Use rust str instead of cstr in ClassIdSource

Author: beicause

godot-codegen/src/generator/classes.rs

@@ -91,7 +91,6 @@ fn make_class(class: &Class, ctx: &mut Context, view: &ApiView) -> GeneratedClas
 
     // Strings
     let godot_class_str = &class_name.godot_ty;
-    let class_name_cstr = util::c_str(godot_class_str);
 
     // Idents and tokens
     let (base_ty, base_ident_opt) = match class.base_class.as_ref() {
@@ -248,7 +247,7 @@ fn make_class(class: &Class, ctx: &mut Context, view: &ApiView) -> GeneratedClas
                     // Optimization note: instead of lazy init, could use separate static which is manually initialized during registration.
                     static CLASS_ID: std::sync::OnceLock<ClassId> = std::sync::OnceLock::new();
 
-                    let name: &'static ClassId = CLASS_ID.get_or_init(|| ClassId::__alloc_next_ascii(#class_name_cstr));
+                    let name: &'static ClassId = CLASS_ID.get_or_init(|| ClassId::__alloc_next_unicode(#godot_class_str));
                     *name
                 }
 

godot-core/src/meta/class_id.rs

@@ -9,7 +9,6 @@ use std::any::TypeId;
 use std::borrow::Cow;
 use std::cell::OnceCell;
 use std::collections::HashMap;
-use std::ffi::CStr;
 use std::fmt;
 use std::hash::Hash;
 
@@ -95,7 +94,7 @@ impl ClassId {
             "In Godot < 4.4, class name must be ASCII: '{name}'"
         );
 
-        cache.insert_class_id(ClassIdSource::Owned(name), Some(type_id), false)
+        cache.insert_class_id(ClassIdSource(Cow::Owned(name)), Some(type_id), false)
     }
 
     /// Create a `ClassId` from a runtime string (for dynamic class names).
