Merge pull request dtolnay#436 from dtolnay/autotraits

dtolnay · web-flow · commit 1edd1b993b79 · 2024-01-06T09:07:57.000-08:00
Transpose ProcMacroAutoTraits struct and PhantomData
diff --git a/src/extra.rs b/src/extra.rs
@@ -3,7 +3,7 @@
 
 use crate::fallback;
 use crate::imp;
-use crate::marker::Marker;
+use crate::marker::{ProcMacroAutoTraits, MARKER};
 use crate::Span;
 use core::fmt::{self, Debug};
 
@@ -14,7 +14,7 @@ use core::fmt::{self, Debug};
 #[derive(Copy, Clone)]
 pub struct DelimSpan {
     inner: DelimSpanEnum,
-    _marker: Marker,
+    _marker: ProcMacroAutoTraits,
 }
 
 #[derive(Copy, Clone)]
@@ -45,7 +45,7 @@ impl DelimSpan {
 
         DelimSpan {
             inner,
-            _marker: Marker,
+            _marker: MARKER,
         }
     }
 
diff --git a/src/lib.rs b/src/lib.rs
@@ -160,7 +160,7 @@ mod imp;
 mod location;
 
 use crate::extra::DelimSpan;
-use crate::marker::Marker;
+use crate::marker::{ProcMacroAutoTraits, MARKER};
 use core::cmp::Ordering;
 use core::fmt::{self, Debug, Display};
 use core::hash::{Hash, Hasher};
