StringName: remove From impl for &'static CStr

Author: Bromeon

godot-codegen/src/util.rs

@@ -41,7 +41,7 @@ pub fn c_str(string: &str) -> Literal {
 pub fn make_string_name(identifier: &str) -> TokenStream {
     let lit = c_str(identifier);
 
-    quote! { StringName::from(#lit) }
+    quote! { StringName::__static_cstr(#lit) }
 }
 
 pub fn make_sname_ptr(identifier: &str) -> TokenStream {

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

@@ -4,6 +4,7 @@
  * 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 std::fmt;
 
 use godot_ffi as sys;
@@ -248,6 +249,37 @@ impl StringName {
     pub fn as_inner(&self) -> inner::InnerStringName<'_> {
         inner::InnerStringName::from_outer(self)
     }
+
+    /// Creates a `StringName` from a static ASCII/Latin-1 `c"string"`.
+    ///
+    /// This avoids unnecessary copies and allocations and directly uses the backing buffer. Useful for literals.
+    ///
+    /// Note that while Latin-1 encoding is the most common encoding for c-strings, it isn't a requirement. So if your c-string
+    /// uses a different encoding (e.g. UTF-8), it is possible that some characters will not show up as expected.
+    ///
+    /// # Safety
+    /// `c_str` must be a static c-string that remains valid for the entire program duration.
+    ///
+    /// # Example
+    /// ```no_run
+    /// use godot::builtin::StringName;
+    ///
+    /// // '±' is a Latin-1 character with codepoint 0xB1. Note that this is not UTF-8, where it would need two bytes.
+    /// let sname = StringName::__static_cstr(c"\xb1 Latin-1 string");
+    /// ```
+    #[doc(hidden)] // Private for now. Needs API discussion, also regarding overlap with try_from_cstr().
+    pub fn __static_cstr(c_str: &'static std::ffi::CStr) -> Self {
+        // SAFETY: c_str is nul-terminated and remains valid for entire program duration.
+        unsafe {
+            Self::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
+                )
+            })
+        }
+    }
 }
 
 // SAFETY:
@@ -354,35 +386,6 @@ impl From<&NodePath> for StringName {
     }
 }
 
-impl From<&std::ffi::CStr> for StringName {
-    /// Creates a `StringName` from a ASCII/Latin-1 `c"string"`.
-    ///
-    /// This avoids unnecessary copies and allocations and directly uses the backing buffer. Useful for literals.
-    ///
-    /// Note that while Latin-1 encoding is the most common encoding for c-strings, it isn't a requirement. So if your c-string
-    /// uses a different encoding (e.g. UTF-8), it is possible that some characters will not show up as expected.
-    ///
-    /// # Example
-    /// ```no_run
-    /// use godot::builtin::StringName;
-    ///
-    /// // '±' is a Latin-1 character with codepoint 0xB1. Note that this is not UTF-8, where it would need two bytes.
-    /// let sname = StringName::from(c"\xb1 Latin-1 string");
-    /// ```
-    fn from(c_str: &std::ffi::CStr) -> Self {
-        // SAFETY: c_str is nul-terminated and remains valid for entire program duration.
-        unsafe {
-            Self::new_with_string_uninit(|ptr| {
-                sys::interface_fn!(string_name_new_with_latin1_chars)(
-                    ptr,
-                    c_str.as_ptr(),
-                    sys::conv::SYS_FALSE, // p_is_static
-                )
-            })
-        }
-    }
-}
-
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Ordering
 

godot-core/src/meta/args/as_arg.rs

@@ -5,8 +5,6 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-use std::ffi::CStr;
-
 use crate::builtin::{GString, NodePath, StringName, Variant};
 use crate::meta::sealed::Sealed;
 use crate::meta::traits::{GodotFfiVariant, GodotNullableFfi};
@@ -562,12 +560,6 @@ impl AsArg<StringName> for &String {
     }
 }
 
-impl AsArg<StringName> for &'static CStr {
-    fn into_arg<'arg>(self) -> CowArg<'arg, StringName> {
-        CowArg::Owned(StringName::from(self))
-    }
-}
-
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // NodePath
 

godot-core/src/meta/class_id.rs

@@ -263,7 +263,7 @@ impl ClassIdSource {
     fn to_string_name(&self) -> StringName {
         match self {
             ClassIdSource::Owned(s) => StringName::from(s),
-            ClassIdSource::Borrowed(cstr) => StringName::from(*cstr),
+            ClassIdSource::Borrowed(cstr) => StringName::__cstr(cstr),
         }
     }
 

godot-macros/src/class/data_models/inherent_impl.rs

@@ -459,7 +459,7 @@ fn add_virtual_script_call(
 
     let code = quote! {
         let object_ptr = #object_ptr;
-        let method_sname = ::godot::builtin::StringName::from(#method_name_cstr);
+        let method_sname = ::godot::builtin::StringName::__static_cstr(#method_name_cstr);
         let method_sname_ptr = method_sname.string_sys();
         let has_virtual_override = unsafe { ::godot::private::has_virtual_script_method(object_ptr, method_sname_ptr) };
 

itest/rust/src/builtin_tests/convert_test.rs

@@ -344,7 +344,6 @@ fn strings_as_arg() {
     // Note: CowArg is an internal type.
 
     let str = "GodotRocks";
-    let cstr = c"GodotRocks";
     let gstring = GString::from("GodotRocks");
     let sname = StringName::from("GodotRocks");
     let npath = NodePath::from("GodotRocks");
@@ -355,7 +354,6 @@ fn strings_as_arg() {
     assert_eq!(as_gstr_arg(npath.arg()), CowArg::Owned(gstring.clone()));
 
     assert_eq!(as_sname_arg(str), CowArg::Owned(sname.clone()));
-    assert_eq!(as_sname_arg(cstr), CowArg::Owned(sname.clone()));
     assert_eq!(as_sname_arg(&sname), CowArg::Borrowed(&sname));
     assert_eq!(as_sname_arg(gstring.arg()), CowArg::Owned(sname.clone()));
     assert_eq!(as_sname_arg(npath.arg()), CowArg::Owned(sname.clone()));

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

@@ -127,7 +127,7 @@ fn string_name_from_cstr() {
     ];
 
     for (bytes, string) in cases.into_iter() {
-        let a = StringName::from(bytes);
+        let a = StringName::__static_cstr(bytes);
         let b = StringName::from(string);
 
         assert_eq!(a, b);