Method generate_function

cmd/gravity/src/codegen/exports.rs:34–81

Generate the Go function code for the given function. The signature is obtained by: - getting the function parameters from the `wit_parser::Function`, converting names to to Go identifiers and types to Go types. - similar for the result To implement the body, we: - creating a `Func` struct which implements `Bindgen` and passing it to the `wit_bindgen_core::abi::call` function. This will call `Fu

(&self, func: &Function, tokens: &mut Tokens<Go>)

    ///   times, one for each instruction in the function, and `Func::emit` will generate
    ///   Go code for each instruction
    fn generate_function(&self, func: &Function, tokens: &mut Tokens<Go>) {
        let params = func
            .params
            .iter()
            .map(
                |Param { name, ty, .. }| match crate::resolve_param_type(ty, self.config.resolve) {
                    GoType::ValueOrOk(t) => (GoIdentifier::local(name), *t),
                    t => (GoIdentifier::local(name), t),
                },
            )
            .collect::<Vec<_>>();

        let result = if let Some(wit_type) = &func.result {
            GoResult::Anon(crate::resolve_type(wit_type, self.config.resolve))
        } else {
            GoResult::Empty
        };

        let mut f = crate::Func::export(result, self.config.sizes);
        wit_bindgen_core::abi::call(
            self.config.resolve,
            wit_bindgen_core::abi::AbiVariant::GuestExport,
            wit_bindgen_core::abi::LiftLower::LowerArgsLiftResults,
            func,
            &mut f,
            // async is not currently supported
            false,
        );

        let arg_assignments = f
            .args()
            .iter()
            .zip(&params)
            .map(|(arg, (param, _))| (arg, param))
            .collect::<Vec<_>>();
        let fn_name = &GoIdentifier::public(&func.name);
        quote_in! { *tokens =>
            $['\n']
            func (i *$(self.config.instance)) $fn_name(
                $['\r']
                ctx $CONTEXT_CONTEXT,
                $(for (name, typ) in &params join ($['\r']) => $name $typ,)
            ) $(f.result()) {
                $(for (arg, param) in arg_assignments join ($['\r']) => $arg := $param)
                $(f.body())
            }
        }
    }
}

impl FormatInto<Go> for ExportGenerator<'_> {