Method gen_import_src

crates/csharp/src/interface.rs:678–840

(
        &mut self,
        func: &Function,
        results: &[TypeId],
        parameter_type: ParameterType,
    )

    }

    fn gen_import_src(
        &mut self,
        func: &Function,
        results: &[TypeId],
        parameter_type: ParameterType,
    ) -> (String, String) {
        let mut bindgen = FunctionBindgen::new(
            self,
            func.item_name(),
            &func.kind,
            func.params
                .iter()
                .enumerate()
                .map(|(i, Param { name, .. })| {
                    if i == 0 && matches!(&func.kind, FunctionKind::Method(_)) {
                        "this".to_owned()
                    } else {
                        name.to_csharp_ident()
                    }
                })
                .collect(),
            results.to_vec(),
            parameter_type,
            func.result,
        );

        let async_ = InterfaceGenerator::is_async(&func.kind);
        let mut src: String;

        if async_ {
            // TODO: Use lower_to_memory as per Go ?
            let sig = bindgen
                .interface_gen
                .resolve
                .wasm_signature(AbiVariant::GuestImportAsync, func);

            // TODO: the result is a tmp so could be result/1/2/..  Maybe this will fallout if we use lower_to_memory.
            let async_status_var = "result"; // String::new();
            let requires_async_return_buffer_param = func.result.is_some();
            let async_return_buffer = if requires_async_return_buffer_param {
                let buffer = bindgen.emit_allocation_for_type(&sig.results);
                uwriteln!(
                    bindgen.src,
                    "//TODO: store somewhere with the TaskCompletionSource, possibly in the state, using Task.AsyncState to retrieve it later."
                );
                Some(buffer)
            } else {
                None
            };

            let csharp_param_names = func
                .params
                .iter()
                .map(|param| param.name.to_lower_camel_case())
                .collect::<Vec<_>>();

            let (lower, wasm_params) = if sig.indirect_params {
                todo!("indirect params not supported for async imports yet");