Method import

crates/moonbit/src/lib.rs:591–695

(&mut self, func: &Function)

    }

    fn import(&mut self, func: &Function) {
        // Determine if the function 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();
        }

        let ffi_import_name = format!("wasmImport{}", func.name.to_upper_camel_case());
        let mut bindgen = FunctionBindgen::new(
            self,
            func.params
                .iter()
                .map(|Param { name, .. }| name.to_moonbit_ident())
                .collect(),
        );

        abi::call(
            bindgen.interface_gen.resolve,
            AbiVariant::GuestImport,
            LiftLower::LowerArgsLiftResults,
            func,
            &mut bindgen,
            false,
        );

        let mut src = bindgen.src.clone();

        let cleanup_list = if bindgen.needs_cleanup_list {
            "let cleanup_list : Array[Int] = []"
        } else {
            ""
        };

        let mbt_sig = self.world_gen.pkg_resolver.mbt_sig(self.name, func, false);
        let sig = self.sig_string(&mbt_sig, async_);

        // Generate the core wasm abi
        let wasm_sig = self.resolve.wasm_signature(
            if async_ {
                AbiVariant::GuestImportAsync
            } else {
                AbiVariant::GuestImport
            },
            func,
        );
        let (import_module, import_name) = self.resolve.wasm_import_name(
            ManglingAndAbi::Legacy(if async_ {
                LiftLowerAbi::AsyncCallback
            } else {
                LiftLowerAbi::Sync
            }),
            WasmImport::Func {
                interface: self.interface,
                func,