Method import

crates/go/src/lib.rs:1008–1230

(
        &mut self,
        resolve: &Resolve,
        func: &Function,
        interface: Option<&WorldKey>,
    )

impl Go {
    fn import(
        &mut self,
        resolve: &Resolve,
        func: &Function,
        interface: Option<&WorldKey>,
    ) -> InterfaceData {
        self.visit_futures_and_streams(true, resolve, func, interface);

        let async_ = self.opts.async_.is_async(resolve, interface, func, true);

        let (variant, prefix) = if async_ {
            (AbiVariant::GuestImportAsync, "[async-lower]")
        } else {
            (AbiVariant::GuestImport, "")
        };

        let sig = resolve.wasm_signature(variant, func);
        let import_name = &func.name;
        let name = func.name.to_snake_case().replace('.', "_");
        let (camel, has_self) = func_declaration(resolve, func);

        let module = match interface {
            Some(name) => resolve.name_world_key(name),
            None => "$root".to_string(),
        };

        let params = sig
            .params
            .iter()
            .enumerate()
            .map(|(i, param)| format!("arg{i} {}", wasm_type(*param)))
            .collect::<Vec<_>>()
            .join(", ");

        let results = match &sig.results[..] {
            [] => "",
            [result] => wasm_type(*result),
            _ => unreachable!(),
        };

        let mut imports = BTreeSet::new();
        let go_params =
            self.func_params(resolve, func, interface, true, &mut imports, has_self, "");
        let go_results = self.func_results(resolve, func, interface, true, &mut imports);

        let raw_name = format!("wasm_import_{name}");

        let go_param_names = has_self
            .then(|| "self".to_string())
            .into_iter()
            .chain(
                func.params
                    .iter()
                    .skip(if has_self { 1 } else { 0 })
                    .map(|Param { name, .. }| name.to_lower_camel_case()),
            )
            .collect::<Vec<_>>();