Unexpose static_name! for now

Author: Bromeon

godot-core/src/builtin/mod.rs

@@ -41,7 +41,7 @@ pub mod __prelude_reexport {
     pub use rect2i::*;
     pub use rid::*;
     pub use signal::*;
-    pub use string::{static_name, Encoding, GString, NodePath, StringName};
+    pub use string::{Encoding, GString, NodePath, StringName};
     pub use transform2d::*;
     pub use transform3d::*;
     pub use variant::*;
@@ -54,6 +54,9 @@ pub mod __prelude_reexport {
     #[allow(deprecated)]
     #[rustfmt::skip] // Do not reorder.
     pub use crate::dict;
+
+    #[cfg(feature = "trace")] // Test only.
+    pub use crate::static_sname;
 }
 
 pub use __prelude_reexport::*;

godot-core/src/builtin/string/mod.rs

@@ -20,7 +20,6 @@ pub use string_name::*;
 use crate::meta;
 use crate::meta::error::ConvertError;
 use crate::meta::{FromGodot, GodotConvert, ToGodot};
-pub use crate::static_name;
 
 impl GodotConvert for &str {
     type Via = GString;

godot-core/src/builtin/string/string_name.rs

@@ -34,11 +34,6 @@ use crate::{impl_shared_string_api, meta};
 /// Note that Godot ignores any bytes after a null-byte. This means that for instance `"hello, world!"` and  \
 /// `"hello, world!\0 ignored by Godot"` will be treated as the same string if converted to a `StringName`.
 ///
-/// # Performance
-///
-/// The fastest way to create string names is using [`static_name!`][crate::builtin::static_name], which creates a static cached `StringName` from null-terminated C-string literals such as `c"MyClass"`. These can be used directly by Godot without conversion. The encoding is limited to Latin-1, however. See the corresponding
-/// [`From<&CStr>` impl](#impl-From<%26CStr>-for-StringName).
-///
 /// # All string types
 ///
 /// | Intended use case | String type                                |
@@ -492,29 +487,17 @@ mod serialize {
     }
 }
 
+// TODO(v0.4.x): consider re-exposing in public API. Open questions: thread-safety, performance, memory leaks, global overhead.
 /// Creates and gets a reference to a static `StringName` from a ASCII/Latin-1 `c"string"`.
 ///
 /// This is the fastest way to create a StringName repeatedly, with the result being cached and never released, like `SNAME` in Godot source code. Suitable for scenarios where high performance is required.
 #[macro_export]
-macro_rules! static_name {
+macro_rules! static_sname {
     ($str:literal) => {{
         use std::sync::OnceLock;
 
-        use godot::sys;
-
         let c_str: &'static std::ffi::CStr = $str;
         static SNAME: OnceLock<StringName> = OnceLock::new();
-        SNAME.get_or_init(|| {
-            // SAFETY: c_str is nul-terminated and remains valid for entire program duration.
-            unsafe {
-                StringName::new_with_string_uninit(|ptr| {
-                    sys::interface_fn!(string_name_new_with_latin1_chars)(
-                        ptr,
-                        c_str.as_ptr(),
-                        sys::conv::SYS_TRUE, // p_is_static
-                    )
-                })
-            }
-        })
+        SNAME.get_or_init(|| StringName::__static_cstr(c_str))
     }};
 }

itest/rust/src/builtin_tests/string/string_name_test.rs

@@ -7,7 +7,7 @@
 
 use std::collections::HashSet;
 
-use godot::builtin::{static_name, Encoding, GString, NodePath, StringName};
+use godot::builtin::{static_sname, Encoding, GString, NodePath, StringName};
 
 use crate::framework::{assert_eq_self, itest};
 
@@ -135,24 +135,24 @@ fn string_name_from_cstr() {
 }
 
 #[itest]
-fn string_name_static_name() {
-    let a = static_name!(c"pure ASCII\t[~]").clone();
+fn string_name_static_sname() {
+    let a = static_sname!(c"pure ASCII\t[~]").clone();
     let b = StringName::from("pure ASCII\t[~]");
 
     assert_eq!(a, b);
 
     let a1 = a.clone();
-    let a2 = static_name!(c"pure ASCII\t[~]").clone();
+    let a2 = static_sname!(c"pure ASCII\t[~]").clone();
 
     assert_eq!(a, a1);
     assert_eq!(a1, a2);
 
-    let a = static_name!(c"\xB1").clone();
+    let a = static_sname!(c"\xB1").clone();
     let b = StringName::from("±");
 
     assert_eq!(a, b);
 
-    let a = static_name!(c"Latin-1 \xA3 \xB1 text \xBE").clone();
+    let a = static_sname!(c"Latin-1 \xA3 \xB1 text \xBE").clone();
     let b = StringName::from("Latin-1 £ ± text ¾");
 
     assert_eq!(a, b);