@@ -184,27 +184,27 @@ pub use crate::location::LineColumn;
 #[derive(Clone)]
 pub struct TokenStream {
     inner: imp::TokenStream,
-    _marker: Marker,
+    _marker: ProcMacroAutoTraits,
 }
 
 /// Error returned from `TokenStream::from_str`.
 pub struct LexError {
     inner: imp::LexError,
-    _marker: Marker,
+    _marker: ProcMacroAutoTraits,
 }
 
 impl TokenStream {
     fn _new(inner: imp::TokenStream) -> Self {
         TokenStream {
             inner,
-            _marker: Marker,
+            _marker: MARKER,
         }
     }
 
     fn _new_fallback(inner: fallback::TokenStream) -> Self {
         TokenStream {
             inner: inner.into(),
-            _marker: Marker,
+            _marker: MARKER,
         }
     }
 
@@ -241,7 +241,7 @@ impl FromStr for TokenStream {
     fn from_str(src: &str) -> Result<TokenStream, LexError> {
         let e = src.parse().map_err(|e| LexError {
             inner: e,
-            _marker: Marker,
+            _marker: MARKER,
         })?;
         Ok(TokenStream::_new(e))
     }
@@ -339,15 +339,15 @@ impl Error for LexError {}
 #[derive(Clone, PartialEq, Eq)]
 pub struct SourceFile {
     inner: imp::SourceFile,
-    _marker: Marker,
+    _marker: ProcMacroAutoTraits,
 }
 
 #[cfg(all(procmacro2_semver_exempt, any(not(wrap_proc_macro), super_unstable)))]
 impl SourceFile {
     fn _new(inner: imp::SourceFile) -> Self {
         SourceFile {
             inner,
-            _marker: Marker,
+            _marker: MARKER,
         }
     }
 
@@ -386,21 +386,21 @@ impl Debug for SourceFile {
 #[derive(Copy, Clone)]
 pub struct Span {
     inner: imp::Span,
-    _marker: Marker,
+    _marker: ProcMacroAutoTraits,
 }
 
 impl Span {
     fn _new(inner: imp::Span) -> Self {
         Span {
             inner,
-            _marker: Marker,
+            _marker: MARKER,
         }
     }
 
     fn _new_fallback(inner: fallback::Span) -> Self {
         Span {
             inner: inner.into(),
-            _marker: Marker,
+            _marker: MARKER,
         }
     }
 
@@ -919,14 +919,14 @@ impl Debug for Punct {
 #[derive(Clone)]
 pub struct Ident {
     inner: imp::Ident,
-    _marker: Marker,
+    _marker: ProcMacroAutoTraits,
 }
 
 impl Ident {
     fn _new(inner: imp::Ident) -> Self {
         Ident {
             inner,
-            _marker: Marker,
+            _marker: MARKER,
         }
     }
 
@@ -1046,7 +1046,7 @@ impl Debug for Ident {
 #[derive(Clone)]
 pub struct Literal {
     inner: imp::Literal,
-    _marker: Marker,
+    _marker: ProcMacroAutoTraits,
 }
 
 macro_rules! suffixed_int_literals {
@@ -1093,14 +1093,14 @@ impl Literal {
     fn _new(inner: imp::Literal) -> Self {
         Literal {
             inner,
-            _marker: Marker,
+            _marker: MARKER,
         }
     }
 
     fn _new_fallback(inner: fallback::Literal) -> Self {
         Literal {
             inner: inner.into(),
-            _marker: Marker,
+            _marker: MARKER,
         }
     }
 
@@ -1260,7 +1260,7 @@ impl FromStr for Literal {
     fn from_str(repr: &str) -> Result<Self, LexError> {
         repr.parse().map(Literal::_new).map_err(|inner| LexError {
             inner,
-            _marker: Marker,
+            _marker: MARKER,
         })
     }
 }
@@ -1279,7 +1279,7 @@ impl Display for Literal {
 
 /// Public implementation details for the `TokenStream` type, such as iterators.
 pub mod token_stream {
-    use crate::marker::Marker;
+    use crate::marker::{ProcMacroAutoTraits, MARKER};
     use crate::{imp, TokenTree};
     use core::fmt::{self, Debug};
 
@@ -1292,7 +1292,7 @@ pub mod token_stream {
     #[derive(Clone)]
     pub struct IntoIter {
         inner: imp::TokenTreeIter,
-        _marker: Marker,
+        _marker: ProcMacroAutoTraits,
     }
 
     impl Iterator for IntoIter {
@@ -1321,7 +1321,7 @@ pub mod token_stream {
         fn into_iter(self) -> IntoIter {
             IntoIter {
                 inner: self.inner.into_iter(),
-                _marker: Marker,
+                _marker: MARKER,
             }
         }
     }
diff --git a/src/marker.rs b/src/marker.rs
@@ -4,18 +4,14 @@ use core::panic::{RefUnwindSafe, UnwindSafe};
 
 // Zero sized marker with the correct set of autotrait impls we want all proc
 // macro types to have.
-pub(crate) type Marker = PhantomData<ProcMacroAutoTraits>;
+#[derive(Copy, Clone)]
+#[cfg_attr(
+    all(procmacro2_semver_exempt, any(not(wrap_proc_macro), super_unstable)),
+    derive(PartialEq, Eq)
+)]
+pub(crate) struct ProcMacroAutoTraits(PhantomData<Rc<()>>);
 
-pub(crate) use self::value::*;
-
-mod value {
-    pub(crate) use core::marker::PhantomData as Marker;
-}
-
-pub(crate) struct ProcMacroAutoTraits(
-    #[allow(dead_code)] // https://github.com/rust-lang/rust/issues/119645
-    Rc<()>,
-);
+pub(crate) const MARKER: ProcMacroAutoTraits = ProcMacroAutoTraits(PhantomData);
 
 impl UnwindSafe for ProcMacroAutoTraits {}
 impl RefUnwindSafe for ProcMacroAutoTraits {}
diff --git a/tests/ui/test-not-send.stderr b/tests/ui/test-not-send.stderr
@@ -28,16 +28,16 @@ error[E0277]: `Rc<()>` cannot be sent between threads safely
   |                     ^^^^ `Rc<()>` cannot be sent between threads safely
   |
   = help: within `Span`, the trait `Send` is not implemented for `Rc<()>`
-note: required because it appears within the type `proc_macro2::marker::ProcMacroAutoTraits`
- --> $WORKSPACE/src/marker.rs
-  |
-  | pub(crate) struct ProcMacroAutoTraits(
-  |                   ^^^^^^^^^^^^^^^^^^^
-note: required because it appears within the type `PhantomData<proc_macro2::marker::ProcMacroAutoTraits>`
+note: required because it appears within the type `PhantomData<Rc<()>>`
  --> $RUST/core/src/marker.rs
   |
   | pub struct PhantomData<T: ?Sized>;
   |            ^^^^^^^^^^^
+note: required because it appears within the type `proc_macro2::marker::ProcMacroAutoTraits`
+ --> $WORKSPACE/src/marker.rs
+  |
+  | pub(crate) struct ProcMacroAutoTraits(PhantomData<Rc<()>>);
+  |                   ^^^^^^^^^^^^^^^^^^^
 note: required because it appears within the type `Span`
  --> $WORKSPACE/src/lib.rs
   |

Original file line number	Diff line number	Diff line change
`@@ -160,7 +160,7 @@ mod imp;`
`160`	`160`	`mod location;`
`161`	`161`
`162`	`162`	`use crate::extra::DelimSpan;`
`163`		`-use crate::marker::Marker;`
	`163`	`+use crate::marker::{ProcMacroAutoTraits, MARKER};`
`164`	`164`	`use core::cmp::Ordering;`
`165`	`165`	`use core::fmt::{self, Debug, Display};`
`166`	`166`	`use core::hash::{Hash, Hasher};`
`@@ -184,27 +184,27 @@ pub use crate::location::LineColumn;`
`184`	`184`	`#[derive(Clone)]`
`185`	`185`	`pub struct TokenStream {`
`186`	`186`	`inner: imp::TokenStream,`
`187`		`- _marker: Marker,`
	`187`	`+ _marker: ProcMacroAutoTraits,`
`188`	`188`	`}`
`189`	`189`
`190`	`190`	/// Error returned from `TokenStream::from_str`.
`191`	`191`	`pub struct LexError {`
`192`	`192`	`inner: imp::LexError,`
`193`		`- _marker: Marker,`
	`193`	`+ _marker: ProcMacroAutoTraits,`
`194`	`194`	`}`
`195`	`195`
`196`	`196`	`impl TokenStream {`
`197`	`197`	`fn _new(inner: imp::TokenStream) -> Self {`
`198`	`198`	`TokenStream {`
`199`	`199`	`inner,`
`200`		`- _marker: Marker,`
	`200`	`+ _marker: MARKER,`
`201`	`201`	`}`
`202`	`202`	`}`
`203`	`203`
`204`	`204`	`fn _new_fallback(inner: fallback::TokenStream) -> Self {`
`205`	`205`	`TokenStream {`
`206`	`206`	`inner: inner.into(),`
`207`		`- _marker: Marker,`
	`207`	`+ _marker: MARKER,`
`208`	`208`	`}`
`209`	`209`	`}`
`210`	`210`
`@@ -241,7 +241,7 @@ impl FromStr for TokenStream {`
`241`	`241`	`fn from_str(src: &str) -> Result<TokenStream, LexError> {`
`242`	`242`	`let e = src.parse().map_err(\|e\| LexError {`
`243`	`243`	`inner: e,`
`244`		`- _marker: Marker,`
	`244`	`+ _marker: MARKER,`
`245`	`245`	`})?;`
`246`	`246`	`Ok(TokenStream::_new(e))`
`247`	`247`	`}`
`@@ -339,15 +339,15 @@ impl Error for LexError {}`
`339`	`339`	`#[derive(Clone, PartialEq, Eq)]`
`340`	`340`	`pub struct SourceFile {`
`341`	`341`	`inner: imp::SourceFile,`
`342`		`- _marker: Marker,`
	`342`	`+ _marker: ProcMacroAutoTraits,`
`343`	`343`	`}`
`344`	`344`
`345`	`345`	`#[cfg(all(procmacro2_semver_exempt, any(not(wrap_proc_macro), super_unstable)))]`
`346`	`346`	`impl SourceFile {`
`347`	`347`	`fn _new(inner: imp::SourceFile) -> Self {`
`348`	`348`	`SourceFile {`
`349`	`349`	`inner,`
`350`		`- _marker: Marker,`
	`350`	`+ _marker: MARKER,`
`351`	`351`	`}`
`352`	`352`	`}`
`353`	`353`
`@@ -386,21 +386,21 @@ impl Debug for SourceFile {`
`386`	`386`	`#[derive(Copy, Clone)]`
`387`	`387`	`pub struct Span {`
`388`	`388`	`inner: imp::Span,`
`389`		`- _marker: Marker,`
	`389`	`+ _marker: ProcMacroAutoTraits,`
`390`	`390`	`}`
`391`	`391`
`392`	`392`	`impl Span {`
`393`	`393`	`fn _new(inner: imp::Span) -> Self {`
`394`	`394`	`Span {`
`395`	`395`	`inner,`
`396`		`- _marker: Marker,`
	`396`	`+ _marker: MARKER,`
`397`	`397`	`}`
`398`	`398`	`}`
`399`	`399`
`400`	`400`	`fn _new_fallback(inner: fallback::Span) -> Self {`
`401`	`401`	`Span {`
`402`	`402`	`inner: inner.into(),`
`403`		`- _marker: Marker,`
	`403`	`+ _marker: MARKER,`
`404`	`404`	`}`
`405`	`405`	`}`
`406`	`406`
`@@ -919,14 +919,14 @@ impl Debug for Punct {`
`919`	`919`	`#[derive(Clone)]`
`920`	`920`	`pub struct Ident {`
`921`	`921`	`inner: imp::Ident,`
`922`		`- _marker: Marker,`
	`922`	`+ _marker: ProcMacroAutoTraits,`
`923`	`923`	`}`
`924`	`924`
`925`	`925`	`impl Ident {`
`926`	`926`	`fn _new(inner: imp::Ident) -> Self {`
`927`	`927`	`Ident {`
`928`	`928`	`inner,`
`929`		`- _marker: Marker,`
	`929`	`+ _marker: MARKER,`
`930`	`930`	`}`
`931`	`931`	`}`
`932`	`932`
`@@ -1046,7 +1046,7 @@ impl Debug for Ident {`
`1046`	`1046`	`#[derive(Clone)]`
`1047`	`1047`	`pub struct Literal {`
`1048`	`1048`	`inner: imp::Literal,`
`1049`		`- _marker: Marker,`
	`1049`	`+ _marker: ProcMacroAutoTraits,`
`1050`	`1050`	`}`
`1051`	`1051`
`1052`	`1052`	`macro_rules! suffixed_int_literals {`
`@@ -1093,14 +1093,14 @@ impl Literal {`
`1093`	`1093`	`fn _new(inner: imp::Literal) -> Self {`
`1094`	`1094`	`Literal {`
`1095`	`1095`	`inner,`
`1096`		`- _marker: Marker,`
	`1096`	`+ _marker: MARKER,`
`1097`	`1097`	`}`
`1098`	`1098`	`}`
`1099`	`1099`
`1100`	`1100`	`fn _new_fallback(inner: fallback::Literal) -> Self {`
`1101`	`1101`	`Literal {`
`1102`	`1102`	`inner: inner.into(),`
`1103`		`- _marker: Marker,`
	`1103`	`+ _marker: MARKER,`
`1104`	`1104`	`}`
`1105`	`1105`	`}`
`1106`	`1106`
`@@ -1260,7 +1260,7 @@ impl FromStr for Literal {`
`1260`	`1260`	`fn from_str(repr: &str) -> Result<Self, LexError> {`
`1261`	`1261`	`repr.parse().map(Literal::_new).map_err(\|inner\| LexError {`
`1262`	`1262`	`inner,`
`1263`		`- _marker: Marker,`
	`1263`	`+ _marker: MARKER,`
`1264`	`1264`	`})`
`1265`	`1265`	`}`
`1266`	`1266`	`}`
`@@ -1279,7 +1279,7 @@ impl Display for Literal {`
`1279`	`1279`
`1280`	`1280`	/// Public implementation details for the `TokenStream` type, such as iterators.
`1281`	`1281`	`pub mod token_stream {`
`1282`		`- use crate::marker::Marker;`
	`1282`	`+ use crate::marker::{ProcMacroAutoTraits, MARKER};`
`1283`	`1283`	`use crate::{imp, TokenTree};`
`1284`	`1284`	`use core::fmt::{self, Debug};`
`1285`	`1285`
`@@ -1292,7 +1292,7 @@ pub mod token_stream {`
`1292`	`1292`	`#[derive(Clone)]`
`1293`	`1293`	`pub struct IntoIter {`
`1294`	`1294`	`inner: imp::TokenTreeIter,`
`1295`		`- _marker: Marker,`
	`1295`	`+ _marker: ProcMacroAutoTraits,`
`1296`	`1296`	`}`
`1297`	`1297`
`1298`	`1298`	`impl Iterator for IntoIter {`
`@@ -1321,7 +1321,7 @@ pub mod token_stream {`
`1321`	`1321`	`fn into_iter(self) -> IntoIter {`
`1322`	`1322`	`IntoIter {`
`1323`	`1323`	`inner: self.inner.into_iter(),`
`1324`		`- _marker: Marker,`
	`1324`	`+ _marker: MARKER,`
`1325`	`1325`	`}`
`1326`	`1326`	`}`
`1327`	`1327`	`}`