Compute is_unsafe property at JSON mapping time

Author: Bromeon

godot-codegen/src/generator/functions_common.rs

@@ -122,7 +122,7 @@ pub fn make_function_definition(
     // Thus, let's keep things simple and more conservative.
     let (maybe_unsafe, maybe_safety_doc) = if let Some(safety_doc) = safety_doc {
         (quote! { unsafe }, safety_doc)
-    } else if function_uses_pointers(sig) {
+    } else if sig.common().is_unsafe {
         (
             quote! { unsafe },
             quote! {
@@ -637,15 +637,3 @@ pub(crate) fn make_params_exprs_virtual<'a>(
 
     ret
 }
-
-fn function_uses_pointers(sig: &dyn Function) -> bool {
-    let has_pointer_params = sig
-        .params()
-        .iter()
-        .any(|param| matches!(param.type_, RustTy::RawPointer { .. }));
-
-    let has_pointer_return = matches!(sig.return_value().type_, Some(RustTy::RawPointer { .. }));
-
-    // No short-circuiting due to variable decls, but that's fine.
-    has_pointer_params || has_pointer_return
-}

godot-codegen/src/models/domain.rs

@@ -284,6 +284,8 @@ pub struct FunctionCommon {
     pub is_vararg: bool,
     pub is_private: bool,
     pub is_virtual_required: bool,
+    /// Whether raw pointers appear in signature. Affects safety, and in case of virtual methods, the name.
+    pub is_unsafe: bool,
     pub direction: FnDirection,
 }
 

godot-codegen/src/models/domain_mapping.rs

@@ -10,7 +10,7 @@ use crate::models::domain::{
     BuildConfiguration, BuiltinClass, BuiltinMethod, BuiltinSize, BuiltinVariant, Class,
     ClassCommons, ClassConstant, ClassConstantValue, ClassMethod, ClassSignal, Constructor, Enum,
     Enumerator, EnumeratorValue, ExtensionApi, FnDirection, FnParam, FnQualifier, FnReturn,
-    FunctionCommon, GodotApiVersion, ModName, NativeStructure, Operator, Singleton, TyName,
+    FunctionCommon, GodotApiVersion, ModName, NativeStructure, Operator, RustTy, Singleton, TyName,
     UtilityFunction,
 };
 use crate::models::json::{
@@ -374,6 +374,7 @@ impl BuiltinMethod {
                 is_vararg: method.is_vararg,
                 is_private: false, // See 'exposed' below. Could be special_cases::is_method_private(builtin_name, &method.name),
                 is_virtual_required: false,
+                is_unsafe: false, // Builtin methods don't use raw pointers.
                 direction: FnDirection::Outbound {
                     hash: method.hash.expect("hash absent for builtin method"),
                 },
@@ -507,15 +508,20 @@ impl ClassMethod {
             is_required_in_json
         };
 
+        let parameters = FnParam::new_range(&method.arguments, ctx);
+        let return_value = FnReturn::new(&method.return_value, ctx);
+        let is_unsafe = Self::function_uses_pointers(&parameters, &return_value);
+
         Some(Self {
             common: FunctionCommon {
                 name: rust_method_name.to_string(),
                 godot_name: godot_method_name,
-                parameters: FnParam::new_range(&method.arguments, ctx),
-                return_value: FnReturn::new(&method.return_value, ctx),
+                parameters,
+                return_value,
                 is_vararg: method.is_vararg,
                 is_private,
                 is_virtual_required,
+                is_unsafe,
                 direction,
             },
             qualifier,
@@ -531,6 +537,17 @@ impl ClassMethod {
 
         special_cases::maybe_rename_virtual_method(class_name, method_name)
     }
+
+    fn function_uses_pointers(parameters: &[FnParam], return_value: &FnReturn) -> bool {
+        let has_pointer_params = parameters
+            .iter()
+            .any(|param| matches!(param.type_, RustTy::RawPointer { .. }));
+
+        let has_pointer_return = matches!(return_value.type_, Some(RustTy::RawPointer { .. }));
+
+        // No short-circuiting due to variable decls, but that's fine.
+        has_pointer_params || has_pointer_return
+    }
 }
 
 impl ClassSignal {
@@ -584,6 +601,7 @@ impl UtilityFunction {
                 is_vararg: function.is_vararg,
                 is_private,
                 is_virtual_required: false,
+                is_unsafe: false, // Utility functions don't use raw pointers.
                 direction: FnDirection::Outbound {
                     hash: function.hash,
                 },