Merge branch 'master' into rust_vs_godot_hashes

markogalevski · web-flow · commit 32f0e2c5bf1e · 2025-10-22T19:19:09.000+02:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -39,7 +39,7 @@ which = "7"
 # * quote: 1.0.37 allows tokenizing CStr.
 # * venial: 0.6.1 contains some bugfixes.
 heck = "0.5"
-litrs = "0.4"
+litrs = { version = "1.0", features = ["proc-macro2"] }
 markdown = "=1.0.0-alpha.23"
 nanoserde = "0.2"
 proc-macro2 = "1.0.80"
diff --git a/godot-codegen/src/context.rs b/godot-codegen/src/context.rs
@@ -12,7 +12,6 @@ use quote::{format_ident, ToTokens};
 
 use crate::generator::method_tables::MethodTableKey;
 use crate::generator::notifications;
-use crate::generator::sys::SYS_PARAMS;
 use crate::models::domain::{ArgPassing, GodotTy, RustTy, TyName};
 use crate::models::json::{
     JsonBuiltinClass, JsonBuiltinMethod, JsonClass, JsonClassConstant, JsonClassMethod,
@@ -29,9 +28,6 @@ pub struct Context<'a> {
     /// Which interface traits are generated (`false` for "Godot-abstract"/final classes).
     classes_final: HashMap<TyName, bool>,
     cached_rust_types: HashMap<GodotTy, RustTy>,
-    /// Various pointers defined in `gdextension_interface`, for example `GDExtensionInitializationFunction`.
-    /// Used in some APIs that are not exposed to GDScript.
-    sys_types: HashSet<&'a str>,
     notifications_by_class: HashMap<TyName, Vec<(Ident, i32)>>,
     classes_with_signals: HashSet<TyName>,
     notification_enum_names_by_class: HashMap<TyName, NotificationEnum>,
@@ -47,8 +43,6 @@ impl<'a> Context<'a> {
             ctx.singletons.insert(class.name.as_str());
         }
 
-        Self::populate_sys_types(&mut ctx);
-
         ctx.builtin_types.insert("Variant"); // not part of builtin_classes
         for builtin in api.builtin_classes.iter() {
             let ty_name = builtin.name.as_str();
@@ -158,14 +152,6 @@ impl<'a> Context<'a> {
         ctx
     }
 
-    /// Adds Godot pointer types to [`Context`].
-    ///
-    /// Godot pointer types, for example `GDExtensionInitializationFunction`, are defined in `gdextension_interface`
-    /// but aren't described in `extension_api.json` – despite being used as parameters in various APIs.
-    fn populate_sys_types(ctx: &mut Context) {
-        ctx.sys_types.extend(SYS_PARAMS.iter().map(|p| p.type_()));
-    }
-
     fn populate_notification_constants(
         class_name: &TyName,
         constants: &[JsonClassConstant],
@@ -266,6 +252,14 @@ impl<'a> Context<'a> {
             .unwrap_or_else(|| panic!("did not register table index for key {key:?}"))
     }
 
+    /// Yields cached sys pointer types – various pointer types declared in `gdextension_interface`
+    /// and used as parameters in exposed Godot APIs.
+    pub fn cached_sys_pointer_types(&self) -> impl Iterator<Item = &RustTy> {
+        self.cached_rust_types
+            .values()
+            .filter(|rust_ty| rust_ty.is_sys_pointer())
+    }
+
     /// Whether an interface trait is generated for a class.
     ///
     /// False if the class is "Godot-abstract"/final, thus there are no virtual functions to inherit.
@@ -307,10 +301,6 @@ impl<'a> Context<'a> {
         self.native_structures_types.contains(ty_name)
     }
 
-    pub fn is_sys(&self, ty_name: &str) -> bool {
-        self.sys_types.contains(ty_name)
-    }
-
     pub fn is_singleton(&self, class_name: &TyName) -> bool {
         self.singletons.contains(class_name.godot_ty.as_str())
     }
diff --git a/godot-codegen/src/conv/type_conversions.rs b/godot-codegen/src/conv/type_conversions.rs
@@ -170,17 +170,20 @@ fn to_rust_type_uncached(full_ty: &GodotTy, ctx: &mut Context) -> RustTy {
             ty = ty.replace("const ", "");
         }
 
-        // .trim() is necessary here, as Godot places a space between a type and the stars when representing a double pointer.
-        // Example: "int*" but "int **".
-        if ctx.is_sys(ty.trim()) {
+        // Sys pointer type defined in `gdextension_interface` and used as param for given method, e.g. `GDExtensionInitializationFunction`.
+        // Note: we branch here to avoid clashes with actual GDExtension classes.
+        if ty.starts_with("GDExtension") {
             let ty = rustify_ty(&ty);
             return RustTy::RawPointer {
-                inner: Box::new(RustTy::SysIdent {
+                inner: Box::new(RustTy::SysPointerType {
                     tokens: quote! { sys::#ty },
                 }),
                 is_const,
             };
         }
+
+        // .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);
         return RustTy::RawPointer {
             inner: Box::new(inner_type),
diff --git a/godot-codegen/src/generator/central_files.rs b/godot-codegen/src/generator/central_files.rs
@@ -10,7 +10,7 @@ use quote::{format_ident, quote, ToTokens};
 
 use crate::context::Context;
 use crate::conv;
-use crate::generator::sys::make_godotconvert_for_systypes;
+use crate::generator::sys_pointer_types::make_godotconvert_for_systypes;
 use crate::generator::{enums, gdext_build_struct};
 use crate::models::domain::ExtensionApi;
 use crate::util::ident;
@@ -61,7 +61,7 @@ pub fn make_core_central_code(api: &ExtensionApi, ctx: &mut Context) -> TokenStr
 
     let (global_enum_defs, global_reexported_enum_defs) = make_global_enums(api);
     let variant_type_traits = make_variant_type_enum(api, false);
-    let sys_types_godotconvert_impl = make_godotconvert_for_systypes();
+    let sys_types_godotconvert_impl = make_godotconvert_for_systypes(ctx);
 
     // TODO impl Clone, Debug, PartialEq, PartialOrd, Hash for VariantDispatch
     // TODO could use try_to().unwrap_unchecked(), since type is already verified. Also directly overload from_variant().
@@ -124,7 +124,10 @@ pub fn make_core_central_code(api: &ExtensionApi, ctx: &mut Context) -> TokenStr
             #( #global_reexported_enum_defs )*
         }
 
-        #( #sys_types_godotconvert_impl )*
+        pub mod sys_pointer_types {
+            use crate::sys;
+            #( #sys_types_godotconvert_impl )*
+        }
     }
 }
 
diff --git a/godot-codegen/src/generator/mod.rs b/godot-codegen/src/generator/mod.rs
@@ -28,7 +28,7 @@ pub mod method_tables;
 pub mod native_structures;
 pub mod notifications;
 pub mod signals;
-pub mod sys;
+pub mod sys_pointer_types;
 pub mod utility_functions;
 pub mod virtual_definitions;
 pub mod virtual_traits;
diff --git a/godot-codegen/src/generator/sys.rs b/godot-codegen/src/generator/sys.rs
diff --git a/godot-codegen/src/generator/sys_pointer_types.rs b/godot-codegen/src/generator/sys_pointer_types.rs
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) godot-rust; Bromeon and contributors.
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+use proc_macro2::TokenStream;
+use quote::quote;
+
+use crate::context::Context;
+
+/// Creates `GodotConvert`, `ToGodot` and `FromGodot` impl
+/// for SysPointerTypes – various pointer types declared in `gdextension_interface`
+/// and used as parameters in exposed Godot APIs.
+pub fn make_godotconvert_for_systypes(ctx: &mut Context) -> Vec<TokenStream> {
+    ctx.cached_sys_pointer_types().map(|sys_pointer_type| {
+        quote! {
+            impl crate::meta::GodotConvert for #sys_pointer_type {
+                type Via = i64;
+            }
+
+            impl crate::meta::ToGodot for #sys_pointer_type {
+                type Pass = crate::meta::ByValue;
+                fn to_godot(&self) -> Self::Via {
+                    *self as i64
+                }
+            }
+
+            impl crate::meta::FromGodot for #sys_pointer_type {
+                fn try_from_godot(via: Self::Via) -> Result <Self, crate::meta::error::ConvertError> {
+                    Ok(via as Self)
+                }
+            }
+        }
+    }).collect()
+}
diff --git a/godot-codegen/src/lib.rs b/godot-codegen/src/lib.rs
@@ -167,19 +167,6 @@ pub fn generate_core_files(core_gen_path: &Path) {
     // Deallocate all the JSON models; no longer needed for codegen.
     // drop(json_api);
 
-    generate_core_central_file(&api, &mut ctx, core_gen_path, &mut submit_fn);
-    watch.record("generate_central_file");
-
-    generate_utilities_file(&api, core_gen_path, &mut submit_fn);
-    watch.record("generate_utilities_file");
-
-    // From 4.4 onward, generate table that maps all virtual methods to their known hashes.
-    // This allows Godot to fall back to an older compatibility function if one is not supported.
-    // Also expose tuple signatures of virtual methods.
-    let code = virtual_definitions::make_virtual_definitions_file(&api, &mut ctx);
-    submit_fn(core_gen_path.join("virtuals.rs"), code);
-    watch.record("generate_virtual_definitions");
-
     // Class files -- currently output in godot-core; could maybe be separated cleaner
     // Note: deletes entire generated directory!
     generate_class_files(
@@ -207,6 +194,22 @@ pub fn generate_core_files(core_gen_path: &Path) {
     );
     watch.record("generate_native_structures_files");
 
+    // Note – generated at the very end since context could be updated while processing other files.
+    // For example – SysPointerTypes (ones defined in gdextension_interface) are declared only
+    // as parameters for various APIs.
+    generate_core_central_file(&api, &mut ctx, core_gen_path, &mut submit_fn);
+    watch.record("generate_central_file");
+
+    generate_utilities_file(&api, core_gen_path, &mut submit_fn);
+    watch.record("generate_utilities_file");
+
+    // From 4.4 onward, generate table that maps all virtual methods to their known hashes.
+    // This allows Godot to fall back to an older compatibility function if one is not supported.
+    // Also expose tuple signatures of virtual methods.
+    let code = virtual_definitions::make_virtual_definitions_file(&api, &mut ctx);
+    submit_fn(core_gen_path.join("virtuals.rs"), code);
+    watch.record("generate_virtual_definitions");
+
     #[cfg(feature = "codegen-rustfmt")]
     {
         rustfmt_files();
diff --git a/godot-codegen/src/models/domain.rs b/godot-codegen/src/models/domain.rs
@@ -728,7 +728,7 @@ pub enum RustTy {
     BuiltinIdent { ty: Ident, arg_passing: ArgPassing },
     /// Pointers declared in `gdextension_interface` such as `sys::GDExtensionInitializationFunction`
     /// used as parameters in some APIs.
-    SysIdent { tokens: TokenStream },
+    SysPointerType { tokens: TokenStream },
 
     /// `Array<i32>`
     ///
@@ -825,6 +825,13 @@ impl RustTy {
             "i8" | "i16" | "i32" | "i64" | "u8" | "u16" | "u32" | "u64" | "isize" | "usize"
         )
     }
+
+    pub fn is_sys_pointer(&self) -> bool {
+        let RustTy::RawPointer { inner, .. } = self else {
+            return false;
+        };
+        matches!(**inner, RustTy::SysPointerType { .. })
+    }
 }
 
 impl ToTokens for RustTy {
@@ -845,7 +852,7 @@ impl ToTokens for RustTy {
             RustTy::EngineClass { tokens: path, .. } => path.to_tokens(tokens),
             RustTy::ExtenderReceiver { tokens: path } => path.to_tokens(tokens),
             RustTy::GenericArray => quote! { Array<Ret> }.to_tokens(tokens),
-            RustTy::SysIdent { tokens: path } => path.to_tokens(tokens),
+            RustTy::SysPointerType { tokens: path } => path.to_tokens(tokens),
         }
     }
 }
diff --git a/godot-codegen/src/special_cases/codegen_special_cases.rs b/godot-codegen/src/special_cases/codegen_special_cases.rs
@@ -50,7 +50,7 @@ fn is_type_excluded(ty: &str, ctx: &mut Context) -> bool {
             RustTy::BuiltinArray { .. } => false,
             RustTy::GenericArray => false,
             RustTy::RawPointer { inner, .. } => is_rust_type_excluded(inner),
-            RustTy::SysIdent { .. } => true,
+            RustTy::SysPointerType { .. } => true,
             RustTy::EngineArray { elem_class, .. } => is_class_excluded(elem_class.as_str()),
             RustTy::EngineEnum {
                 surrounding_class, ..
diff --git a/godot-core/src/deprecated.rs b/godot-core/src/deprecated.rs
@@ -37,6 +37,12 @@ pub use crate::emit_deprecated_warning;
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Library-side deprecations -- see usage description above.
 
+#[deprecated = "\n\
+    #[class(no_init, base=EditorPlugin)] will crash when opened in the editor.\n\
+    EditorPlugin classes are automatically instantiated by Godot and require a default constructor.\n\
+    Use #[class(init)] instead, or provide a custom init() function in the IEditorPlugin impl."]
+pub const fn class_no_init_editor_plugin() {}
+
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Godot-side deprecations (we may mark them deprecated but keep support).
 
diff --git a/godot-core/src/meta/class_id.rs b/godot-core/src/meta/class_id.rs
@@ -309,8 +309,20 @@ impl ClassIdCache {
     }
 
     fn clear(&mut self) {
-        self.entries.clear();
+        // MACOS-PARTIAL-RELOAD: Previous implementation for when upstream fixes `.gdextension` reload.
+        // self.entries.clear();
+        // self.type_to_index.clear();
+        // self.string_to_index.clear();
+
+        // MACOS-PARTIAL-RELOAD: Preserve existing `ClassId` entries when only the `.gdextension` reloads so indices stay valid.
+        // There are two types of hot reload: `dylib` reload (`dylib` `mtime` newer) unloads and reloads the library, whereas
+        // `.gdextension` reload (`.gdextension` `mtime` newer) re-initializes the existing `dylib` without unloading it. To handle
+        // `.gdextension` reload, keep the backing entries (and thus the `string_to_index` map) but drop cached Godot `StringNames`
+        // and the `TypeId` lookup so they can be rebuilt.
+        for entry in &mut self.entries {
+            entry.godot_str = OnceCell::new();
+        }
+
         self.type_to_index.clear();
-        self.string_to_index.clear();
     }
 }
diff --git a/godot-ffi/src/lib.rs b/godot-ffi/src/lib.rs
@@ -283,7 +283,15 @@ pub unsafe fn initialize(
 /// # Safety
 /// See [`initialize`].
 pub unsafe fn deinitialize() {
-    deinitialize_binding()
+    deinitialize_binding();
+
+    // MACOS-PARTIAL-RELOAD: Clear the main thread ID to allow re-initialization during hot reload.
+    #[cfg(not(wasm_nothreads))]
+    {
+        if MAIN_THREAD_ID.is_initialized() {
+            MAIN_THREAD_ID.clear();
+        }
+    }
 }
 
 fn print_preamble(version: GDExtensionGodotVersion) {
diff --git a/godot-macros/src/class/derive_godot_class.rs b/godot-macros/src/class/derive_godot_class.rs
diff --git a/godot-macros/src/docs/extract_docs.rs b/godot-macros/src/docs/extract_docs.rs
diff --git a/itest/godot/TestRunner.gd b/itest/godot/TestRunner.gd
diff --git a/itest/hot-reload/godot/run-test.sh b/itest/hot-reload/godot/run-test.sh
diff --git a/itest/rust/src/object_tests/virtual_methods_test.rs b/itest/rust/src/object_tests/virtual_methods_test.rs

Original file line number	Diff line number	Diff line change
`@@ -728,7 +728,7 @@ pub enum RustTy {`
`728`	`728`	`BuiltinIdent { ty: Ident, arg_passing: ArgPassing },`
`729`	`729`	/// Pointers declared in `gdextension_interface` such as `sys::GDExtensionInitializationFunction`
`730`	`730`	`/// used as parameters in some APIs.`
`731`		`- SysIdent { tokens: TokenStream },`
	`731`	`+ SysPointerType { tokens: TokenStream },`
`732`	`732`
`733`	`733`	/// `Array<i32>`
`734`	`734`	`///`
`@@ -825,6 +825,13 @@ impl RustTy {`
`825`	`825`	`"i8" \| "i16" \| "i32" \| "i64" \| "u8" \| "u16" \| "u32" \| "u64" \| "isize" \| "usize"`
`826`	`826`	`)`
`827`	`827`	`}`
	`828`	`+`
	`829`	`+ pub fn is_sys_pointer(&self) -> bool {`
	`830`	`+ let RustTy::RawPointer { inner, .. } = self else {`
	`831`	`+ return false;`
	`832`	`+ };`
	`833`	`+ matches!(**inner, RustTy::SysPointerType { .. })`
	`834`	`+ }`
`828`	`835`	`}`
`829`	`836`
`830`	`837`	`impl ToTokens for RustTy {`
`@@ -845,7 +852,7 @@ impl ToTokens for RustTy {`
`845`	`852`	`RustTy::EngineClass { tokens: path, .. } => path.to_tokens(tokens),`
`846`	`853`	`RustTy::ExtenderReceiver { tokens: path } => path.to_tokens(tokens),`
`847`	`854`	`RustTy::GenericArray => quote! { Array<Ret> }.to_tokens(tokens),`
`848`		`- RustTy::SysIdent { tokens: path } => path.to_tokens(tokens),`
	`855`	`+ RustTy::SysPointerType { tokens: path } => path.to_tokens(tokens),`
`849`	`856`	`}`
`850`	`857`	`}`
`851`	`858`	`}`