Don't unnecessarily Copy encodings

madsmtm · madsmtm · commit e8dec22a4953 · 2022-08-28T16:26:59.000+02:00
diff --git a/objc2-encode/src/encoding.rs b/objc2-encode/src/encoding.rs
@@ -218,7 +218,7 @@ fn equivalent_to(enc1: &Encoding<'_>, enc2: &Encoding<'_>, level: NestingLevel)
     // should compare equal, but we don't bother since in practice a plain
     // `Unknown` will never appear.
     use Helper::*;
-    match (Helper::new(*enc1), Helper::new(*enc2)) {
+    match (Helper::new(enc1), Helper::new(enc2)) {
         (Primitive(p1), Primitive(p2)) => p1 == p2,
         (BitField(b1, type1), BitField(b2, type2)) => {
             b1 == b2 && equivalent_to(type1, type2, level.bitfield())
@@ -252,7 +252,11 @@ fn equivalent_to(enc1: &Encoding<'_>, enc2: &Encoding<'_>, level: NestingLevel)
     }
 }
 
-fn display_fmt(this: Encoding<'_>, f: &mut fmt::Formatter<'_>, level: NestingLevel) -> fmt::Result {
+fn display_fmt(
+    this: &Encoding<'_>,
+    f: &mut fmt::Formatter<'_>,
+    level: NestingLevel,
+) -> fmt::Result {
     use Helper::*;
     match Helper::new(this) {
         Primitive(primitive) => f.write_str(primitive.to_str()),
@@ -262,12 +266,12 @@ fn display_fmt(this: Encoding<'_>, f: &mut fmt::Formatter<'_>, level: NestingLev
         }
         Indirection(kind, t) => {
             write!(f, "{}", kind.prefix())?;
-            display_fmt(*t, f, level.indirection(kind))
+            display_fmt(t, f, level.indirection(kind))
         }
         Array(len, item) => {
             write!(f, "[")?;
             write!(f, "{}", len)?;
-            display_fmt(*item, f, level.array())?;
+            display_fmt(item, f, level.array())?;
             write!(f, "]")
         }
         Container(kind, name, fields) => {
@@ -276,7 +280,7 @@ fn display_fmt(this: Encoding<'_>, f: &mut fmt::Formatter<'_>, level: NestingLev
             if let Some(level) = level.container() {
                 write!(f, "=")?;
                 for field in fields {
-                    display_fmt(*field, f, level)?;
+                    display_fmt(field, f, level)?;
                 }
             }
             write!(f, "{}", kind.end())
@@ -292,7 +296,7 @@ fn display_fmt(this: Encoding<'_>, f: &mut fmt::Formatter<'_>, level: NestingLev
 /// Objective-C compilers.
 impl fmt::Display for Encoding<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        display_fmt(*self, f, NestingLevel::new())
+        display_fmt(self, f, NestingLevel::new())
     }
 }
 
@@ -375,7 +379,7 @@ mod tests {
                 )*
 
                 // Check static str
-                const STATIC_ENCODING_DATA: [u8; static_encoding_str_len(E, NestingLevel::new())] = static_encoding_str_array(E, NestingLevel::new());
+                const STATIC_ENCODING_DATA: [u8; static_encoding_str_len(&E, NestingLevel::new())] = static_encoding_str_array(&E, NestingLevel::new());
                 const STATIC_ENCODING_STR: &str = unsafe { core::str::from_utf8_unchecked(&STATIC_ENCODING_DATA) };
                 assert_eq!(STATIC_ENCODING_STR, $string);
             }
diff --git a/objc2-encode/src/helper.rs b/objc2-encode/src/helper.rs
@@ -167,7 +167,7 @@ pub(crate) enum Helper<'a> {
 }
 
 impl<'a> Helper<'a> {
-    pub(crate) const fn new(encoding: Encoding<'a>) -> Self {
+    pub(crate) const fn new(encoding: &Encoding<'a>) -> Self {
         use Encoding::*;
         match encoding {
             Char => Self::Primitive(Primitive::Char),
@@ -194,10 +194,10 @@ impl<'a> Helper<'a> {
             Class => Self::Primitive(Primitive::Class),
             Sel => Self::Primitive(Primitive::Sel),
             Unknown => Self::Primitive(Primitive::Unknown),
-            BitField(b, t) => Self::BitField(b, t),
+            BitField(b, t) => Self::BitField(*b, t),
             Pointer(t) => Self::Indirection(IndirectionKind::Pointer, t),
             Atomic(t) => Self::Indirection(IndirectionKind::Atomic, t),
-            Array(len, item) => Self::Array(len, item),
+            Array(len, item) => Self::Array(*len, item),
             Struct(name, fields) => Self::Container(ContainerKind::Struct, name, fields),
             Union(name, members) => Self::Container(ContainerKind::Union, name, members),
         }
diff --git a/objc2-encode/src/parse.rs b/objc2-encode/src/parse.rs
@@ -20,7 +20,7 @@ pub(crate) fn rm_enc_prefix<'a>(
     level: NestingLevel,
 ) -> Option<&'a str> {
     use Helper::*;
-    match Helper::new(*enc) {
+    match Helper::new(enc) {
         Primitive(primitive) => s.strip_prefix(primitive.to_str()),
         BitField(b, _type) => {
             // TODO: Use the type on GNUStep (nesting level?)
diff --git a/objc2-encode/src/static_str.rs b/objc2-encode/src/static_str.rs
@@ -38,7 +38,7 @@ pub(crate) const fn static_int_str_array<const RES: usize>(mut n: u128) -> [u8;
     rev
 }
 
-pub(crate) const fn static_encoding_str_len(encoding: Encoding<'_>, level: NestingLevel) -> usize {
+pub(crate) const fn static_encoding_str_len(encoding: &Encoding<'_>, level: NestingLevel) -> usize {
     use Helper::*;
 
     match Helper::new(encoding) {
@@ -47,8 +47,8 @@ pub(crate) const fn static_encoding_str_len(encoding: Encoding<'_>, level: Nesti
             // TODO: Use the type on GNUStep (nesting level?)
             1 + static_int_str_len(b as u128)
         }
-        Indirection(kind, &t) => 1 + static_encoding_str_len(t, level.indirection(kind)),
-        Array(len, &item) => {
+        Indirection(kind, t) => 1 + static_encoding_str_len(t, level.indirection(kind)),
+        Array(len, item) => {
             1 + static_int_str_len(len as u128) + static_encoding_str_len(item, level.array()) + 1
         }
         Container(_, name, items) => {
@@ -57,7 +57,7 @@ pub(crate) const fn static_encoding_str_len(encoding: Encoding<'_>, level: Nesti
                 res += 1;
                 let mut i = 0;
                 while i < items.len() {
-                    res += static_encoding_str_len(items[i], level);
+                    res += static_encoding_str_len(&items[i], level);
                     i += 1;
                 }
             }
@@ -67,7 +67,7 @@ pub(crate) const fn static_encoding_str_len(encoding: Encoding<'_>, level: Nesti
 }
 
 pub(crate) const fn static_encoding_str_array<const LEN: usize>(
-    encoding: Encoding<'_>,
+    encoding: &Encoding<'_>,
     level: NestingLevel,
 ) -> [u8; LEN] {
     use Helper::*;
@@ -84,7 +84,7 @@ pub(crate) const fn static_encoding_str_array<const LEN: usize>(
                 i += 1;
             }
         }
-        BitField(b, &_type) => {
+        BitField(b, _type) => {
             // TODO: Use the type on GNUStep (nesting level?)
             res[res_i] = b'b';
             res_i += 1;
@@ -98,7 +98,7 @@ pub(crate) const fn static_encoding_str_array<const LEN: usize>(
                 i += 1;
             }
         }
-        Indirection(kind, &t) => {
+        Indirection(kind, t) => {
             res[res_i] = kind.prefix_byte();
             res_i += 1;
 
@@ -111,7 +111,7 @@ pub(crate) const fn static_encoding_str_array<const LEN: usize>(
                 i += 1;
             }
         }
-        Array(len, &item) => {
+        Array(len, item) => {
             let mut res_i = 0;
 
             res[res_i] = b'[';
@@ -158,10 +158,10 @@ pub(crate) const fn static_encoding_str_array<const LEN: usize>(
                 let mut items_i = 0;
                 while items_i < items.len() {
                     // We use LEN even though it creates an oversized array
-                    let field_res = static_encoding_str_array::<LEN>(items[items_i], level);
+                    let field_res = static_encoding_str_array::<LEN>(&items[items_i], level);
 
                     let mut item_res_i = 0;
-                    while item_res_i < static_encoding_str_len(items[items_i], level) {
+                    while item_res_i < static_encoding_str_len(&items[items_i], level) {
                         res[res_i] = field_res[item_res_i];
                         res_i += 1;
                         item_res_i += 1;
