zerocopy-derive: Fix panic with raw identifiers

zerocopy-derive/src/enum.rs

@@ -43,7 +43,8 @@ pub(crate) fn generate_tag_enum(repr: &EnumRepr, data: &DataEnum) -> TokenStream
 }
 
 fn tag_ident(variant_ident: &Ident) -> Ident {
-    Ident::new(&format!("___ZEROCOPY_TAG_{}", variant_ident), variant_ident.span())
+    let variant_ident_str = crate::ext::to_ident_str(variant_ident);
+    Ident::new(&format!("___ZEROCOPY_TAG_{}", variant_ident_str), variant_ident.span())
 }
 
 /// Generates a constant for the tag associated with each variant of the enum.
@@ -84,7 +85,8 @@ fn generate_tag_consts(data: &DataEnum) -> TokenStream {
 }
 
 fn variant_struct_ident(variant_ident: &Ident) -> Ident {
-    Ident::new(&format!("___ZerocopyVariantStruct_{}", variant_ident), variant_ident.span())
+    let variant_ident_str = crate::ext::to_ident_str(variant_ident);
+    Ident::new(&format!("___ZerocopyVariantStruct_{}", variant_ident_str), variant_ident.span())
 }
 
 /// Generates variant structs for the given enum variant.
@@ -162,7 +164,8 @@ fn generate_variants_union(generics: &Generics, data: &DataEnum) -> TokenStream
 
         // Field names are prefixed with `__field_` to prevent name collision with
         // the `__nonempty` field.
-        let field_name = Ident::new(&format!("__field_{}", &variant.ident), variant.ident.span());
+        let field_name_str = crate::ext::to_ident_str(&variant.ident);
+        let field_name = Ident::new(&format!("__field_{}", field_name_str), variant.ident.span());
         let variant_struct_ident = variant_struct_ident(&variant.ident);
 
         Some(quote! {

zerocopy-derive/src/ext.rs

@@ -112,3 +112,12 @@ fn map_fields<'a>(
         })
         .collect()
 }
+
+pub(crate) fn to_ident_str(t: &impl ToString) -> String {
+    let s = t.to_string();
+    if let Some(stripped) = s.strip_prefix("r#") {
+        stripped.to_string()
+    } else {
+        s
+    }
+}

zerocopy-derive/src/lib.rs

@@ -318,8 +318,10 @@ fn derive_known_layout_inner(
 
             // Generate a valid ident for a type-level handle to a field of a
             // given `name`.
-            let field_index =
-                |name| Ident::new(&format!("__Zerocopy_Field_{}", name), ident.span());
+            let field_index = |name: &TokenStream| {
+                let name = to_ident_str(name);
+                Ident::new(&format!("__Zerocopy_Field_{}", name), ident.span())
+            };
 
             let field_indices: Vec<_> =
                 fields.iter().map(|(_vis, name, _ty)| field_index(name)).collect();

zerocopy-derive/tests/enum_try_from_bytes.rs

@@ -642,3 +642,11 @@ mod issue_2051 {
         I32_MUL,
     }
 }
+
+#[derive(imp::TryFromBytes)]
+#[repr(u8)]
+enum RawIdentifierVariant {
+    r#type,
+}
+
+util_assert_impl_all!(RawIdentifierVariant: imp::TryFromBytes);

zerocopy-derive/tests/struct_known_layout.rs

@@ -112,3 +112,11 @@ struct Packet<P> {
 }
 
 util_assert_impl_all!(Packet<imp::u8>: imp::KnownLayout);
+
+#[derive(imp::KnownLayout)]
+#[repr(C)]
+struct RawIdentifier {
+    r#type: u8,
+}
+
+util_assert_impl_all!(RawIdentifier: imp::KnownLayout);