Define CowStr type alias (internal for now)

Author: Bromeon

godot-core/src/builtin/mod.rs

@@ -22,6 +22,10 @@ pub use crate::sys::VariantType;
 #[allow(deprecated)] // dict
 pub use crate::{array, dict, real, reals, varray, vdict};
 
+/// Abbreviation for occasionally used _owned or borrowed string_.
+#[doc(hidden)]
+pub type CowStr = std::borrow::Cow<'static, str>;
+
 #[doc(hidden)]
 pub mod __prelude_reexport {
     #[rustfmt::skip] // Do not reorder.

godot-core/src/meta/class_id.rs

@@ -156,7 +156,7 @@ impl ClassId {
     }
 
     /// Returns an owned or borrowed `str` representing the class name.
-    pub fn to_cow_str(&self) -> Cow<'static, str> {
+    pub fn to_cow_str(&self) -> CowStr {
         let cache = CLASS_ID_CACHE.lock();
         let entry = cache.get_entry(self.global_index as usize);
         entry.rust_str.clone()
@@ -206,12 +206,12 @@ impl fmt::Debug for ClassId {
 ///
 /// `StringName` needs to be lazy-initialized because the Godot binding may not be initialized yet.
 struct ClassIdEntry {
-    rust_str: Cow<'static, str>,
+    rust_str: CowStr,
     godot_str: OnceCell<StringName>,
 }
 
 impl ClassIdEntry {
-    fn new(rust_str: Cow<'static, str>) -> Self {
+    fn new(rust_str: CowStr) -> Self {
         Self {
             rust_str,
             godot_str: OnceCell::new(),
@@ -257,7 +257,7 @@ impl ClassIdCache {
     /// If `expect_first` is true and the string is already present in the cache.
     fn insert_class_id(
         &mut self,
-        source: Cow<'static, str>,
+        source: CowStr,
         type_id: Option<TypeId>,
         expect_first: bool,
     ) -> ClassId {

godot-core/src/registry/signal/connect_handle.rs

@@ -5,9 +5,7 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-use std::borrow::Cow;
-
-use crate::builtin::Callable;
+use crate::builtin::{Callable, CowStr};
 use crate::classes::Object;
 use crate::obj::Gd;
 use crate::sys;
@@ -20,15 +18,15 @@ use crate::sys;
 /// Connections managed by a handle can be disconnected using [`disconnect()`][Self::disconnect].
 pub struct ConnectHandle {
     receiver_object: Gd<Object>,
-    signal_name: Cow<'static, str>,
+    signal_name: CowStr,
     callable: Callable,
 }
 
 impl ConnectHandle {
     // Should only be invoked by connect_* methods.
     pub(super) fn new(
         receiver_object: Gd<Object>,
-        signal_name: Cow<'static, str>,
+        signal_name: CowStr,
         callable: Callable,
     ) -> Self {
         Self {

godot-core/src/registry/signal/typed_signal.rs

@@ -10,7 +10,7 @@ use std::marker::PhantomData;
 use std::ops::DerefMut;
 
 use super::{make_callable_name, make_godot_fn, ConnectBuilder, ConnectHandle, SignalObject};
-use crate::builtin::{Callable, Variant};
+use crate::builtin::{Callable, CowStr, Variant};
 use crate::classes::object::ConnectFlags;
 use crate::meta;
 use crate::meta::{InParamTuple, ObjectToOwned, UniformObjectDeref};
@@ -52,7 +52,7 @@ use crate::registry::signal::signal_receiver::{IndirectSignalReceiver, SignalRec
 pub struct TypedSignal<'c, C: WithSignals, Ps> {
     /// In Godot, valid signals (unlike funcs) are _always_ declared in a class and become part of each instance. So there's always an object.
     object: C::__SignalObj<'c>,
-    name: Cow<'static, str>,
+    name: CowStr,
     _signature: PhantomData<Ps>,
 }
 

itest/rust/src/object_tests/class_name_test.rs

@@ -5,9 +5,7 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-use std::borrow::Cow;
-
-use godot::builtin::{GString, StringName};
+use godot::builtin::{CowStr, GString, StringName};
 use godot::meta::ClassId;
 use godot::obj::bounds::implement_godot_bounds;
 use godot::obj::GodotClass;
@@ -48,7 +46,7 @@ fn class_name_godotclass() {
     assert_eq!(a.to_string(), "A");
     assert_eq!(a.to_gstring(), GString::from("A"));
     assert_eq!(a.to_string_name(), StringName::from("A"));
-    assert_eq!(a.to_cow_str(), Cow::<'static, str>::Owned("A".to_string()));
+    assert_eq!(a.to_cow_str(), CowStr::Owned("A".to_string()));
 }
 
 #[cfg(since_api = "4.4")]
@@ -63,10 +61,7 @@ fn class_name_godotclass_unicode() {
     assert_eq!(a.to_string(), "统一码");
     assert_eq!(a.to_gstring(), GString::from("统一码"));
     assert_eq!(a.to_string_name(), StringName::from("统一码"));
-    assert_eq!(
-        a.to_cow_str(),
-        Cow::<'static, str>::Owned("统一码".to_string())
-    );
+    assert_eq!(a.to_cow_str(), CowStr::Owned("统一码".to_string()));
 
     let b = ClassId::__dynamic("统一码");
     assert_eq!(a, b);