Method generate_procedure_file

crates/codegen/src/csharp.rs:857–962

(
        &self,
        module: &ModuleDef,
        procedure: &spacetimedb_schema::def::ProcedureDef,
    )

    }

    fn generate_procedure_file(
        &self,
        module: &ModuleDef,
        procedure: &spacetimedb_schema::def::ProcedureDef,
    ) -> OutputFile {
        let mut output = CsharpAutogen::new(
            self.namespace,
            &[
                "SpacetimeDB.ClientApi",
                "System.Collections.Generic",
                "System.Runtime.Serialization",
            ],
            false,
        );

        writeln!(output, "public sealed partial class RemoteProcedures : RemoteBase");
        indented_block(&mut output, |output| {
            let func_name_pascal_case = procedure.accessor_name.deref().to_case(Case::Pascal);
            let delegate_separator = if procedure.params_for_generate.elements.is_empty() {
                ""
            } else {
                ", "
            };

            let (func_params, func_args) =
                build_func_params_and_args(module, procedure.params_for_generate.into_iter(), self.namespace);
            let return_type_str = ty_fmt_with_ns(module, &procedure.return_type_for_generate, self.namespace);
            // Generate the clean public API that users call to allow us of BSATN.Decode<> then reflect to the proper return type
            writeln!(
                output,
                "public void {func_name_pascal_case}({func_params}{delegate_separator}ProcedureCallback<{return_type_str}> callback)"
            );
            indented_block(output, |output| {
                writeln!(output, "// Convert the clean callback to the wrapper callback");
                writeln!(
                    output,
                    "Internal{func_name_pascal_case}({func_args}{delegate_separator}(ctx, result) => {{"
                );

                writeln!(output, "if (result.IsSuccess && result.Value != null)");
                indented_block(output, |output| {
                    writeln!(
                        output,
                        "callback(ctx, ProcedureCallbackResult<{return_type_str}>.Success(result.Value.Value));"
                    );
                });
                writeln!(output, "else");
                indented_block(output, |output| {
                    writeln!(
                        output,
                        "callback(ctx, ProcedureCallbackResult<{return_type_str}>.Failure(result.Error!));"
                    );
                });
                writeln!(output, "}});");
            });
            writeln!(output);

            // Generate the private wrapper method that handles BSATN