Separate start and initialization

Author: daxpedda

crates/cli-support/src/js/mod.rs

@@ -62,6 +62,8 @@ pub struct Context<'a> {
 
     /// A flag to track if the stack pointer setter shim has been injected.
     stack_pointer_shim_injected: bool,
+
+    start_found: bool,
 }
 
 #[derive(Default)]
@@ -93,6 +95,7 @@ impl<'a> Context<'a> {
         config: &'a Bindgen,
         wit: &'a NonstandardWitSection,
         aux: &'a WasmBindgenAux,
+        start_found: bool,
     ) -> Result<Context<'a>, Error> {
         Ok(Context {
             globals: String::new(),
@@ -113,6 +116,7 @@ impl<'a> Context<'a> {
             memories: Default::default(),
             table_indices: Default::default(),
             stack_pointer_shim_injected: false,
+            start_found,
         })
     }
 
@@ -854,9 +858,8 @@ impl<'a> Context<'a> {
                     wasm = instance.exports;
                     init.__wbindgen_wasm_module = module;
                     {init_memviews}
-                    if (start == true) {{
-                        {start}
-                    }}
+                    {start}
+                    {main}
                     return wasm;
                 }}
 
@@ -906,6 +909,11 @@ impl<'a> Context<'a> {
             } else {
                 ""
             },
+            main = if needs_manual_start && self.start_found {
+                "if (start == true) { wasm.__wbindgen_main(); }"
+            } else {
+                ""
+            },
             imports_init = imports_init,
         );
 

crates/cli-support/src/lib.rs

@@ -359,7 +359,7 @@ impl Bindgen {
         // auxiliary section for all sorts of miscellaneous information and
         // features #[wasm_bindgen] supports that aren't covered by wasm
         // interface types.
-        wit::process(
+        let wit::ProcessResult { start_found, .. } = wit::process(
             &mut module,
             self.externref,
             self.wasm_interface_types,
@@ -441,7 +441,7 @@ impl Bindgen {
                 .customs
                 .delete_typed::<wit::NonstandardWitSection>()
                 .unwrap();
-            let mut cx = js::Context::new(&mut module, self, &adapters, &aux)?;
+            let mut cx = js::Context::new(&mut module, self, &adapters, &aux, start_found)?;
             cx.generate()?;
             let (js, ts, start) = cx.finalize(stem)?;
             Generated::Js(JsGenerated {

crates/cli-support/src/wit/mod.rs

@@ -43,12 +43,18 @@ struct InstructionBuilder<'a, 'b> {
     return_position: bool,
 }
 
+pub struct ProcessResult {
+    pub adapters: NonstandardWitSectionId,
+    pub aux: WasmBindgenAuxId,
+    pub start_found: bool,
+}
+
 pub fn process(
     module: &mut Module,
     externref_enabled: bool,
     wasm_interface_types: bool,
     support_start: bool,
-) -> Result<(NonstandardWitSectionId, WasmBindgenAuxId), Error> {
+) -> Result<ProcessResult, Error> {
     let mut storage = Vec::new();
     let programs = extract_programs(module, &mut storage)?;
 
@@ -88,7 +94,11 @@ pub fn process(
 
     let adapters = cx.module.customs.add(cx.adapters);
     let aux = cx.module.customs.add(cx.aux);
-    Ok((adapters, aux))
+    Ok(ProcessResult {
+        adapters,
+        aux,
+        start_found: cx.start_found,
+    })
 }
 
 impl<'a> Context<'a> {
@@ -476,22 +486,7 @@ impl<'a> Context<'a> {
             return Ok(());
         }
 
-        let prev_start = match self.module.start {
-            Some(f) => f,
-            None => {
-                self.module.start = Some(id);
-                return Ok(());
-            }
-        };
-
-        // Note that we call the previous start function, if any, first. This is
-        // because the start function currently only shows up when it's injected
-        // through thread/externref transforms. These injected start functions
-        // need to happen before user code, so we always schedule them first.
-        let mut builder = walrus::FunctionBuilder::new(&mut self.module.types, &[], &[]);
-        builder.func_body().call(prev_start).call(id);
-        let new_start = builder.finish(Vec::new(), &mut self.module.funcs);
-        self.module.start = Some(new_start);
+        self.module.exports.add("__wbindgen_main", id);
         Ok(())
     }