Method export

crates/moonbit/src/lib.rs:697–987

(&mut self, func: &Function)

    }

    fn export(&mut self, func: &Function) {
        // Determine if is async
        let async_ = self
            .world_gen
            .opts
            .async_
            .is_async(self.resolve, self.interface, func, false);
        if async_ {
            self.world_gen.async_support.mark_async();
        }

        // Generate declarations for user implementations.
        {
            let mbt_sig = self.world_gen.pkg_resolver.mbt_sig(self.name, func, false);
            let func_sig = self.sig_string(&mbt_sig, async_);

            print_docs(&mut self.src, &func.docs);
            uwrite!(
                self.src,
                r#"
                declare {func_sig}
                "#
            );
        }

        // Generate the caller function
        let variant = if async_ {
            AbiVariant::GuestExportAsync
        } else {
            AbiVariant::GuestExport
        };

        let sig = self.resolve.wasm_signature(variant, func);

        let mut bindgen = FunctionBindgen::new(
            self,
            (0..sig.params.len()).map(|i| format!("p{i}")).collect(),
        );

        abi::call(
            bindgen.interface_gen.resolve,
            variant,
            LiftLower::LiftArgsLowerResults,
            func,
            &mut bindgen,
            async_,
        );

        // TODO: adapt async cleanup
        assert!(!bindgen.needs_cleanup_list);

        // Async functions deferred task return
        let deferred_task_return = bindgen.deferred_task_return.clone();

        let src = bindgen.src;

        let result_type = match &sig.results[..] {
            [] => "Unit",