Method generate_procedure_file

crates/codegen/src/unrealcpp.rs:622–786

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

    }

    fn generate_procedure_file(
        &self,
        module: &ModuleDef,
        procedure: &spacetimedb_schema::def::ProcedureDef,
    ) -> OutputFile {
        let procedure_snake = procedure.name.deref();
        let procedure_pascal = procedure_snake.to_case(Case::Pascal);
        let pascal = format!("{}{}", self.module_prefix, procedure_pascal);

        // Collect includes for parameter types
        let mut includes = HashSet::<String>::new();
        for (_param_name, param_type) in &procedure.params_for_generate.elements {
            collect_includes_for_type(self.module_prefix, module, param_type, &mut includes, self.module_name);
        }
        collect_includes_for_type(
            self.module_prefix,
            module,
            &procedure.return_type_for_generate,
            &mut includes,
            self.module_name,
        );

        // Convert to sorted vector
        let mut include_vec: Vec<String> = includes.into_iter().collect();
        include_vec.sort();

        // Convert to string references
        let include_refs: Vec<&str> = include_vec.iter().map(|s| s.as_str()).collect();

        let mut header = UnrealCppAutogen::new(&include_refs, &pascal, false);

        let args_struct = format!("F{pascal}Args");

        // Generate procedure arguments struct
        writeln!(header, "// Procedure arguments struct for {pascal}");
        writeln!(header, "USTRUCT(BlueprintType)");
        writeln!(header, "struct {} {args_struct}", self.get_api_macro());
        writeln!(header, "{{");
        writeln!(header, "    GENERATED_BODY()");
        writeln!(header);

        // Generate properties for each parameter
        for (param_name, param_type) in &procedure.params_for_generate.elements {
            let param_pascal = param_name.deref().to_case(Case::Pascal);
            let type_str = cpp_ty_fmt_with_module(self.module_prefix, module, param_type, self.module_name).to_string();
            let init_str = cpp_ty_init_fmt_impl(self.module_prefix, module, param_type);
            let field_decl = format!("{type_str} {param_pascal}{init_str}");

            // Check if the type is blueprintable
            if is_blueprintable(module, param_type) {
                writeln!(header, "    UPROPERTY(BlueprintReadWrite, Category=\"SpacetimeDB\")");
            } else {
                // Add comment explaining why the field isn't exposed as UPROPERTY
                writeln!(
                    header,
                    "    // NOTE: {type_str} field not exposed to Blueprint due to non-blueprintable elements"
                );
            }