[derive] Improve hygiene testing

In zerocopy-derive tests, import `zerocopy` as `zerocopy_renamed` so
that references to `::zerocopy` fail to resolve. This ensures that no
generated code hard-codes `zerocopy` or `::zerocopy`, and instead all
references make use of the provided custom crate name.

gherrit-pr-id: G3cb376b3f2d996151636f7aebb3a33f4134162e6

Author: joshlf

zerocopy-derive/Cargo.toml

@@ -55,4 +55,8 @@ testutil = { path = "../testutil" }
 # sometimes change the output format slightly, so a version mismatch can cause
 # CI test failures.
 trybuild = { version = "=1.0.89", features = ["diff"] }
-zerocopy = { path = "../", features = ["derive"] }
+# We import as `zerocopy-renamed` so that we can refer to the crate as
+# `zerocopy-renamed` in the generated code, which allows us to test that the
+# `crate` attribute works correctly, and ensures that we never accidentally
+# hard-code the name `zerocopy` in the generated code.
+zerocopy-renamed = { package = "zerocopy", path = "../", features = ["derive"] }

zerocopy-derive/src/enum.rs

@@ -21,7 +21,8 @@ use crate::{
 /// Generates a tag enum for the given enum. This generates an enum with the
 /// same non-align `repr`s, variants, and corresponding discriminants, but none
 /// of the fields.
-pub(crate) fn generate_tag_enum(repr: &EnumRepr, data: &DataEnum) -> TokenStream {
+pub(crate) fn generate_tag_enum(ctx: &Ctx, repr: &EnumRepr, data: &DataEnum) -> TokenStream {
+    let zerocopy_crate = &ctx.zerocopy_crate;
     let variants = data.variants.iter().map(|v| {
         let ident = &v.ident;
         if let Some((eq, discriminant)) = &v.discriminant {
@@ -48,7 +49,7 @@ pub(crate) fn generate_tag_enum(repr: &EnumRepr, data: &DataEnum) -> TokenStream
 
         // SAFETY: `___ZerocopyTag` has no fields, and so it does not permit
         // interior mutation.
-        unsafe impl ::zerocopy::Immutable for ___ZerocopyTag {
+        unsafe impl #zerocopy_crate::Immutable for ___ZerocopyTag {
             fn only_derive_is_allowed_to_implement_this_trait() {}
         }
     }
@@ -240,7 +241,7 @@ pub(crate) fn derive_is_bit_valid(
     repr: &EnumRepr,
 ) -> Result<TokenStream, Error> {
     let trait_path = Trait::TryFromBytes.crate_path(&ctx.zerocopy_crate);
-    let tag_enum = generate_tag_enum(repr, data);
+    let tag_enum = generate_tag_enum(ctx, repr, data);
     let tag_consts = generate_tag_consts(data);
 
     let (outer_tag_type, inner_tag_type) = if repr.is_c() {

zerocopy-derive/src/lib.rs

@@ -651,13 +651,14 @@ fn derive_split_at_inner(ctx: &Ctx, _top_level: Trait) -> Result<TokenStream, Er
         return Err(Error::new(Span::call_site(), "must at least one field"));
     };
 
+    let zerocopy_crate = &ctx.zerocopy_crate;
     // SAFETY: `#ty`, per the above checks, is `repr(C)` or `repr(transparent)`
     // and is not packed; its trailing field is guaranteed to be well-aligned
     // for its type. By invariant on `FieldBounds::TRAILING_SELF`, the trailing
     // slice of the trailing field is also well-aligned for its type.
     Ok(ImplBlockBuilder::new(ctx, &ctx.ast.data, Trait::SplitAt, FieldBounds::TRAILING_SELF)
         .inner_extras(quote! {
-            type Elem = <#trailing_field as ::zerocopy::SplitAt>::Elem;
+            type Elem = <#trailing_field as #zerocopy_crate::SplitAt>::Elem;
         })
         .build())
 }
@@ -1219,7 +1220,7 @@ fn derive_into_bytes_enum(ctx: &Ctx, enm: &DataEnum) -> Result<TokenStream, Erro
         ));
     }
 
-    let tag_type_definition = r#enum::generate_tag_enum(&repr, enm);
+    let tag_type_definition = r#enum::generate_tag_enum(ctx, &repr, enm);
     Ok(ImplBlockBuilder::new(ctx, enm, Trait::IntoBytes, FieldBounds::ALL_SELF)
         .padding_check(PaddingCheck::Enum { tag_type_definition })
         .build())

zerocopy-derive/src/util.rs

@@ -31,8 +31,8 @@ impl Ctx {
                         if meta.path.is_ident("crate") {
                             let expr = meta.value().and_then(|value| value.parse());
                             if let Ok(Expr::Lit(ExprLit { lit: Lit::Str(lit), .. })) = expr {
-                                if let Ok(path_lit) = lit.parse() {
-                                    path = path_lit;
+                                if let Ok(path_lit) = lit.parse::<Ident>() {
+                                    path = parse_quote!(::#path_lit);
                                     return Ok(());
                                 }
                             }

zerocopy-derive/tests/crate_path.rs

@@ -26,6 +26,7 @@ macro_rules! test {
 
                     #[deprecated = "do not use"]
                     #[derive(imp::$trait)]
+                    #[zerocopy(crate = "zerocopy_renamed")]
                     $ty
 
                     #[allow(deprecated)]
@@ -53,6 +54,7 @@ mod enum_hash_eq {
         use super::super::*;
         #[deprecated = "do not use"]
         #[derive(imp::ByteHash, imp::IntoBytes, imp::Immutable)]
+        #[zerocopy(crate = "zerocopy_renamed")]
         #[repr(u8)]
         enum Enum {
             A,
@@ -67,6 +69,7 @@ mod enum_hash_eq {
         use super::super::*;
         #[deprecated = "do not use"]
         #[derive(imp::ByteEq, imp::IntoBytes, imp::Immutable)]
+        #[zerocopy(crate = "zerocopy_renamed")]
         #[repr(u8)]
         enum Enum {
             A,
@@ -84,6 +87,7 @@ mod struct_hash_eq {
         use super::super::*;
         #[deprecated = "do not use"]
         #[derive(imp::ByteHash, imp::IntoBytes, imp::Immutable)]
+        #[zerocopy(crate = "zerocopy_renamed")]
         #[repr(C)]
         struct Struct;
 
@@ -96,6 +100,7 @@ mod struct_hash_eq {
         use super::super::*;
         #[deprecated = "do not use"]
         #[derive(imp::ByteEq, imp::IntoBytes, imp::Immutable)]
+        #[zerocopy(crate = "zerocopy_renamed")]
         #[repr(C)]
         struct Struct;
 
@@ -112,6 +117,7 @@ mod split_at_test {
         use super::super::*;
         #[deprecated = "do not use"]
         #[derive(imp::SplitAt, imp::KnownLayout)]
+        #[zerocopy(crate = "zerocopy_renamed")]
         #[repr(C)]
         struct Struct {
             a: [u8],

zerocopy-derive/tests/deprecated.rs

@@ -48,6 +48,7 @@ fn test_trivial_is_bit_valid() {
 // Make sure no deprecation warning is generated from our derive (see #553).
 #[deprecated = "do not use"]
 #[derive(imp::FromBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(u8)]
 enum FooU8 {
     Variant0,
@@ -309,6 +310,7 @@ enum FooU8 {
 }
 
 #[derive(imp::FromBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(u8)]
 enum FooU8WithData {
     Variant0(u32),
@@ -575,6 +577,7 @@ fn _allow_deprecated() {
 }
 
 #[derive(imp::FromBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(i8)]
 enum FooI8 {
     Variant0,
@@ -838,6 +841,7 @@ enum FooI8 {
 util_assert_impl_all!(FooI8: imp::FromBytes);
 
 #[derive(imp::FromBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(u8, align(2))]
 enum FooU8Align {
     Variant0,
@@ -1101,6 +1105,7 @@ enum FooU8Align {
 util_assert_impl_all!(FooU8Align: imp::FromBytes);
 
 #[derive(imp::FromBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(i8, align(2))]
 enum FooI8Align {
     Variant0,
@@ -1364,6 +1369,7 @@ enum FooI8Align {
 util_assert_impl_all!(FooI8Align: imp::FromBytes);
 
 #[derive(imp::FromBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(u16)]
 enum FooU16 {
     Variant0,
@@ -66907,6 +66913,7 @@ enum FooU16 {
 util_assert_impl_all!(FooU16: imp::FromBytes);
 
 #[derive(imp::FromBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(i16)]
 enum FooI16 {
     Variant0,