Method export

crates/csharp/src/interface.rs:842–1145

(&mut self, func: &Function, interface_key: Option<&WorldKey>)

    }

    pub(crate) fn export(&mut self, func: &Function, interface_key: Option<&WorldKey>) {
        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 modifiers = modifiers(func, &camel_name, Direction::Export);

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

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

        let mut bindgen = FunctionBindgen::new(
            self,
            func.item_name(),
            &func.kind,
            (0..sig.params.len()).map(|i| format!("p{i}")).collect(),
            results,
            ParameterType::ABI,
            func.result,
        );

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

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

        let src = bindgen.src;
        let resource_type_name = bindgen.resource_type_name;

        let vars = bindgen
            .resource_drops
            .iter()
            .map(|(t, v)| format!("{t}? {v} = null;"))
            .collect::<Vec<_>>()
            .join(";\n");

        let wasm_result_type = if async_ {
            "int"