Document changes, cover subarray_... methods as well.

Author: Yarwin

godot-codegen/src/generator/functions_common.rs

@@ -360,10 +360,7 @@ pub(crate) enum FnKind {
     /// `call()` forwarding to `try_call()`.
     DelegateTry,
 
-    // Currently not used – uncomment when needed again.
-    // /// Default extender `new()` associated function -- optional receiver and required parameters.
-    // ExBuilderConstructor,
-    /// Same as [`ExBuilderConstructor`], but for a builder with an explicit lifetime.
+    /// Default extender `new()` associated function -- optional receiver and required parameters. Has an explicit lifetime.
     ExBuilderConstructorLifetimed,
 
     /// Default extender `new()` associated function -- only default parameters.
@@ -576,7 +573,6 @@ pub(crate) fn make_params_exprs<'a>(
         // Methods relevant in the context of default parameters. Flow in this order.
         // Note that for builder methods of Ex* structs, there's a direct call in default_parameters.rs to the parameter manipulation methods,
         // bypassing this method. So one case is missing here.
-        // FnKind::ExBuilderConstructor => (FnParamDecl::FnPublic, FnArgExpr::StoreInField),
         FnKind::ExBuilderConstructorLifetimed => {
             (FnParamDecl::FnPublicLifetime, FnArgExpr::StoreInField)
         }

godot-codegen/src/models/domain.rs

@@ -718,7 +718,7 @@ pub enum RustTy {
 
     /// `Array<T>`
     ///
-    ///
+    /// Set by [`builtin_method_generic_ret`](crate::special_cases::builtin_method_generic_ret)
     GenericArray,
 
     /// C-style raw pointer to a `RustTy`.

godot-codegen/src/models/domain_mapping.rs

@@ -366,18 +366,19 @@ impl BuiltinMethod {
             return None;
         }
 
-        let return_value =
-            if let Some(generic) = special_cases::is_builtin_method_generic(builtin_name, method) {
-                generic
-            } else {
-                FnReturn::new(
-                    &method
-                        .return_type
-                        .as_deref()
-                        .map(JsonMethodReturn::from_type_no_meta),
-                    ctx,
-                )
-            };
+        let return_value = if let Some(generic) =
+            special_cases::builtin_method_generic_ret(builtin_name, method)
+        {
+            generic
+        } else {
+            FnReturn::new(
+                &method
+                    .return_type
+                    .as_deref()
+                    .map(JsonMethodReturn::from_type_no_meta),
+                ctx,
+            )
+        };
 
         Some(Self {
             common: FunctionCommon {

godot-codegen/src/special_cases/special_cases.rs

@@ -778,15 +778,18 @@ pub fn is_builtin_method_deleted(_class_name: &TyName, method: &JsonBuiltinMetho
     codegen_special_cases::is_builtin_method_excluded(method)
 }
 
-pub fn is_builtin_method_generic(
+/// Returns some generic type – such as `GenericArray` representing `Array<T>` – if method is marked as generic, `None` otherwise.
+///
+/// Usually required to properly initialize the return value & cache its type.
+pub fn builtin_method_generic_ret(
     class_name: &TyName,
     method: &JsonBuiltinMethod,
 ) -> Option<FnReturn> {
     match (
         class_name.rust_ty.to_string().as_str(),
         method.name.as_str(),
     ) {
-        ("Array", "duplicate") => Some(FnReturn {
+        ("Array", "duplicate") | ("Array", "slice") => Some(FnReturn {
             decl: RustTy::GenericArray.return_decl(),
             type_: Some(RustTy::GenericArray),
         }),

godot-core/src/builtin/collections/array.rs

@@ -589,8 +589,7 @@ impl<T: ArrayElement> Array<T> {
         let end = end.unwrap_or(i32::MAX as i64);
 
         // SAFETY: The type of the array is `T` and we convert the returned array to an `Array<T>` immediately.
-        let subarray: VariantArray =
-            unsafe { self.as_inner().slice(begin, end, step as i64, deep) };
+        let subarray: Self = unsafe { self.as_inner().slice(begin, end, step as i64, deep) };
 
         // SAFETY: slice() returns a typed array with the same type as Self.
         let result = unsafe { subarray.assume_type() };

itest/rust/src/builtin_tests/containers/array_test.rs

@@ -677,13 +677,18 @@ func make_array() -> Array[CustomScriptForArrays]:
     assert_eq!(script.get_global_name(), "CustomScriptForArrays".into());
 }
 
+// Test that proper type has been set&cached while creating new Array.
 #[itest]
 fn array_inner_type() {
     let primary = Array::<Dictionary>::new();
     let secondary = primary.duplicate_shallow();
     assert_eq!(secondary.element_type(), primary.element_type());
     let secondary = primary.duplicate_deep();
-    assert_eq!(secondary.element_type(), primary.element_type())
+    assert_eq!(secondary.element_type(), primary.element_type());
+    let subarray = primary.subarray_deep(.., None);
+    assert_eq!(subarray.element_type(), primary.element_type());
+    let subarray = primary.subarray_shallow(.., None);
+    assert_eq!(subarray.element_type(), primary.element_type());
 }
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------