Implement AnyArray, typed-or-untyped covariant array

Author: Bromeon

godot-codegen/src/conv/type_conversions.rs

@@ -14,15 +14,15 @@ use quote::{quote, ToTokens};
 
 use crate::context::Context;
 use crate::conv;
-use crate::models::domain::{ArgPassing, GodotTy, ModName, RustTy, TyName};
+use crate::models::domain::{ArgPassing, FlowDirection, GodotTy, ModName, RustTy, TyName};
 use crate::special_cases::is_builtin_type_scalar;
 use crate::util::ident;
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Godot -> Rust types
 
 /// Returns `(identifier, is_copy)` for a hardcoded Rust type, if it exists.
-fn to_hardcoded_rust_ident(full_ty: &GodotTy) -> Option<&str> {
+fn to_hardcoded_rust_ident(full_ty: &GodotTy) -> Option<Ident> {
     let ty = full_ty.ty.as_str();
     let meta = full_ty.meta.as_deref();
 
@@ -53,7 +53,14 @@ fn to_hardcoded_rust_ident(full_ty: &GodotTy) -> Option<&str> {
         // Others
         ("bool", None) => "bool",
         ("String", None) => "GString",
-        ("Array", None) => "VariantArray",
+
+        // Must remain "Array" because this is checked verbatim for later adjustments (e.g. to AnyArray).
+        // Keep also in line with default-exprs e.g. `Array::new()`.
+        ("Array", None) => match full_ty.flow {
+            Some(FlowDirection::RustToGodot) => "AnyArray",
+            Some(FlowDirection::GodotToRust) => "VariantArray",
+            None => "_unused__Array_must_not_appear_in_idents",
+        },
 
         // Types needed for native structures mapping
         ("uint8_t", None) => "u8",
@@ -76,10 +83,10 @@ fn to_hardcoded_rust_ident(full_ty: &GodotTy) -> Option<&str> {
         _ => return None,
     };
 
-    Some(result)
+    Some(ident(result))
 }
 
-fn to_hardcoded_rust_enum(ty: &str) -> Option<&str> {
+fn to_hardcoded_rust_enum(ty: &str) -> Option<Ident> {
     // Some types like Vector2[i].Axis may not appear in Godot's current JSON, but they are encountered
     // in custom Godot builds, e.g. when extending PhysicsServer2D.
     let result = match ty {
@@ -92,7 +99,8 @@ fn to_hardcoded_rust_enum(ty: &str) -> Option<&str> {
         "enum::Vector3i.Axis" => "Vector3Axis",
         _ => return None,
     };
-    Some(result)
+
+    Some(ident(result))
 }
 
 /// Maps an input type to a Godot type with the same C representation. This is subtly different from [`to_rust_type`],
@@ -124,7 +132,7 @@ pub(crate) fn to_rust_type_abi(ty: &str, ctx: &mut Context) -> (RustTy, bool) {
             ty: ident("f64"),
             arg_passing: ArgPassing::ByValue,
         },
-        _ => to_rust_type(ty, None, ctx),
+        _ => to_rust_temporary_type(ty, ctx),
     };
 
     (ty, is_obj)
@@ -134,14 +142,28 @@ pub(crate) fn to_rust_type_abi(ty: &str, ctx: &mut Context) -> (RustTy, bool) {
 ///
 /// Uses an internal cache (via `ctx`), as several types are ubiquitous.
 // TODO take TyName as input
-pub(crate) fn to_rust_type<'a>(ty: &'a str, meta: Option<&'a String>, ctx: &mut Context) -> RustTy {
+pub(crate) fn to_rust_type<'a>(
+    json_ty: &'a str,
+    meta: Option<&'a String>,
+    flow: Option<FlowDirection>,
+    ctx: &mut Context,
+) -> RustTy {
+    // Flow: don't-care for everything besides GDScript types Array or Array[Array].
+    // Do not panic if not set (used in to_temporary_rust_type()).
+    let flow = if json_ty == "Array" || json_ty == "typedarray::Array" {
+        flow
+    } else {
+        None
+    };
+
     let full_ty = GodotTy {
-        ty: ty.to_string(),
+        ty: json_ty.to_string(),
         meta: meta.cloned(),
+        flow,
     };
 
-    // Separate find + insert slightly slower, but much easier with lifetimes
-    // The insert path will be hit less often and thus doesn't matter
+    // Separate find + insert slightly slower, but much easier with lifetimes.
+    // The insert path will be hit less often and thus doesn't matter.
     if let Some(rust_ty) = ctx.find_rust_type(&full_ty) {
         rust_ty.clone()
     } else {
@@ -151,6 +173,17 @@ pub(crate) fn to_rust_type<'a>(ty: &'a str, meta: Option<&'a String>, ctx: &mut
     }
 }
 
+/// Converts a Godot type to a Rust type without caching, suitable for cases where only parts of the returned RustTy are needed.
+///
+/// This is a lightweight alternative to [`to_rust_type()`] for scenarios where only parts of the returned `RustTy` are needed (e.g.
+/// just the identifier name).
+///
+/// The returned type may have inaccuracies in fields that depend on metad or flow direction, so this should only be used when
+/// those fields are not needed. This allows for simpler call sites in code that doesn't require complete type information.
+pub(crate) fn to_rust_temporary_type(ty: &str, ctx: &mut Context) -> RustTy {
+    to_rust_type(ty, None, None, ctx)
+}
+
 fn to_rust_type_uncached(full_ty: &GodotTy, ctx: &mut Context) -> RustTy {
     let ty = full_ty.ty.as_str();
 
@@ -188,7 +221,7 @@ fn to_rust_type_uncached(full_ty: &GodotTy, ctx: &mut Context) -> RustTy {
 
         // .trim() is necessary here, as Godot places a space between a type and the stars when representing a double pointer.
         // Example: "int*" but "int **".
-        let inner_type = to_rust_type(ty.trim(), None, ctx);
+        let inner_type = to_rust_type(ty.trim(), None, None, ctx);
         return RustTy::RawPointer {
             inner: Box::new(inner_type),
             is_const,
@@ -199,15 +232,15 @@ fn to_rust_type_uncached(full_ty: &GodotTy, ctx: &mut Context) -> RustTy {
     if !ty.starts_with("typedarray::") {
         if let Some(hardcoded) = to_hardcoded_rust_ident(full_ty) {
             return RustTy::BuiltinIdent {
-                ty: ident(hardcoded),
+                ty: hardcoded,
                 arg_passing: ctx.get_builtin_arg_passing(full_ty),
             };
         }
     }
 
     if let Some(hardcoded) = to_hardcoded_rust_enum(ty) {
         return RustTy::EngineEnum {
-            tokens: ident(hardcoded).to_token_stream(),
+            tokens: hardcoded.to_token_stream(),
             surrounding_class: None, // would need class passed in
             is_bitfield: false,
         };
@@ -226,7 +259,7 @@ fn to_rust_type_uncached(full_ty: &GodotTy, ctx: &mut Context) -> RustTy {
             };
         }
     } else if let Some(elem_ty) = ty.strip_prefix("typedarray::") {
-        let rust_elem_ty = to_rust_type(elem_ty, full_ty.meta.as_ref(), ctx);
+        let rust_elem_ty = to_rust_type(elem_ty, full_ty.meta.as_ref(), full_ty.flow, ctx);
         return if ctx.is_builtin(elem_ty) {
             RustTy::BuiltinArray {
                 elem_type: quote! { Array<#rust_elem_ty> },
@@ -331,6 +364,9 @@ fn to_rust_expr_inner(expr: &str, ty: &RustTy, is_inner: bool) -> TokenStream {
         "true" => return quote! { true },
         "false" => return quote! { false },
         "[]" | "{}" if is_inner => return quote! {},
+        "[]" if matches!(ty, RustTy::BuiltinIdent { ty, .. } if ty == "AnyArray") => {
+            return quote! { AnyArray::new_untyped() }
+        }
         "[]" => return quote! { Array::new() }, // VariantArray or Array<T>
         "{}" => return quote! { Dictionary::new() },
         "null" => {

godot-codegen/src/generator/builtins.rs

@@ -15,8 +15,8 @@ use crate::generator::functions_common::{FnCode, FnDefinition, FnDefinitions};
 use crate::generator::method_tables::MethodTableKey;
 use crate::generator::{enums, functions_common};
 use crate::models::domain::{
-    BuiltinClass, BuiltinMethod, ClassLike, ExtensionApi, FnDirection, Function, ModName, RustTy,
-    TyName,
+    BuiltinClass, BuiltinMethod, ClassLike, ExtensionApi, FlowDirection, FnDirection, Function,
+    ModName, RustTy, TyName,
 };
 use crate::{conv, util, SubmitFn};
 
@@ -97,9 +97,12 @@ fn make_builtin_class(
 ) -> GeneratedBuiltin {
     let godot_name = &class.name().godot_ty;
 
+    // Meta direction irrelevant, since we're just interested in the builtin "outer" name.
+    // Flow mostly irrelevant too, but we'd like to have VariantArray as the outer class, so choose Godot->Rust.
+    let flow = FlowDirection::GodotToRust;
     let RustTy::BuiltinIdent {
         ty: outer_class, ..
-    } = conv::to_rust_type(godot_name, None, ctx)
+    } = conv::to_rust_type(godot_name, None, Some(flow), ctx)
     else {
         panic!("Rust type `{godot_name}` categorized wrong")
     };

godot-codegen/src/generator/central_files.rs

@@ -12,7 +12,7 @@ use crate::context::Context;
 use crate::conv;
 use crate::generator::sys_pointer_types::make_godotconvert_for_systypes;
 use crate::generator::{enums, gdext_build_struct};
-use crate::models::domain::ExtensionApi;
+use crate::models::domain::{ExtensionApi, FlowDirection};
 use crate::util::ident;
 
 pub fn make_sys_central_code(api: &ExtensionApi) -> TokenStream {
@@ -175,11 +175,14 @@ fn make_variant_enums(api: &ExtensionApi, ctx: &mut Context) -> VariantEnums {
         variant_ty_enumerators_rust: Vec::with_capacity(len),
     };
 
+    // When extracting variant, data moves Godot->Rust. Means `VariantArray` for `Array`.
+    let flow = FlowDirection::GodotToRust;
+
     // Note: NIL is not part of this iteration, it will be added manually.
     for builtin in api.builtins.iter() {
         let original_name = builtin.godot_original_name();
         let shout_case = builtin.godot_shout_name();
-        let rust_ty = conv::to_rust_type(original_name, None, ctx);
+        let rust_ty = conv::to_rust_type(original_name, None, Some(flow), ctx);
         let pascal_case = conv::to_pascal_case(original_name);
 
         result

godot-codegen/src/generator/functions_common.rs

@@ -389,7 +389,7 @@ pub(crate) enum FnArgExpr {
     StoreInDefaultField,
 }
 
-/// How parameters are declared in a function signature.
+/// Whether parameters need to be declared in a special way (e.g. with `impl AsArg`).
 #[derive(Copy, Clone)]
 pub(crate) enum FnParamDecl {
     /// Public-facing, i.e. `T`, `&T`, `impl AsArg<T>`.
@@ -494,6 +494,11 @@ pub(crate) fn make_param_or_field_type(
             let lft = lifetimes.next();
             special_ty = Some(quote! { RefArg<#lft, #ty> });
 
+            // Transform VariantArray -> AnyArray for outbound parameters.
+            // FIXME virtual params
+            // let ty = if matches!(decl, FnParamDecl::)
+            //     ty.try_to_any_array().unwrap_or_else(|| ty.clone());
+
             match decl {
                 FnParamDecl::FnPublic => quote! { & #ty },
                 FnParamDecl::FnPublicLifetime => quote! { &'a #ty },

godot-codegen/src/models/domain.rs

@@ -479,6 +479,15 @@ pub enum FnDirection {
     Outbound { hash: i64 },
 }
 
+/// Whether return values need to be declared in a special way (e.g. `AnyArray`).
+#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+pub(crate) enum FlowDirection {
+    /// Godot -> Rust.
+    GodotToRust,
+
+    /// Rust -> Godot.
+    RustToGodot,
+}
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 
 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
@@ -555,39 +564,53 @@ impl FnParamBuilder {
     }
 
     /// Builds a single function parameter from the provided JSON method argument.
-    pub fn build_single(self, method_arg: &JsonMethodArg, ctx: &mut Context) -> FnParam {
-        self.build_single_impl(method_arg, ctx)
+    pub fn build_single(
+        self,
+        method_arg: &JsonMethodArg,
+        flow: FlowDirection,
+        ctx: &mut Context,
+    ) -> FnParam {
+        self.build_single_impl(method_arg, flow, ctx)
     }
 
     /// Builds a vector of function parameters from the provided JSON method arguments.
     pub fn build_many(
         self,
         method_args: &Option<Vec<JsonMethodArg>>,
+        flow: FlowDirection,
         ctx: &mut Context,
     ) -> Vec<FnParam> {
         option_as_slice(method_args)
             .iter()
-            .map(|arg| self.build_single_impl(arg, ctx))
+            .map(|arg| self.build_single_impl(arg, flow, ctx))
             .collect()
     }
 
     /// Core implementation for processing a single JSON method argument into a `FnParam`.
-    fn build_single_impl(&self, method_arg: &JsonMethodArg, ctx: &mut Context) -> FnParam {
+    fn build_single_impl(
+        &self,
+        method_arg: &JsonMethodArg,
+        flow: FlowDirection,
+        ctx: &mut Context,
+    ) -> FnParam {
         let name = safe_ident(&method_arg.name);
-        let type_ = conv::to_rust_type(&method_arg.type_, method_arg.meta.as_ref(), ctx);
+        let type_ =
+            conv::to_rust_type(&method_arg.type_, method_arg.meta.as_ref(), Some(flow), ctx);
 
         // Apply enum replacement if one exists for this parameter
         let matching_replacement = self
             .replacements
             .iter()
             .find(|(p, ..)| *p == method_arg.name);
+
         let type_ = if let Some((_, enum_name, is_bitfield)) = matching_replacement {
             if !type_.is_integer() {
                 panic!(
                     "Parameter `{}` is of type {}, but can only replace int with enum",
                     method_arg.name, type_
                 );
             }
+
             conv::to_enum_type_uncached(enum_name, *is_bitfield)
         } else {
             type_
@@ -629,8 +652,12 @@ pub struct FnReturn {
 }
 
 impl FnReturn {
-    pub fn new(return_value: &Option<JsonMethodReturn>, ctx: &mut Context) -> Self {
-        Self::with_enum_replacements(return_value, &[], ctx)
+    pub fn new(
+        return_value: &Option<JsonMethodReturn>,
+        flow: FlowDirection,
+        ctx: &mut Context,
+    ) -> Self {
+        Self::with_enum_replacements(return_value, &[], flow, ctx)
     }
 
     pub fn with_generic_builtin(generic_type: RustTy) -> Self {
@@ -643,10 +670,11 @@ impl FnReturn {
     pub fn with_enum_replacements(
         return_value: &Option<JsonMethodReturn>,
         replacements: EnumReplacements,
+        flow: FlowDirection,
         ctx: &mut Context,
     ) -> Self {
         if let Some(ret) = return_value {
-            let ty = conv::to_rust_type(&ret.type_, ret.meta.as_ref(), ctx);
+            let ty = conv::to_rust_type(&ret.type_, ret.meta.as_ref(), Some(flow), ctx);
 
             // Apply enum replacement if one exists for return type (indicated by empty string)
             let matching_replacement = replacements.iter().find(|(p, ..)| p.is_empty());
@@ -710,6 +738,9 @@ pub type EnumReplacements = &'static [(&'static str, &'static str, bool)];
 pub struct GodotTy {
     pub ty: String,
     pub meta: Option<String>,
+
+    // None if flow doesn't matter (most types except "Array").
+    pub flow: Option<FlowDirection>,
 }
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------
@@ -726,7 +757,7 @@ pub enum RustTy {
 
     /// `Array<i32>`
     ///
-    /// Note that untyped arrays are mapped as `BuiltinIdent("Array")`.
+    /// Untyped arrays are either `BuiltinIdent("AnyArray")` for outbound methods, or `BuiltinIdent("Array")` for virtual methods.
     BuiltinArray { elem_type: TokenStream },
 
     /// Will be included as `Array<T>` in the generated source.