Merge pull request #1322 from godot-rust/qol/rename-class-id

Rename `ClassName` -> `ClassId`

Author: Bromeon

check.sh

@@ -312,18 +312,18 @@ function compute_elapsed() {
 for cmd in "${cmds[@]}"; do
     "cmd_${cmd}" || {
         compute_elapsed
-        log -ne "$RED\n====================="
-        log -ne "\ngdext: checks FAILED."
-        log -ne "\n=====================\n$END"
+        log -ne "$RED\n=========================="
+        log -ne "\ngodot-rust: checks FAILED."
+        log -ne "\n==========================\n$END"
         log -ne "\nTotal duration: $elapsed.\n"
         exit 1
     }
 done
 
 compute_elapsed
-log -ne "$CYAN\n========================="
-log -ne "\ngdext: checks SUCCESSFUL."
-log -ne "\n=========================\n$END"
+log -ne "$CYAN\n=============================="
+log -ne "\ngodot-rust: checks SUCCESSFUL."
+log -ne "\n==============================\n$END"
 log -ne "\nTotal duration: $elapsed.\n"
 
 # If invoked with sh instead of bash, pressing Up arrow after executing `sh check.sh` may cause a `[A` to appear.

godot-codegen/src/generator/classes.rs

@@ -244,11 +244,11 @@ fn make_class(class: &Class, ctx: &mut Context, view: &ApiView) -> GeneratedClas
                 type Base = #base_ty;
 
                 // Code duplicated in godot-macros.
-                fn class_name() -> ClassName {
+                fn class_id() -> ClassId {
                     // Optimization note: instead of lazy init, could use separate static which is manually initialized during registration.
-                    static CLASS_NAME: std::sync::OnceLock<ClassName> = std::sync::OnceLock::new();
+                    static CLASS_ID: std::sync::OnceLock<ClassId> = std::sync::OnceLock::new();
 
-                    let name: &'static ClassName = CLASS_NAME.get_or_init(|| ClassName::__alloc_next_ascii(#class_name_cstr));
+                    let name: &'static ClassId = CLASS_ID.get_or_init(|| ClassId::__alloc_next_ascii(#class_name_cstr));
                     *name
                 }
 
@@ -421,8 +421,8 @@ fn make_constructor_and_default(class: &Class, ctx: &Context) -> Construction {
     let class_name = class.name();
 
     let godot_class_stringname = make_string_name(&class_name.godot_ty);
-    // Note: this could use class_name() but is not yet done due to potential future lazy-load refactoring.
-    //let class_name_obj = quote! { <Self as crate::obj::GodotClass>::class_name() };
+    // Note: this could use class_id() but is not yet done due to potential future lazy-load refactoring.
+    //let class_name_obj = quote! { <Self as crate::obj::GodotClass>::class_id() };
 
     let (constructor, construct_doc, has_godot_default_impl);
     if ctx.is_singleton(class_name) {

godot-codegen/src/util.rs

@@ -25,7 +25,7 @@ pub fn make_imports() -> TokenStream {
     quote! {
         use godot_ffi as sys;
         use crate::builtin::*;
-        use crate::meta::{AsArg, ClassName, CowArg, InParamTuple, OutParamTuple, ParamTuple, RefArg, Signature};
+        use crate::meta::{AsArg, ClassId, CowArg, InParamTuple, OutParamTuple, ParamTuple, RefArg, Signature};
         use crate::classes::native::*;
         use crate::classes::Object;
         use crate::obj::Gd;

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

@@ -17,7 +17,7 @@ use crate::meta;
 use crate::meta::error::{ConvertError, FromGodotError, FromVariantError};
 use crate::meta::signed_range::SignedRange;
 use crate::meta::{
-    element_godot_type_name, element_variant_type, ArrayElement, AsArg, ClassName, ElementType,
+    element_godot_type_name, element_variant_type, ArrayElement, AsArg, ClassId, ElementType,
     ExtVariantType, FromGodot, GodotConvert, GodotFfiVariant, GodotType, PropertyHintInfo, RefArg,
     ToGodot,
 };
@@ -1038,7 +1038,7 @@ impl<T: ArrayElement> Array<T> {
         if let (ElementType::ScriptClass(_), ElementType::Class(expected_class)) =
             (&self_ty, &target_ty)
         {
-            if let Some(actual_base_class) = self_ty.class_name() {
+            if let Some(actual_base_class) = self_ty.class_id() {
                 if actual_base_class == *expected_class {
                     return Ok(self);
                 }
@@ -1073,8 +1073,8 @@ impl<T: ArrayElement> Array<T> {
             // A bit contrived because empty StringName is lazy-initialized but must also remain valid.
             #[allow(unused_assignments)]
             let mut empty_string_name = None;
-            let class_name = if let Some(class_name) = elem_ty.class_name() {
-                class_name.string_sys()
+            let class_name = if let Some(class_id) = elem_ty.class_id() {
+                class_id.string_sys()
             } else {
                 empty_string_name = Some(StringName::default());
                 // as_ref() crucial here -- otherwise the StringName is dropped.
@@ -1297,7 +1297,7 @@ where
     }
 
     #[doc(hidden)]
-    fn as_node_class() -> Option<ClassName> {
+    fn as_node_class() -> Option<ClassId> {
         PropertyHintInfo::object_as_node_class::<T>()
     }
 }
@@ -1315,7 +1315,7 @@ where
     }
 
     #[doc(hidden)]
-    fn as_node_class() -> Option<ClassName> {
+    fn as_node_class() -> Option<ClassId> {
         PropertyHintInfo::object_as_node_class::<T>()
     }
 }

godot-core/src/builtin/variant/impls.rs

@@ -401,7 +401,7 @@ impl GodotType for Variant {
     fn property_info(property_name: &str) -> PropertyInfo {
         PropertyInfo {
             variant_type: Self::VARIANT_TYPE.variant_as_nil(),
-            class_name: Self::class_name(),
+            class_id: Self::class_id(),
             property_name: StringName::from(property_name),
             hint_info: PropertyHintInfo::none(),
             usage: global::PropertyUsageFlags::DEFAULT | global::PropertyUsageFlags::NIL_IS_VARIANT,

godot-core/src/classes/class_runtime.rs

@@ -12,7 +12,7 @@ use crate::builtin::{GString, StringName, Variant, VariantType};
 use crate::classes::{ClassDb, Object};
 use crate::meta::CallContext;
 #[cfg(debug_assertions)]
-use crate::meta::ClassName;
+use crate::meta::ClassId;
 use crate::obj::{bounds, Bounds, Gd, GodotClass, InstanceId, RawGd};
 use crate::sys;
 
@@ -171,7 +171,7 @@ where
     T: GodotClass + Bounds<Declarer = bounds::DeclEngine>,
 {
     let mut obj = unsafe {
-        let object_ptr = sys::classdb_construct_object(T::class_name().string_sys());
+        let object_ptr = sys::classdb_construct_object(T::class_id().string_sys());
         Gd::<T>::from_obj_sys(object_ptr)
     };
     #[cfg(since_api = "4.4")]
@@ -202,9 +202,9 @@ pub(crate) fn ensure_object_alive(
 }
 
 #[cfg(debug_assertions)]
-pub(crate) fn ensure_object_inherits(derived: ClassName, base: ClassName, instance_id: InstanceId) {
+pub(crate) fn ensure_object_inherits(derived: ClassId, base: ClassId, instance_id: InstanceId) {
     if derived == base
-        || base == Object::class_name() // for Object base, anything inherits by definition
+        || base == Object::class_id() // for Object base, anything inherits by definition
         || is_derived_base_cached(derived, base)
     {
         return;
@@ -245,12 +245,12 @@ where
 
 /// Checks if `derived` inherits from `base`, using a cache for _successful_ queries.
 #[cfg(debug_assertions)]
-fn is_derived_base_cached(derived: ClassName, base: ClassName) -> bool {
+fn is_derived_base_cached(derived: ClassId, base: ClassId) -> bool {
     use std::collections::HashSet;
 
     use sys::Global;
 
-    static CACHE: Global<HashSet<(ClassName, ClassName)>> = Global::default();
+    static CACHE: Global<HashSet<(ClassId, ClassId)>> = Global::default();
 
     let mut cache = CACHE.lock();
     let key = (derived, base);

godot-core/src/classes/manual_extensions.rs

@@ -32,7 +32,7 @@ impl Node {
         self.try_get_node_as(path).unwrap_or_else(|| {
             panic!(
                 "There is no node of type {ty} at path `{path}`",
-                ty = T::class_name()
+                ty = T::class_id()
             )
         })
     }
@@ -66,7 +66,7 @@ impl PackedScene {
         T: Inherits<Node>,
     {
         self.try_instantiate_as::<T>()
-            .unwrap_or_else(|| panic!("Failed to instantiate {to}", to = T::class_name()))
+            .unwrap_or_else(|| panic!("Failed to instantiate {to}", to = T::class_id()))
     }
 
     /// Instantiates the scene as type `T` (fallible).

godot-core/src/docs.rs

@@ -7,7 +7,7 @@
 
 use std::collections::HashMap;
 
-use crate::meta::ClassName;
+use crate::meta::ClassId;
 use crate::registry::plugin::{ITraitImpl, InherentImpl, PluginItem, Struct};
 
 /// Created for documentation on
@@ -75,7 +75,7 @@ struct DocPieces {
 /// strings of not-yet-parented XML tags (or empty string if no method has been documented).
 #[doc(hidden)]
 pub fn gather_xml_docs() -> impl Iterator<Item = String> {
-    let mut map = HashMap::<ClassName, DocPieces>::new();
+    let mut map = HashMap::<ClassId, DocPieces>::new();
     crate::private::iterate_plugins(|x| {
         let class_name = x.class_name;