Method import

crates/csharp/src/interface.rs:487–609

(&mut self, import_module_name: &str, func: &Function)

    }

    pub(crate) fn import(&mut self, import_module_name: &str, func: &Function) {
        let camel_name = match &func.kind {
            FunctionKind::Freestanding
            | FunctionKind::Static(_)
            | FunctionKind::AsyncFreestanding
            | FunctionKind::AsyncStatic(_) => func.item_name().to_upper_camel_case(),
            FunctionKind::Method(_) | FunctionKind::AsyncMethod(_) => {
                func.item_name().to_upper_camel_case()
            }
            FunctionKind::Constructor(id) => {
                self.csharp_gen.all_resources[id].name.to_upper_camel_case()
            }
        };

        let access = self.csharp_gen.access_modifier();

        let modifiers = modifiers(func, &camel_name, Direction::Import);

        let interop_camel_name = func.item_name().to_upper_camel_case();

        let sig = self.resolve.wasm_signature(AbiVariant::GuestImport, func);

        let is_async = matches!(
            func.kind,
            FunctionKind::AsyncFreestanding
                | FunctionKind::AsyncStatic(_)
                | FunctionKind::AsyncMethod(_)
        );

        let mut wasm_result_type = match &sig.results[..] {
            [] => {
                if is_async {
                    "uint"
                } else {
                    "void"
                }
            }
            [result] => crate::world_generator::wasm_type(*result),
            _ => unreachable!(),
        };

        let (result_type, results) = self.func_payload_and_return_type(func);

        let is_async = InterfaceGenerator::is_async(&func.kind);

        let requires_async_return_buffer_param = is_async && !sig.results.is_empty();
        let sig_unsafe = if requires_async_return_buffer_param {
            "unsafe "
        } else {
            ""
        };

        let wasm_params: String = {
            let param_list = sig
                .params
                .iter()
                .enumerate()
                .map(|(i, param)| {