tests through records and fixes

Author: QuantumSegfault

crates/d/src/lib.rs

@@ -1280,7 +1280,7 @@ impl<'a> DInterfaceGenerator<'a> {
             self.src.push_str("static ");
         }
         self.src.push_str(&format!(
-            "{} {}({}) @nogc nothrow {{\n",
+            "{} {}({}) @trusted nothrow {{\n",
             d_sig.result,
             d_sig.name,
             d_sig
@@ -1353,7 +1353,7 @@ impl<'a> DInterfaceGenerator<'a> {
             self.src.push_str("static ");
         }
         self.src.push_str(&format!(
-            "private extern(C) {} __import_{}({}) @nogc nothrow;\n",
+            "private extern(C) {} __import_{}({}) nothrow;\n",
             match wasm_sig.results.len() {
                 0 => "void",
                 1 => wasm_type(wasm_sig.results[0]),
@@ -1727,11 +1727,9 @@ impl<'a> InterfaceGenerator<'a> for DInterfaceGenerator<'a> {
 
                 self.src.push_str(&format!(
                     "struct {escaped_name} {{
-    @nogc nothrow:
-
     package({}) uint __handle = 0;
 
-    package({0}) this(uint handle) {{
+    package({0}) this(uint handle) @safe @nogc nothrow {{
         __handle = handle;
     }}
 
@@ -1782,8 +1780,9 @@ impl<'a> InterfaceGenerator<'a> for DInterfaceGenerator<'a> {
                     }
                 }
 
-                self.src
-                    .push_str("\nvoid drop() {\n__import_drop(__handle);\n}\n");
+                self.src.push_str(
+                    "\nvoid drop() @trusted @nogc nothrow {\n__import_drop(__handle);\n}\n",
+                );
                 self.src.push_str(&format!(
                     "@wasmImport!(\"{}\", \"[resource-drop]{}\")\n",
                     self.wasm_import_module.unwrap(),
@@ -1797,8 +1796,9 @@ impl<'a> InterfaceGenerator<'a> for DInterfaceGenerator<'a> {
                         .replace("-", "_"),
                     name.replace("-", "_")
                 ));
-                self.src
-                    .push_str("static private extern(C) void __import_drop(uint);\n\n");
+                self.src.push_str(
+                    "static private extern(C) void __import_drop(uint) @nogc nothrow;\n\n",
+                );
                 self.src.push_str("alias witFree = drop;\n");
 
                 self.src.push_str(&format!(
@@ -1808,18 +1808,16 @@ impl<'a> InterfaceGenerator<'a> for DInterfaceGenerator<'a> {
     alias borrow this;
 
     struct Borrow {{
-    @nogc nothrow:
-
     package({}) uint __handle = 0;
 
-    package({0}) this(uint handle) {{
+    package({0}) this(uint handle) @safe @nogc nothrow {{
         __handle = handle;
     }}
 
     @disable this();
 
-    void witFree() {{}}
-    Borrow witClone() const {{ return Borrow(__handle); }}
+    void witFree() @safe @nogc nothrow {{}}
+    Borrow witClone() const @safe @nogc nothrow {{ return Borrow(__handle); }}
                 ",
                     self.r#gen.root_pkg
                 ));
@@ -1883,11 +1881,9 @@ impl<'a> InterfaceGenerator<'a> for DInterfaceGenerator<'a> {
 
                     self.src.push_str(&format!(
                         "struct {escaped_name} {{
-        @nogc nothrow:
-
         package({}) uint __handle = 0;
 
-        package({0}) this(uint handle) {{
+        package({0}) this(uint handle) @safe @nogc nothrow {{
             __handle = handle;
         }}
 
@@ -1899,6 +1895,8 @@ impl<'a> InterfaceGenerator<'a> for DInterfaceGenerator<'a> {
                     self.src.push_str(&format!(
                         "
                         static {escaped_name} makeNew(T)(scope void delegate(out T) dg) if (is(T == struct)) {{
+                        if (dg is null) return {escaped_name}.init;
+
                         auto ptr = cast(T*)malloc(T.sizeof);
                         if (ptr is null) return {escaped_name}.init;
 
@@ -1908,7 +1906,7 @@ impl<'a> InterfaceGenerator<'a> for DInterfaceGenerator<'a> {
                         ",
                     ));
                     self.src.push_str(&format!(
-                        "@wasmImport!(\"{}\", \"[resource-new]{}\")\n",
+                        "@wasmImport!(\"[export]{}\", \"[resource-new]{}\")\n",
                         self.wasm_import_module.unwrap(),
                         name
                     ));
@@ -1924,9 +1922,9 @@ impl<'a> InterfaceGenerator<'a> for DInterfaceGenerator<'a> {
                         .push_str("static private extern(C) uint __import_makeNew(void*);\n\n");
 
                     self.src
-                        .push_str("T* rep(T)() if (is(T == struct)) {\nreturn cast(T*)__import_rep(__handle);\n}\n");
+                        .push_str("T* rep(T)() @nogc nothrow if (is(T == struct)) {\nreturn cast(T*)__import_rep(__handle);\n}\n");
                     self.src.push_str(&format!(
-                        "@wasmImport!(\"{}\", \"[resource-rep]{}\")\n",
+                        "@wasmImport!(\"[export]{}\", \"[resource-rep]{}\")\n",
                         self.wasm_import_module.unwrap(),
                         name
                     ));
@@ -1941,10 +1939,11 @@ impl<'a> InterfaceGenerator<'a> for DInterfaceGenerator<'a> {
                     self.src
                         .push_str("static private extern(C) void __import_rep(uint);\n\n");
 
-                    self.src
-                        .push_str("void drop() {\n__import_drop(__handle);\n}\n");
+                    self.src.push_str(
+                        "void drop() @trusted @nogc nothrow {\n__import_drop(__handle);\n}\n",
+                    );
                     self.src.push_str(&format!(
-                        "@wasmImport!(\"{}\", \"[resource-drop]{}\")\n",
+                        "@wasmImport!(\"[export]{}\", \"[resource-drop]{}\")\n",
                         self.wasm_import_module.unwrap(),
                         name
                     ));
@@ -1956,28 +1955,27 @@ impl<'a> InterfaceGenerator<'a> for DInterfaceGenerator<'a> {
                             .replace("-", "_"),
                         name.replace("-", "_")
                     ));
-                    self.src
-                        .push_str("static private extern(C) void __import_drop(uint);\n\n");
+                    self.src.push_str(
+                        "static private extern(C) void __import_drop(uint) @nogc nothrow;\n\n",
+                    );
                     self.src.push_str("alias witFree = drop;\n");
 
                     self.src.push_str(&format!(
                         "// TODO: make RAII? disable copy for the own
-        Borrow borrow() => Borrow(__handle);
+        Borrow borrow() @safe @nogc nothrow => Borrow(__handle);
         alias borrow this;
 
         struct Borrow {{
-            @nogc nothrow:
-
             package({}) uint __handle = 0;
 
-            package({0}) this(uint handle) {{
+            package({0}) this(uint handle) @safe @nogc nothrow {{
                 __handle = handle;
             }}
 
             @disable this();
 
-            void witFree() {{}}
-            Borrow witClone() const {{ return Borrow(__handle); }}
+            void witFree() @safe @nogc nothrow {{}}
+            Borrow witClone() const @safe @nogc nothrow {{ return Borrow(__handle); }}
 
                         ",
                         self.r#gen.root_pkg
@@ -3106,9 +3104,9 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> {
                     bool {is_some} = ({op0}) != 0;
                     if ({is_some}) {{
                         {some}
-                        {resultname} = {type_name}.some({some_value});
+                        {resultname} = {type_name}.makeSome({some_value});
                     }} else {{
-                        {resultname} = {type_name}.none;
+                        {resultname} = {type_name}.makeNone;
                     }}
                     "
                 ));

crates/d/src/wit_common.d

@@ -145,11 +145,11 @@ private:
         _value = value;
     }
 public:
-    static inout(Option) some(inout T value) @safe @nogc nothrow {
+    static inout(Option) makeSome(inout T value) @safe @nogc nothrow {
         return inout Option(true, value);
     }
 
-    static Option none() @safe @nogc nothrow {
+    static Option makeNone() @safe @nogc nothrow {
         return Option(false, T.init);
     }
 
@@ -169,11 +169,11 @@ public:
 }
 
 auto some(T)(inout T value) @safe @nogc nothrow {
-    return Option!T.some(value);
+    return Option!T.makeSome(value);
 }
 
 auto none(T)() @safe @nogc nothrow {
-    return Option!T.none;
+    return Option!T.makeNone;
 }
 
 /// Based on Rust's Result
@@ -256,12 +256,12 @@ void witFree(T : Option!U, U)(scope ref T val) {
 T witClone(T : Option!U, U)(in T val) {
     if (val.isSome) {
         static if (!is(U == void)) {
-            return T.some(val.unwrap.witClone);
+            return T.makeSome(val.unwrap.witClone);
         } else {
-            return T.some;
+            return T.makeSome;
         }
     } else {
-        return T.none;
+        return T.makeNone;
     }
 }
 

tests/runtime/lists-alias/runner.d

@@ -0,0 +1,16 @@
+import wit.my.lists.runner;
+import cat = wit.my.lists.runner.imports.cat;
+import wit.common;
+
+@witExport("$root", "run")
+void run() {
+    cat.foo((cast(immutable ubyte[])"hello").witList);
+
+    WitList!ubyte t = cat.bar();
+    scope(exit) t.witFree;
+    assert(t == (cast(immutable ubyte[])"world").witList);
+}
+
+alias Exports = wit.my.lists.runner.Exports!(
+    run
+);

tests/runtime/lists-alias/test.d

@@ -0,0 +1,17 @@
+import wit.my.lists.test;
+import wit.common;
+
+@witExport("cat", "foo")
+void foo(in WitList!ubyte x) {
+    assert(x == (cast(immutable ubyte[])"hello").witList);
+}
+
+@witExport("cat", "bar")
+WitList!ubyte bar() {
+    return (cast(immutable ubyte[])"world").witList.witClone;
+}
+
+alias Exports = wit.my.lists.test.Exports!(
+    foo,
+    bar
+);

tests/runtime/many-arguments/runner.d

@@ -0,0 +1,11 @@
+import wit.test.many_arguments.runner;
+import wit.common;
+
+@witExport("$root", "run")
+void run() {
+    manyArguments(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+}
+
+alias Exports = wit.test.many_arguments.runner.Exports!(
+    run
+);

tests/runtime/many-arguments/test.d

@@ -0,0 +1,16 @@
+import wit.test.many_arguments.test;
+import wit.common;
+
+import std.meta : Repeat, AliasSeq;
+
+@witExport("test:many-arguments/to-test", "many-arguments")
+void manyArguments(Repeat!(16, ulong) args) {
+    assert(args == AliasSeq!(
+        1,  2,  3,  4,  5,  6,  7,  8,
+        9,  10, 11, 12, 13, 14, 15, 16
+    ));
+}
+
+alias Exports = wit.test.many_arguments.test.Exports!(
+    manyArguments
+);

tests/runtime/numbers/runner.d

@@ -0,0 +1,50 @@
+import wit.test.numbers.runner;
+import wit.common;
+
+void doAsserts(alias func)() {
+    static if(is(typeof(func) P == function)) {
+        alias T = P[0];
+        static if (is(T == dchar)) {
+            enum T a = 'a';
+            enum T b = ' ';
+            enum T c = '🚩';
+        } else static if (__traits(isFloating, T)) {
+            enum T a = 1.0;
+            enum T b = -T.infinity;
+            enum T c = T.infinity;
+        } else {
+            enum T a = 1;
+            enum T b = T.min;
+            enum T c = T.max;
+        }
+    }
+
+    assert(func(a) == a);
+    assert(func(b) == b);
+    assert(func(c) == c);
+}
+
+@witExport("$root", "run")
+void run() {
+    doAsserts!roundtripU8;
+    doAsserts!roundtripS8;
+    doAsserts!roundtripU16;
+    doAsserts!roundtripS16;
+    doAsserts!roundtripU32;
+    doAsserts!roundtripS32;
+    doAsserts!roundtripU64;
+    doAsserts!roundtripS64;
+    doAsserts!roundtripF32;
+    doAsserts!roundtripF64;
+    doAsserts!roundtripChar;
+
+    setScalar(2);
+    assert(getScalar() == 2);
+
+    setScalar(4);
+    assert(getScalar() == 4);
+}
+
+alias Exports = wit.test.numbers.runner.Exports!(
+    run
+);

tests/runtime/numbers/test.d

@@ -0,0 +1,32 @@
+import wit.test.numbers.test;
+import wit.common;
+
+template roundtrip(T, string suffix) {
+    @witExport("test:numbers/numbers", "roundtrip-"~suffix)
+    T roundtrip(T val) => val;
+}
+
+uint scalar;
+
+@witExport("test:numbers/numbers", "get-scalar")
+auto getScalar() => scalar;
+
+@witExport("test:numbers/numbers", "set-scalar")
+void setScalar(uint val) { scalar = val; }
+
+alias Exports = wit.test.numbers.test.Exports!(
+    roundtrip!(ubyte, "u8"),
+    roundtrip!(byte, "s8"),
+    roundtrip!(ushort, "u16"),
+    roundtrip!(short, "s16"),
+    roundtrip!(uint, "u32"),
+    roundtrip!(int, "s32"),
+    roundtrip!(ulong, "u64"),
+    roundtrip!(long, "s64"),
+    roundtrip!(float, "f32"),
+    roundtrip!(double, "f64"),
+    roundtrip!(dchar, "char"),
+
+    getScalar,
+    setScalar
+);