flavorful test and cast removals

Author: QuantumSegfault

crates/d/src/lib.rs

@@ -826,10 +826,6 @@ impl WorldGenerator for D {
             let world_name = &world.name;
             let pkg = &resolve.packages[world.package.unwrap()].name;
             let version = env!("CARGO_PKG_VERSION");
-            world_src.push_str(&format!(
-                "\n@(imported!\"ldc.attributes\".section(\"component-type:wit-bindgen:{version}:\
-                 {pkg}:{world_name}:{opts_suffix}\"))\n"
-            ));
 
             let mut producers = wasm_metadata::Producers::empty();
             producers.add(
@@ -848,7 +844,7 @@ impl WorldGenerator for D {
 
             world_src.push_str(&format!(
                 "
-                void __wit_bindgen_component_types() {{
+                void __wit_bindgen_component_type() {{
                     imported!\"ldc.llvmasm\".__irEx!(
                         \"\",
                         \"\",

crates/d/src/wit_common.d

@@ -18,8 +18,9 @@ struct WitList(T) {
     T* ptr;
     size_t length;
 
-    this(T[] slice) @trusted {
-        this = slice;
+    this(inout T[] slice) inout @trusted {
+        ptr = slice.ptr;
+        length = slice.length;
     }
 
     void opAssign(T[] slice) @trusted {
@@ -35,8 +36,7 @@ struct WitList(T) {
     bool opEquals(in T[] other) const => this[] == other;
     size_t toHash() const => this[].hashOf;
 }
-auto witList(T : U[], U)(T slice) => WitList!U(slice);
-
+auto witList(T : U[], U)(inout T slice) => inout WitList!U(slice);
 
 // WIT ABI for string matches List,
 // except list<char> in WIT is actually List!(dchar)
@@ -140,17 +140,17 @@ private:
     bool _present = false;
     T _value;
 
-    this(bool present, T value = T.init) @safe @nogc nothrow {
+    this(bool present, inout T value) inout @safe @nogc nothrow {
         _present = present;
         _value = value;
     }
 public:
-    static Option some(T value) @safe @nogc nothrow {
-        return Option(true, value);
+    static inout(Option) some(inout T value) @safe @nogc nothrow {
+        return inout Option(true, value);
     }
 
     static Option none() @safe @nogc nothrow {
-        return Option(false);
+        return Option(false, T.init);
     }
 
     bool isSome() const @safe @nogc nothrow => _present;
@@ -168,12 +168,12 @@ public:
     { return _present ? _value : fallback(); }
 }
 
-auto some(T)(T value) @safe @nogc nothrow {
+auto some(T)(inout T value) @safe @nogc nothrow {
     return Option!T.some(value);
 }
 
-auto none(T)(T value) @safe @nogc nothrow {
-    return Option!T.some(value);
+auto none(T)() @safe @nogc nothrow {
+    return Option!T.none;
 }
 
 /// Based on Rust's Result
@@ -192,7 +192,7 @@ private:
     }
     Storage _storage;
 
-    this(bool hasError, Storage storage) @safe @nogc nothrow {
+    this(bool hasError, inout(Storage) storage) inout @safe @nogc nothrow {
         _hasError = hasError;
         _storage = storage;
     }
@@ -201,22 +201,22 @@ public:
     static if (is(T == void)) {
         static Result ok() @safe @nogc nothrow => Result(false, Storage.init);
     } else {
-        static Result ok(T value) @trusted @nogc nothrow {
+        static Result ok(inout(T) value) @trusted @nogc nothrow {
             Storage newStorage = Storage.init;
-            newStorage.value = value;
+            newStorage.value = cast(T)value;
 
-            return Result(false, newStorage);
+            return Result(false, cast(inout Storage)newStorage);
         }
     }
 
     static if (is(E == void)) {
         static Result err() @safe @nogc nothrow => Result(true, Storage.init);
     } else {
-        static Result err(E error) @trusted @nogc nothrow {
+        static inout(Result) err(inout(E) error) @trusted @nogc nothrow {
             Storage newStorage = Storage.init;
-            newStorage.error = error;
+            newStorage.error = cast(E)error;
 
-            return Result(true, newStorage);
+            return inout Result(true, cast(inout Storage)newStorage);
         }
     }
 
@@ -320,6 +320,20 @@ T witClone(T : Tuple!U, U...)(in T val) {
     return clone;
 }
 
+
+void witFree(T : U[L], U, size_t L)(scope ref T val) {
+    foreach (ref e; val) {
+        e.witFree;
+    }
+}
+T witClone(T : U[L], U, size_t L)(in T val) {
+    T clone;
+    foreach (i, ref e; clone) {
+        e = val[i].witClone;
+    }
+    return clone;
+}
+
 package(wit):
 
 extern(C) {

crates/test/src/d.rs

@@ -111,13 +111,13 @@ fn compile(runner: &Runner, compile: &Compile<'_>, compiler: PathBuf) -> Result<
     cmd.arg(&compile.component.path)
         .arg("-betterC")
         .arg("-mtriple=wasm32-unknown-unknown")
+        .arg("-fvisibility=hidden") // important to make sure unused symbols don't get linked
         .arg("-I")
         .arg(&compile.bindings_dir)
         .arg("-i") // compile included dependencies
         .arg("--de") // deperecations are errors
         .arg("-w") // warnings are errors
         .arg("-L--no-entry")
-        .arg("-L--no-export-dynamic")
         .arg("--d-version=WitBindings_DummyLibc") // to provide bump allocator and `abort`
         .arg("--checkaction=halt") // to trap instead of using libc __assert
         .arg("-of")

tests/runtime/flavorful/runner.d

@@ -13,7 +13,7 @@ void run() {
     }
 
     {
-        auto result = fListInRecord3(ListInRecord3(a: cast(WitString)"list_in_record3 input".witList));
+        auto result = fListInRecord3(const ListInRecord3("list_in_record3 input".witList));
         scope(exit) result.witFree;
 
         assert(
@@ -23,7 +23,7 @@ void run() {
     }
 
     {
-        auto result = fListInRecord4(ListInAlias(a: cast(WitString)"input4".witList));
+        auto result = fListInRecord4(const ListInAlias("input4".witList));
         scope(exit) result.witFree;
 
         assert(
@@ -32,7 +32,7 @@ void run() {
         );
     }
 
-    fListInVariant1(some(cast(WitString)"foo".witList), Result!(void, WitString).err(cast(WitString)"bar".witList));
+    fListInVariant1(some("foo".witList), Result!(void, WitString).err("bar".witList));
 
     {
         auto result = fListInVariant2();
@@ -41,17 +41,17 @@ void run() {
 
         assert(
             result
-            == some(cast(WitString)"list_in_variant2".witList)
+            == some("list_in_variant2".witList)
         );
     }
 
     {
-        auto result = fListInVariant3(some(cast(WitString)"input3".witList));
+        auto result = fListInVariant3(some("input3".witList));
         scope(exit) result.witFree;
 
         assert(
             result
-            == some(cast(WitString)"output3".witList)
+            == some("output3".witList)
         );
     }
 
@@ -62,8 +62,8 @@ void run() {
     assert(errnoResult().isOk);
 
     {
-        WitString[1] input = [cast(WitString)"typedef2".witList];
-        auto result = listTypedefs(cast(WitString)"typedef1".witList, input[].witList);
+        immutable WitString[1] input = ["typedef2".witList];
+        auto result = listTypedefs("typedef1".witList, input[].witList);
         scope(exit) result.witFree;
 
         assert(result[0] == (cast(ubyte[])"typedef3").witList);
@@ -72,12 +72,19 @@ void run() {
     }
 
     {
-        bool[2] input1 = [true, false];
-        Result!(void, void)[2] input2 = [Result!(void, void).ok(), Result!(void, void).err()];
-        MyErrno[2] input3 = [MyErrno.success, MyErrno.a];
+        static immutable bool[] input1 = [true, false];
+        static immutable Result!()[] input2 = [Result!().ok, Result!().err];
+        static immutable MyErrno[] input3 = [MyErrno.success, MyErrno.a];
 
         auto result = listOfVariants(input1[].witList, input2[].witList, input3[].witList);
         scope(exit) result.witFree;
+
+        static immutable bool[] output1 = [false, true];
+        static immutable Result!()[] output2 = [Result!().err, Result!().ok];
+        static immutable MyErrno[] output3 = [MyErrno.a, MyErrno.b];
+        assert(result[0] == output1);
+        assert(result[1] == output2);
+        assert(result[2] == output3);
     }
 }