@@ -105,7 +104,7 @@ impl ClassId {
     pub(crate) fn new_dynamic(class_name: String) -> Self {
         let mut cache = CLASS_ID_CACHE.lock();
 
-        cache.insert_class_id(ClassIdSource::Owned(class_name), None, false)
+        cache.insert_class_id(ClassIdSource(Cow::Owned(class_name)), None, false)
     }
 
     // Test-only APIs.
@@ -127,37 +126,16 @@ impl ClassId {
         Self { global_index: 0 }
     }
 
-    /// Create a new ASCII; expect to be unique. Internal, reserved for macros.
-    #[doc(hidden)]
-    pub fn __alloc_next_ascii(class_name_cstr: &'static CStr) -> Self {
-        let utf8 = class_name_cstr
-            .to_str()
-            .expect("class name is invalid UTF-8");
-
-        assert!(
-            utf8.is_ascii(),
-            "ClassId::alloc_next_ascii() with non-ASCII Unicode string '{utf8}'"
-        );
-
-        let source = ClassIdSource::Borrowed(class_name_cstr);
-        let mut cache = CLASS_ID_CACHE.lock();
-        cache.insert_class_id(source, None, true)
-    }
-
     /// Create a new Unicode entry; expect to be unique. Internal, reserved for macros.
     #[doc(hidden)]
     pub fn __alloc_next_unicode(class_name_str: &'static str) -> Self {
+        #[cfg(before_api = "4.4")]
         assert!(
-            cfg!(since_api = "4.4"),
+            class_name_str.is_ascii(),
             "Before Godot 4.4, class names must be ASCII, but '{class_name_str}' is not.\nSee https://github.com/godotengine/godot/pull/96501."
         );
 
-        assert!(
-            !class_name_str.is_ascii(),
-            "ClassId::__alloc_next_unicode() with ASCII string '{class_name_str}'"
-        );
-
-        let source = ClassIdSource::Owned(class_name_str.to_owned());
+        let source = ClassIdSource(Cow::Borrowed(class_name_str));
         let mut cache = CLASS_ID_CACHE.lock();
         cache.insert_class_id(source, None, true)
     }
@@ -206,15 +184,13 @@ impl ClassId {
 
 impl fmt::Display for ClassId {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.with_string_name(|s| s.fmt(f))
+        self.to_cow_str().fmt(f)
     }
 }
 
 impl fmt::Debug for ClassId {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let cache = CLASS_ID_CACHE.lock();
-        let entry = cache.get_entry(self.global_index as usize);
-        let name = entry.rust_str.as_cow_str();
+        let name = self.to_cow_str();
 
         if name.is_empty() {
             write!(f, "ClassId(none)")
@@ -224,10 +200,6 @@ impl fmt::Debug for ClassId {
     }
 }
 
-fn ascii_cstr_to_str(cstr: &CStr) -> &str {
-    cstr.to_str().expect("should be validated ASCII")
-}
-
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 
 /// Entry in the class name cache.
@@ -247,31 +219,25 @@ impl ClassIdEntry {
     }
 
     fn none() -> Self {
-        Self::new(ClassIdSource::Borrowed(c""))
+        Self::new(ClassIdSource(Cow::Borrowed("")))
     }
 }
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 
-/// `Cow`-like enum for class names, but with C strings as the borrowed variant.
-enum ClassIdSource {
-    Owned(String),
-    Borrowed(&'static CStr),
-}
+/// `Cow` for class names, with static strings as the borrowed variant.
+struct ClassIdSource(Cow<'static, str>);
 
 impl ClassIdSource {
     fn to_string_name(&self) -> StringName {
-        match self {
-            ClassIdSource::Owned(s) => StringName::from(s),
-            ClassIdSource::Borrowed(cstr) => StringName::__cstr(cstr),
+        match &self.0 {
+            Cow::Owned(s) => StringName::from(s),
+            Cow::Borrowed(str) => StringName::from(*str),
         }
     }
 
     fn as_cow_str(&self) -> Cow<'static, str> {
-        match self {
-            ClassIdSource::Owned(s) => Cow::Owned(s.clone()),
-            ClassIdSource::Borrowed(cstr) => Cow::Borrowed(ascii_cstr_to_str(cstr)),
-        }
+        self.0.clone()
     }
 }
 // ----------------------------------------------------------------------------------------------------------------------------------------------

godot-core/src/meta/signature.rs

@@ -470,7 +470,7 @@ impl<'a> CallContext<'a> {
     }
 
     /// Call from Godot into a custom Callable.
-    pub fn custom_callable(function_name: &'a str) -> Self {
+    pub const fn custom_callable(function_name: &'a str) -> Self {
         Self {
             class_name: Cow::Borrowed("<Callable>"),
             function_name,

godot-macros/src/class/derive_godot_class.rs

@@ -55,15 +55,7 @@ pub fn derive_godot_class(item: venial::Item) -> ParseResult<TokenStream> {
         .map_or_else(|| class.name.clone(), |rename| rename)
         .to_string();
 
-    // Determine if we can use ASCII for the class name (in most cases).
-    // Crate godot-macros does not have knowledge of `api-*` features (and neither does user crate where macros are generated),
-    // so we can't cause a compile error if Unicode is used before Godot 4.4. However, this causes a runtime error at startup.
-    let class_name_allocation = if class_name_str.is_ascii() {
-        let c_str = util::c_str(&class_name_str);
-        quote! { ClassId::__alloc_next_ascii(#c_str) }
-    } else {
-        quote! { ClassId::__alloc_next_unicode(#class_name_str) }
-    };
+    let class_name_allocation = quote! { ClassId::__alloc_next_unicode(#class_name_str) };
 
     if struct_cfg.is_internal {
         modifiers.push(quote! { with_internal })

itest/rust/src/object_tests/class_name_test.rs

@@ -158,10 +158,10 @@ fn class_name_debug() {
 fn class_name_alloc_panic() {
     // ASCII.
     {
-        let _1st = ClassId::__alloc_next_ascii(c"DuplicateTestClass");
+        let _1st = ClassId::__alloc_next_unicode("DuplicateTestClass");
 
         expect_panic("2nd allocation with same ASCII string fails", || {
-            let _2nd = ClassId::__alloc_next_ascii(c"DuplicateTestClass");
+            let _2nd = ClassId::__alloc_next_unicode("DuplicateTestClass");
         });
     }