Add export stub generation

Author: QuantumSegfault

crates/d/src/lib.rs

@@ -26,12 +26,14 @@ struct DSig {
 #[derive(Default)]
 struct D {
     used_interfaces: HashSet<(WorldKey, InterfaceId)>,
+    export_stubs: Vec<String>,
 
     interface_imports: Vec<String>,
     interface_exports: Vec<String>,
     type_imports_src: Source,
     function_imports_src: Source,
     function_exports_src: Source,
+    export_stubs_src: Source,
 
     opts: Opts,
 
@@ -57,6 +59,11 @@ pub struct Opts {
     /// Where to place output files
     #[cfg_attr(feature = "clap", arg(skip))]
     out_dir: Option<PathBuf>,
+
+    #[cfg_attr(feature = "clap", arg(long, default_value_t = false))]
+    /// Whether stubs/declarations for exports should be emitted
+    /// Only for testing purposes.
+    emit_export_stubs: bool,
 }
 
 impl Opts {
@@ -313,6 +320,8 @@ impl D {
 
         DInterfaceGenerator {
             src: Source::default(),
+            stub_src: Source::default(),
+            stubs: Vec::default(),
             fqn: "",
             r#gen: self,
             resolve,
@@ -487,7 +496,10 @@ impl WorldGenerator for D {
         types: &[(&str, TypeId)],
         _files: &mut Files,
     ) {
+        let fqn = self.world_fqn.clone();
         let mut r#gen = self.interface(resolve, Some(Direction::Import), None, Some("$root"));
+        r#gen.fqn = &fqn;
+
         for (name, id) in types.iter() {
             r#gen.define_type(name, *id);
         }
@@ -502,7 +514,10 @@ impl WorldGenerator for D {
         funcs: &[(&str, &Function)],
         _files: &mut Files,
     ) {
+        let fqn = self.world_fqn.clone();
         let mut r#gen = self.interface(resolve, Some(Direction::Import), None, Some("$root"));
+        r#gen.fqn = &fqn;
+
         for (_name, func) in funcs {
             r#gen.import_func(func);
         }
@@ -604,12 +619,31 @@ impl WorldGenerator for D {
         let ret_area_decl = r#gen.emit_ret_area_if_needed();
 
         r#gen.src.push_str(&ret_area_decl);
-        r#gen.src.push_str("}\n");
+        r#gen.src.push_str("}\n\n");
+
+        let DInterfaceGenerator {
+            mut src,
+            stub_src,
+            stubs,
+            ..
+        } = r#gen;
+
+        if self.opts.emit_export_stubs {
+            src.append_src(&stub_src);
+
+            src.push_str("alias STUBS = AliasSeq!(\n");
+            src.indent(1);
+            src.push_str(&stubs.join(",\n"));
+            src.deindent(1);
+            src.push_str("\n);\n");
+
+            self.export_stubs.push(format!("{fqn}.STUBS"));
+        }
 
         let mut interface_filepath = PathBuf::from_iter(fqn.split("."));
         interface_filepath.add_extension("d");
 
-        files.push(interface_filepath.to_str().unwrap(), r#gen.src.as_bytes());
+        files.push(interface_filepath.to_str().unwrap(), src.as_bytes());
 
         self.cur_interface = None;
         Ok(())
@@ -622,7 +656,10 @@ impl WorldGenerator for D {
         funcs: &[(&str, &Function)],
         _files: &mut Files,
     ) -> Result<()> {
+        let fqn = self.world_fqn.clone();
         let mut r#gen = self.interface(resolve, Some(Direction::Export), None, Some("$root"));
+        r#gen.fqn = &fqn;
+
         for (_name, func) in funcs {
             match func.kind {
                 FunctionKind::Freestanding | FunctionKind::AsyncFreestanding => {
@@ -634,9 +671,21 @@ impl WorldGenerator for D {
 
         let ret_area_decl = r#gen.emit_ret_area_if_needed();
 
-        self.function_exports_src = take(&mut r#gen.src);
+        let DInterfaceGenerator {
+            src,
+            stub_src,
+            mut stubs,
+            ..
+        } = r#gen;
+
+        self.function_exports_src = src;
         self.function_exports_src.push_str(&ret_area_decl);
 
+        if self.opts.emit_export_stubs {
+            self.export_stubs_src.append_src(&stub_src);
+            self.export_stubs.append(&mut stubs);
+        }
+
         Ok(())
     }
 
@@ -714,6 +763,20 @@ impl WorldGenerator for D {
         world_src.push_str(&self.function_exports_src.as_str());
         world_src.push_str("}\n");
 
+        if self.opts.emit_export_stubs {
+            self.export_stubs_src.push_str("alias STUBS = AliasSeq!(\n");
+            self.export_stubs_src.indent(1);
+            self.export_stubs_src
+                .push_str(&self.export_stubs.join(",\n"));
+            self.export_stubs_src.deindent(1);
+            self.export_stubs_src.push_str("\n);\n");
+
+            self.export_stubs_src
+                .push_str("alias Exports_STUB_INVOKE = Exports!(STUBS);\n");
+
+            world_src.append_src(&self.export_stubs_src);
+        }
+
         let mut world_filepath = PathBuf::from_iter(get_world_fqn(world_id, resolve).split("."));
         world_filepath.push("package.d");
 
@@ -726,6 +789,8 @@ impl WorldGenerator for D {
 
 struct DInterfaceGenerator<'a> {
     src: Source,
+    stub_src: Source,
+    stubs: Vec<String>,
     direction: Option<Direction>,
     r#gen: &'a mut D,
     resolve: &'a Resolve,
@@ -1190,6 +1255,24 @@ impl<'a> DInterfaceGenerator<'a> {
             }
         ));
 
+        if self.r#gen.opts.emit_export_stubs {
+            self.stub_src.push_str(&format!(
+                "@witExport(\"{}\", \"{}\")\n{} {}_STUB({});\n",
+                self.wasm_import_module.unwrap(),
+                func.name,
+                d_sig.result,
+                d_sig.name,
+                d_sig
+                    .arguments
+                    .iter()
+                    .map(|(name, ty)| "in ".to_owned() + ty + " " + name)
+                    .collect::<Vec<String>>()
+                    .join(", ")
+            ));
+
+            self.stubs.push(d_sig.name.clone() + "_STUB");
+        }
+
         self.src.push_str("/// ditto\n");
         self.src.push_str(&format!(
             "@wasmExport!(\"{}#{}\")\n",
@@ -1991,7 +2074,7 @@ impl<'a, 'b> FunctionBindgen<'a, 'b> {
 fn perform_cast(op: &str, cast: &Bitcast) -> String {
     match cast {
         Bitcast::I32ToF32 | Bitcast::I64ToF32 => {
-            format!("cast(uint)({op}).reinterpretCast!float")
+            format!("(cast(uint){op}).reinterpretCast!float")
         }
         Bitcast::F32ToI32 | Bitcast::F32ToI64 => {
             format!("({op}).reinterpretCast!uint")
@@ -2260,13 +2343,14 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> {
                     base,
                 } = self.blocks.pop().unwrap();
                 let arr_src = &operands[0];
+                let arr_dst = &operands[1];
                 let size_str = self.r#gen.sizes.size(element).format("size_t.sizeof");
 
                 self.push_str(&format!(
                     "foreach ({block_element}_idx, const ref {block_element}; {arr_src}) {{\n"
                 ));
                 self.push_str(&format!(
-                    "const auto {base} = {arr_src} + {block_element}_idx * {size_str};\n"
+                    "const auto {base} = {arr_dst} + {block_element}_idx * {size_str};\n"
                 ));
                 self.push_str(&body);
                 self.push_str("\n}\n");

crates/test/src/d.rs

@@ -0,0 +1,131 @@
+use crate::config::StringList;
+use crate::{Compile, LanguageMethods, Runner, Verify};
+use anyhow::{Context, Result};
+use clap::Parser;
+use heck::ToSnakeCase;
+use serde::Deserialize;
+use std::env;
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+#[derive(Default, Debug, Clone, Parser)]
+pub struct DOpts {}
+
+pub struct D;
+
+fn ldc2(runner: &Runner) -> PathBuf {
+    format!("ldc2").into()
+}
+
+impl LanguageMethods for D {
+    fn display(&self) -> &str {
+        "d"
+    }
+
+    fn comment_prefix_for_test_config(&self) -> Option<&str> {
+        Some("//@")
+    }
+
+    fn should_fail_verify(
+        &self,
+        name: &str,
+        config: &crate::config::WitConfig,
+        _args: &[String],
+    ) -> bool {
+        config.async_ || config.error_context
+    }
+
+    fn default_bindgen_args_for_codegen(&self) -> &[&str] {
+        &["--emit-export-stubs"]
+    }
+
+    fn prepare(&self, runner: &mut Runner) -> Result<()> {
+        prepare(runner, ldc2(runner))
+    }
+
+    fn compile(&self, runner: &Runner, c: &Compile<'_>) -> Result<()> {
+        compile(runner, c, ldc2(runner))
+    }
+
+    fn verify(&self, runner: &Runner, v: &Verify<'_>) -> Result<()> {
+        verify(runner, v, ldc2(runner))
+    }
+}
+
+fn prepare(runner: &mut Runner, compiler: PathBuf) -> Result<()> {
+    let cwd = env::current_dir()?;
+    let dir = cwd.join(&runner.opts.artifacts).join("d");
+
+    super::write_if_different(&dir.join("test.d"), "extern(C) void _start() {}")?;
+
+    println!("Testing if `{}` works...", compiler.display());
+    runner
+        .run_command(
+            Command::new(&compiler)
+                .current_dir(&dir)
+                .arg("-mtriple=wasm32-unknown-unknown")
+                .arg("-betterC")
+                .arg("test.d"),
+        )
+        .inspect_err(|_| {
+            eprintln!("Error: failed to find `{}`.", compiler.display());
+        })?;
+
+    Ok(())
+}
+
+fn search_for_world_package(bindings_root: &Path) -> Option<PathBuf> {
+    // Look for a package.d generated from a world nested at wit/*/*/*/package.d
+
+    // TODO: If we had access to the full package+version of the world being
+    // generated, we wouldn't need to search.
+
+    // ./wit/*
+    fs::read_dir(bindings_root.join("wit"))
+        .ok()?
+        .flatten()
+        .map(|e| e.path())
+        .filter(|p| p.is_dir())
+        // ./wit/*/*
+        .filter_map(|p| fs::read_dir(p).ok())
+        .flatten()
+        .flatten()
+        .map(|e| e.path())
+        .filter(|p| p.is_dir())
+        // ./wit/*/*/*
+        .filter_map(|p| fs::read_dir(p).ok())
+        .flatten()
+        .flatten()
+        .map(|e| e.path())
+        .filter(|p| p.is_dir())
+        // ./wit/*/*/*/package.d
+        .filter_map(|p| fs::read_dir(p).ok())
+        .flatten()
+        .flatten()
+        .map(|e| e.path())
+        .find(|p| p.is_file() && p.file_name().unwrap() == "package.d")
+}
+
+fn compile(runner: &Runner, compile: &Compile<'_>, compiler: PathBuf) -> Result<()> {
+    todo!();
+}
+
+fn verify(runner: &Runner, verify: &Verify<'_>, compiler: PathBuf) -> Result<()> {
+    let mut cmd = Command::new(compiler);
+
+    let world_path = search_for_world_package(verify.bindings_dir).unwrap();
+
+    cmd.arg(world_path)
+        .arg("-betterC")
+        .arg("-mtriple=wasm32-unknown-unknown")
+        .arg("-I")
+        .arg(&verify.bindings_dir)
+        .arg("-i") // compile included dependencies
+        .arg("-c") // compile only
+        .arg("--de") // deperecations are errors
+        .arg("-w") // warnigns are errors
+        .arg("-of")
+        .arg(verify.artifacts_dir.join("tmp.o"));
+    runner.run_command(&mut cmd)
+}