Prevent external instantiation of the nonexhaustive variants

dtolnay · Jan 24, 2021 · 269b422 · 269b422
1 parent 1368867
commit 269b422
Show file tree

Hide file tree

Showing 9 changed files with 41 additions and 29 deletions.
diff --git a/src/attr.rs b/src/attr.rs
@@ -530,7 +530,7 @@ pub mod parsing {
 
     #[cfg(feature = "full")]
     impl private {
-        pub fn attrs(outer: Vec<Attribute>, inner: Vec<Attribute>) -> Vec<Attribute> {
+        pub(crate) fn attrs(outer: Vec<Attribute>, inner: Vec<Attribute>) -> Vec<Attribute> {
             let mut attrs = outer;
             attrs.extend(inner);
             attrs

diff --git a/src/export.rs b/src/export.rs
@@ -33,3 +33,5 @@ mod help {
     pub type Bool = bool;
     pub type Str = str;
 }
+
+pub struct private(pub(crate) ());
diff --git a/src/expr.rs b/src/expr.rs
@@ -234,7 +234,7 @@ ast_enum_of_structs! {
         //         Expr::Yield(e) => {...}
         //
         //         #[cfg(test)]
-        //         Expr::__TestExhaustive => unimplemented!(),
+        //         Expr::__TestExhaustive(_) => unimplemented!(),
         //         #[cfg(not(test))]
         //         _ => { /* some sane fallback */ }
         //     }
@@ -244,7 +244,7 @@ ast_enum_of_structs! {
         // added, so that you can add code to handle it, but your library will
         // continue to compile and work for downstream users in the interim.
         #[doc(hidden)]
-        __TestExhaustive,
+        __TestExhaustive(crate::private),
     }
 }
 
@@ -823,7 +823,7 @@ impl Expr {
             | Expr::TryBlock(ExprTryBlock { attrs, .. })
             | Expr::Yield(ExprYield { attrs, .. }) => mem::replace(attrs, new),
             Expr::Verbatim(_) => Vec::new(),
-            Expr::__TestExhaustive => unreachable!(),
+            Expr::__TestExhaustive(_) => unreachable!(),
         }
     }
 }
@@ -2322,7 +2322,7 @@ pub(crate) mod parsing {
                 Pat::Type(_) => unreachable!(),
                 Pat::Verbatim(_) => {}
                 Pat::Wild(pat) => pat.attrs = attrs,
-                Pat::__TestExhaustive => unreachable!(),
+                Pat::__TestExhaustive(_) => unreachable!(),
             }
             Ok(pat)
         }
@@ -2673,7 +2673,7 @@ pub(crate) mod parsing {
         }
         for part in float_repr.split('.') {
             let index = crate::parse_str(part).map_err(|err| Error::new(float.span(), err))?;
-            let base = mem::replace(e, Expr::__TestExhaustive);
+            let base = mem::replace(e, Expr::__TestExhaustive(crate::private(())));
             *e = Expr::Field(ExprField {
                 attrs: Vec::new(),
                 base: Box::new(base),

diff --git a/src/item.rs b/src/item.rs
@@ -81,7 +81,7 @@ ast_enum_of_structs! {
         //         Item::Verbatim(e) => {...}
         //
         //         #[cfg(test)]
-        //         Item::__TestExhaustive => unimplemented!(),
+        //         Item::__TestExhaustive(_) => unimplemented!(),
         //         #[cfg(not(test))]
         //         _ => { /* some sane fallback */ }
         //     }
@@ -91,7 +91,7 @@ ast_enum_of_structs! {
         // added, so that you can add code to handle it, but your library will
         // continue to compile and work for downstream users in the interim.
         #[doc(hidden)]
-        __TestExhaustive,
+        __TestExhaustive(crate::private),
     }
 }
 
@@ -376,7 +376,7 @@ impl Item {
             | Item::Macro(ItemMacro { attrs, .. })
             | Item::Macro2(ItemMacro2 { attrs, .. }) => mem::replace(attrs, new),
             Item::Verbatim(_) => Vec::new(),
-            Item::__TestExhaustive => unreachable!(),
+            Item::__TestExhaustive(_) => unreachable!(),
         }
     }
 }
@@ -582,7 +582,7 @@ ast_enum_of_structs! {
         //         ForeignItem::Verbatim(e) => {...}
         //
         //         #[cfg(test)]
-        //         ForeignItem::__TestExhaustive => unimplemented!(),
+        //         ForeignItem::__TestExhaustive(_) => unimplemented!(),
         //         #[cfg(not(test))]
         //         _ => { /* some sane fallback */ }
         //     }
@@ -592,7 +592,7 @@ ast_enum_of_structs! {
         // added, so that you can add code to handle it, but your library will
         // continue to compile and work for downstream users in the interim.
         #[doc(hidden)]
-        __TestExhaustive,
+        __TestExhaustive(crate::private),
     }
 }
 
@@ -689,7 +689,7 @@ ast_enum_of_structs! {
         //         TraitItem::Verbatim(e) => {...}
         //
         //         #[cfg(test)]
-        //         TraitItem::__TestExhaustive => unimplemented!(),
+        //         TraitItem::__TestExhaustive(_) => unimplemented!(),
         //         #[cfg(not(test))]
         //         _ => { /* some sane fallback */ }
         //     }
@@ -699,7 +699,7 @@ ast_enum_of_structs! {
         // added, so that you can add code to handle it, but your library will
         // continue to compile and work for downstream users in the interim.
         #[doc(hidden)]
-        __TestExhaustive,
+        __TestExhaustive(crate::private),
     }
 }
 
@@ -798,7 +798,7 @@ ast_enum_of_structs! {
         //         ImplItem::Verbatim(e) => {...}
         //
         //         #[cfg(test)]
-        //         ImplItem::__TestExhaustive => unimplemented!(),
+        //         ImplItem::__TestExhaustive(_) => unimplemented!(),
         //         #[cfg(not(test))]
         //         _ => { /* some sane fallback */ }
         //     }
@@ -808,7 +808,7 @@ ast_enum_of_structs! {
         // added, so that you can add code to handle it, but your library will
         // continue to compile and work for downstream users in the interim.
         #[doc(hidden)]
-        __TestExhaustive,
+        __TestExhaustive(crate::private),
     }
 }
 
@@ -1771,7 +1771,7 @@ pub mod parsing {
                 ForeignItem::Type(item) => &mut item.attrs,
                 ForeignItem::Macro(item) => &mut item.attrs,
                 ForeignItem::Verbatim(_) => return Ok(item),
-                ForeignItem::__TestExhaustive => unreachable!(),
+                ForeignItem::__TestExhaustive(_) => unreachable!(),
             };
             attrs.extend(item_attrs.drain(..));
             *item_attrs = attrs;
@@ -2249,7 +2249,7 @@ pub mod parsing {
                 TraitItem::Method(item) => &mut item.attrs,
                 TraitItem::Type(item) => &mut item.attrs,
                 TraitItem::Macro(item) => &mut item.attrs,
-                TraitItem::Verbatim(_) | TraitItem::__TestExhaustive => unreachable!(),
+                TraitItem::Verbatim(_) | TraitItem::__TestExhaustive(_) => unreachable!(),
             };
             attrs.extend(item_attrs.drain(..));
             *item_attrs = attrs;
@@ -2580,7 +2580,7 @@ pub mod parsing {
                     ImplItem::Type(item) => &mut item.attrs,
                     ImplItem::Macro(item) => &mut item.attrs,
                     ImplItem::Verbatim(_) => return Ok(item),
-                    ImplItem::__TestExhaustive => unreachable!(),
+                    ImplItem::__TestExhaustive(_) => unreachable!(),
                 };
                 attrs.extend(item_attrs.drain(..));
                 *item_attrs = attrs;

diff --git a/src/lib.rs b/src/lib.rs
@@ -252,6 +252,7 @@
 // Syn types in rustdoc of other crates get linked to here.
 #![doc(html_root_url = "https://docs.rs/syn/1.0.59")]
 #![cfg_attr(doc_cfg, feature(doc_cfg))]
+#![allow(non_camel_case_types)]
 // Ignored clippy lints.
 #![allow(
     clippy::doc_markdown,
@@ -813,10 +814,9 @@ mod verbatim;
 #[cfg(all(any(feature = "full", feature = "derive"), feature = "printing"))]
 mod print;
 
-////////////////////////////////////////////////////////////////////////////////
+use crate::__private::private;
 
-#[allow(dead_code, non_camel_case_types)]
-struct private;
+////////////////////////////////////////////////////////////////////////////////
 
 // https://github.com/rust-lang/rust/issues/62830
 #[cfg(feature = "parsing")]

diff --git a/src/macros.rs b/src/macros.rs
@@ -77,7 +77,7 @@ macro_rules! ast_enum_of_structs_impl {
         $pub:ident $enum:ident $name:ident {
             $(
                 $(#[$variant_attr:meta])*
-                $variant:ident $( ($member:ident) )*,
+                $variant:ident $( ($($member:ident)::+) )*,
             )*
         }
 
@@ -87,15 +87,15 @@ macro_rules! ast_enum_of_structs_impl {
         check_keyword_matches!(enum $enum);
 
         $($(
-            ast_enum_from_struct!($name::$variant, $member);
+            ast_enum_from_struct!($name::$variant, $($member)::+);
         )*)*
 
         #[cfg(feature = "printing")]
         generate_to_tokens! {
             $($remaining)*
             ()
             tokens
-            $name { $($variant $($member)*,)* }
+            $name { $($variant $($($member)::+)*,)* }
         }
     };
 }
@@ -104,6 +104,9 @@ macro_rules! ast_enum_from_struct {
     // No From<TokenStream> for verbatim variants.
     ($name:ident::Verbatim, $member:ident) => {};
 
+    // No From<TokenStream> for private variants.
+    ($name:ident::$variant:ident, crate::private) => {};
+
     ($name:ident::$variant:ident, $member:ident) => {
         impl From<$member> for $name {
             fn from(e: $member) -> $name {
@@ -131,6 +134,13 @@ macro_rules! generate_to_tokens {
         );
     };
 
+    (($($arms:tt)*) $tokens:ident $name:ident { $variant:ident crate::private, $($next:tt)*}) => {
+        generate_to_tokens!(
+            ($($arms)* $name::$variant(_) => unreachable!(),)
+            $tokens $name { $($next)* }
+        );
+    };
+
     (($($arms:tt)*) $tokens:ident $name:ident {}) => {
         #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
         impl ::quote::ToTokens for $name {

diff --git a/src/pat.rs b/src/pat.rs
@@ -82,7 +82,7 @@ ast_enum_of_structs! {
         //         Pat::Wild(e) => {...}
         //
         //         #[cfg(test)]
-        //         Pat::__TestExhaustive => unimplemented!(),
+        //         Pat::__TestExhaustive(_) => unimplemented!(),
         //         #[cfg(not(test))]
         //         _ => { /* some sane fallback */ }
         //     }
@@ -92,7 +92,7 @@ ast_enum_of_structs! {
         // added, so that you can add code to handle it, but your library will
         // continue to compile and work for downstream users in the interim.
         #[doc(hidden)]
-        __TestExhaustive,
+        __TestExhaustive(crate::private),
     }
 }
 

diff --git a/src/path.rs b/src/path.rs
@@ -747,7 +747,7 @@ mod printing {
     }
 
     impl private {
-        pub fn print_path(tokens: &mut TokenStream, qself: &Option<QSelf>, path: &Path) {
+        pub(crate) fn print_path(tokens: &mut TokenStream, qself: &Option<QSelf>, path: &Path) {
             let qself = match qself {
                 Some(qself) => qself,
                 None => {

diff --git a/src/ty.rs b/src/ty.rs
@@ -73,7 +73,7 @@ ast_enum_of_structs! {
         //         Type::Verbatim(e) => {...}
         //
         //         #[cfg(test)]
-        //         Type::__TestExhaustive => unimplemented!(),
+        //         Type::__TestExhaustive(_) => unimplemented!(),
         //         #[cfg(not(test))]
         //         _ => { /* some sane fallback */ }
         //     }
@@ -83,7 +83,7 @@ ast_enum_of_structs! {
         // added, so that you can add code to handle it, but your library will
         // continue to compile and work for downstream users in the interim.
         #[doc(hidden)]
-        __TestExhaustive,
+        __TestExhaustive(crate::private),
     }
 }