Add deny(unreachable_pub) to rustc_builtin_macros.

nnethercote · nnethercote · commit 13d165e8fb59 · 2024-07-06T22:36:23.000+10:00
diff --git a/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs b/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
@@ -352,15 +352,15 @@ struct TypeParameter {
 pub(crate) struct BlockOrExpr(ThinVec<ast::Stmt>, Option<P<Expr>>);
 
 impl BlockOrExpr {
-    pub fn new_stmts(stmts: ThinVec<ast::Stmt>) -> BlockOrExpr {
+    pub(crate) fn new_stmts(stmts: ThinVec<ast::Stmt>) -> BlockOrExpr {
         BlockOrExpr(stmts, None)
     }
 
-    pub fn new_expr(expr: P<Expr>) -> BlockOrExpr {
+    pub(crate) fn new_expr(expr: P<Expr>) -> BlockOrExpr {
         BlockOrExpr(ThinVec::new(), Some(expr))
     }
 
-    pub fn new_mixed(stmts: ThinVec<ast::Stmt>, expr: Option<P<Expr>>) -> BlockOrExpr {
+    pub(crate) fn new_mixed(stmts: ThinVec<ast::Stmt>, expr: Option<P<Expr>>) -> BlockOrExpr {
         BlockOrExpr(stmts, expr)
     }
 
@@ -462,7 +462,7 @@ fn find_type_parameters(
 }
 
 impl<'a> TraitDef<'a> {
-    pub fn expand(
+    pub(crate) fn expand(
         self,
         cx: &ExtCtxt<'_>,
         mitem: &ast::MetaItem,
@@ -472,7 +472,7 @@ impl<'a> TraitDef<'a> {
         self.expand_ext(cx, mitem, item, push, false);
     }
 
-    pub fn expand_ext(
+    pub(crate) fn expand_ext(
         self,
         cx: &ExtCtxt<'_>,
         mitem: &ast::MetaItem,
diff --git a/compiler/rustc_builtin_macros/src/deriving/generic/ty.rs b/compiler/rustc_builtin_macros/src/deriving/generic/ty.rs
@@ -28,17 +28,17 @@ pub(crate) enum PathKind {
 }
 
 impl Path {
-    pub fn new(path: Vec<Symbol>) -> Path {
+    pub(crate) fn new(path: Vec<Symbol>) -> Path {
         Path::new_(path, Vec::new(), PathKind::Std)
     }
-    pub fn new_local(path: Symbol) -> Path {
+    pub(crate) fn new_local(path: Symbol) -> Path {
         Path::new_(vec![path], Vec::new(), PathKind::Local)
     }
-    pub fn new_(path: Vec<Symbol>, params: Vec<Box<Ty>>, kind: PathKind) -> Path {
+    pub(crate) fn new_(path: Vec<Symbol>, params: Vec<Box<Ty>>, kind: PathKind) -> Path {
         Path { path, params, kind }
     }
 
-    pub fn to_ty(
+    pub(crate) fn to_ty(
         &self,
         cx: &ExtCtxt<'_>,
         span: Span,
@@ -47,7 +47,7 @@ impl Path {
     ) -> P<ast::Ty> {
         cx.ty_path(self.to_path(cx, span, self_ty, self_generics))
     }
-    pub fn to_path(
+    pub(crate) fn to_path(
         &self,
         cx: &ExtCtxt<'_>,
         span: Span,
@@ -88,7 +88,7 @@ pub(crate) fn self_ref() -> Ty {
 }
 
 impl Ty {
-    pub fn to_ty(
+    pub(crate) fn to_ty(
         &self,
         cx: &ExtCtxt<'_>,
         span: Span,
@@ -109,7 +109,7 @@ impl Ty {
         }
     }
 
-    pub fn to_path(
+    pub(crate) fn to_path(
         &self,
         cx: &ExtCtxt<'_>,
         span: Span,
@@ -168,10 +168,10 @@ pub(crate) struct Bounds {
 }
 
 impl Bounds {
-    pub fn empty() -> Bounds {
+    pub(crate) fn empty() -> Bounds {
         Bounds { bounds: Vec::new() }
     }
-    pub fn to_generics(
+    pub(crate) fn to_generics(
         &self,
         cx: &ExtCtxt<'_>,
         span: Span,
diff --git a/compiler/rustc_builtin_macros/src/deriving/smart_ptr.rs b/compiler/rustc_builtin_macros/src/deriving/smart_ptr.rs
@@ -16,7 +16,7 @@ macro_rules! path {
     ($span:expr, $($part:ident)::*) => { vec![$(Ident::new(sym::$part, $span),)*] }
 }
 
-pub fn expand_deriving_smart_ptr(
+pub(crate) fn expand_deriving_smart_ptr(
     cx: &ExtCtxt<'_>,
     span: Span,
     _mitem: &MetaItem,
diff --git a/compiler/rustc_builtin_macros/src/format_foreign.rs b/compiler/rustc_builtin_macros/src/format_foreign.rs
@@ -4,29 +4,29 @@ pub(crate) mod printf {
 
     /// Represents a single `printf`-style substitution.
     #[derive(Clone, PartialEq, Debug)]
-    pub enum Substitution<'a> {
+    pub(crate) enum Substitution<'a> {
         /// A formatted output substitution with its internal byte offset.
         Format(Format<'a>),
         /// A literal `%%` escape, with its start and end indices.
         Escape((usize, usize)),
     }
 
     impl<'a> Substitution<'a> {
-        pub fn as_str(&self) -> &str {
+        pub(crate) fn as_str(&self) -> &str {
             match self {
                 Substitution::Format(fmt) => fmt.span,
                 Substitution::Escape(_) => "%%",
             }
         }
 
-        pub fn position(&self) -> InnerSpan {
+        pub(crate) fn position(&self) -> InnerSpan {
             match self {
                 Substitution::Format(fmt) => fmt.position,
                 &Substitution::Escape((start, end)) => InnerSpan::new(start, end),
             }
         }
 
-        pub fn set_position(&mut self, start: usize, end: usize) {
+        pub(crate) fn set_position(&mut self, start: usize, end: usize) {
             match self {
                 Substitution::Format(fmt) => fmt.position = InnerSpan::new(start, end),
                 Substitution::Escape(pos) => *pos = (start, end),
@@ -37,7 +37,7 @@ pub(crate) mod printf {
         ///
         /// This ignores cases where the substitution does not have an exact equivalent, or where
         /// the substitution would be unnecessary.
-        pub fn translate(&self) -> Result<String, Option<String>> {
+        pub(crate) fn translate(&self) -> Result<String, Option<String>> {
             match self {
                 Substitution::Format(fmt) => fmt.translate(),
                 Substitution::Escape(_) => Err(None),
@@ -47,31 +47,31 @@ pub(crate) mod printf {
 
     #[derive(Clone, PartialEq, Debug)]
     /// A single `printf`-style formatting directive.
-    pub struct Format<'a> {
+    pub(crate) struct Format<'a> {
         /// The entire original formatting directive.
-        pub span: &'a str,
+        span: &'a str,
         /// The (1-based) parameter to be converted.
-        pub parameter: Option<u16>,
+        parameter: Option<u16>,
         /// Formatting flags.
-        pub flags: &'a str,
+        flags: &'a str,
         /// Minimum width of the output.
-        pub width: Option<Num>,
+        width: Option<Num>,
         /// Precision of the conversion.
-        pub precision: Option<Num>,
+        precision: Option<Num>,
         /// Length modifier for the conversion.
-        pub length: Option<&'a str>,
+        length: Option<&'a str>,
         /// Type of parameter being converted.
-        pub type_: &'a str,
+        type_: &'a str,
         /// Byte offset for the start and end of this formatting directive.
-        pub position: InnerSpan,
+        position: InnerSpan,
     }
 
     impl Format<'_> {
         /// Translate this directive into an equivalent Rust formatting directive.
         ///
         /// Returns `Err` in cases where the `printf` directive does not have an exact Rust
         /// equivalent, rather than guessing.
-        pub fn translate(&self) -> Result<String, Option<String>> {
+        pub(crate) fn translate(&self) -> Result<String, Option<String>> {
             use std::fmt::Write;
 
             let (c_alt, c_zero, c_left, c_plus) = {
@@ -248,7 +248,7 @@ pub(crate) mod printf {
 
     /// A general number used in a `printf` formatting directive.
     #[derive(Copy, Clone, PartialEq, Debug)]
-    pub enum Num {
+    enum Num {
         // The range of these values is technically bounded by `NL_ARGMAX`... but, at least for GNU
         // libc, it apparently has no real fixed limit. A `u16` is used here on the basis that it
         // is *vanishingly* unlikely that *anyone* is going to try formatting something wider, or
@@ -287,12 +287,12 @@ pub(crate) mod printf {
     }
 
     /// Returns an iterator over all substitutions in a given string.
-    pub fn iter_subs(s: &str, start_pos: usize) -> Substitutions<'_> {
+    pub(crate) fn iter_subs(s: &str, start_pos: usize) -> Substitutions<'_> {
         Substitutions { s, pos: start_pos }
     }
 
     /// Iterator over substitutions in a string.
-    pub struct Substitutions<'a> {
+    pub(crate) struct Substitutions<'a> {
         s: &'a str,
         pos: usize,
     }
@@ -326,7 +326,7 @@ pub(crate) mod printf {
     }
 
     /// Parse the next substitution from the input string.
-    pub fn parse_next_substitution(s: &str) -> Option<(Substitution<'_>, &str)> {
+    fn parse_next_substitution(s: &str) -> Option<(Substitution<'_>, &str)> {
         use self::State::*;
 
         let at = {
@@ -614,37 +614,37 @@ pub(crate) mod printf {
     mod tests;
 }
 
-pub mod shell {
+pub(crate) mod shell {
     use super::strcursor::StrCursor as Cur;
     use rustc_span::InnerSpan;
 
     #[derive(Clone, PartialEq, Debug)]
-    pub enum Substitution<'a> {
+    pub(crate) enum Substitution<'a> {
         Ordinal(u8, (usize, usize)),
         Name(&'a str, (usize, usize)),
         Escape((usize, usize)),
     }
 
     impl Substitution<'_> {
-        pub fn as_str(&self) -> String {
+        pub(crate) fn as_str(&self) -> String {
             match self {
                 Substitution::Ordinal(n, _) => format!("${n}"),
                 Substitution::Name(n, _) => format!("${n}"),
                 Substitution::Escape(_) => "$$".into(),
             }
         }
 
-        pub fn position(&self) -> InnerSpan {
+        pub(crate) fn position(&self) -> InnerSpan {
             let (Self::Ordinal(_, pos) | Self::Name(_, pos) | Self::Escape(pos)) = self;
             InnerSpan::new(pos.0, pos.1)
         }
 
-        pub fn set_position(&mut self, start: usize, end: usize) {
+        fn set_position(&mut self, start: usize, end: usize) {
             let (Self::Ordinal(_, pos) | Self::Name(_, pos) | Self::Escape(pos)) = self;
             *pos = (start, end);
         }
 
-        pub fn translate(&self) -> Result<String, Option<String>> {
+        pub(crate) fn translate(&self) -> Result<String, Option<String>> {
             match self {
                 Substitution::Ordinal(n, _) => Ok(format!("{{{}}}", n)),
                 Substitution::Name(n, _) => Ok(format!("{{{}}}", n)),
@@ -654,12 +654,12 @@ pub mod shell {
     }
 
     /// Returns an iterator over all substitutions in a given string.
-    pub fn iter_subs(s: &str, start_pos: usize) -> Substitutions<'_> {
+    pub(crate) fn iter_subs(s: &str, start_pos: usize) -> Substitutions<'_> {
         Substitutions { s, pos: start_pos }
     }
 
     /// Iterator over substitutions in a string.
-    pub struct Substitutions<'a> {
+    pub(crate) struct Substitutions<'a> {
         s: &'a str,
         pos: usize,
     }
@@ -681,7 +681,7 @@ pub mod shell {
     }
 
     /// Parse the next substitution from the input string.
-    pub fn parse_next_substitution(s: &str) -> Option<(Substitution<'_>, &str)> {
+    fn parse_next_substitution(s: &str) -> Option<(Substitution<'_>, &str)> {
         let at = {
             let start = s.find('$')?;
             match s[start + 1..].chars().next()? {
@@ -741,24 +741,24 @@ pub mod shell {
 }
 
 mod strcursor {
-    pub struct StrCursor<'a> {
+    pub(crate) struct StrCursor<'a> {
         s: &'a str,
         pub at: usize,
     }
 
     impl<'a> StrCursor<'a> {
-        pub fn new_at(s: &'a str, at: usize) -> StrCursor<'a> {
+        pub(crate) fn new_at(s: &'a str, at: usize) -> StrCursor<'a> {
             StrCursor { s, at }
         }
 
-        pub fn at_next_cp(mut self) -> Option<StrCursor<'a>> {
+        pub(crate) fn at_next_cp(mut self) -> Option<StrCursor<'a>> {
             match self.try_seek_right_cp() {
                 true => Some(self),
                 false => None,
             }
         }
 
-        pub fn next_cp(mut self) -> Option<(char, StrCursor<'a>)> {
+        pub(crate) fn next_cp(mut self) -> Option<(char, StrCursor<'a>)> {
             let cp = self.cp_after()?;
             self.seek_right(cp.len_utf8());
             Some((cp, self))
@@ -768,11 +768,11 @@ mod strcursor {
             &self.s[0..self.at]
         }
 
-        pub fn slice_after(&self) -> &'a str {
+        pub(crate) fn slice_after(&self) -> &'a str {
             &self.s[self.at..]
         }
 
-        pub fn slice_between(&self, until: StrCursor<'a>) -> Option<&'a str> {
+        pub(crate) fn slice_between(&self, until: StrCursor<'a>) -> Option<&'a str> {
             if !str_eq_literal(self.s, until.s) {
                 None
             } else {
diff --git a/compiler/rustc_builtin_macros/src/lib.rs b/compiler/rustc_builtin_macros/src/lib.rs
@@ -6,6 +6,7 @@
 #![allow(rustc::diagnostic_outside_of_impl)]
 #![allow(rustc::untranslatable_diagnostic)]
 #![cfg_attr(bootstrap, feature(lint_reasons))]
+#![deny(unreachable_pub)]
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
 #![doc(rust_logo)]
 #![feature(assert_matches)]

Original file line number	Diff line number	Diff line change
`@@ -352,15 +352,15 @@ struct TypeParameter {`
`352`	`352`	`pub(crate) struct BlockOrExpr(ThinVec<ast::Stmt>, Option<P<Expr>>);`
`353`	`353`
`354`	`354`	`impl BlockOrExpr {`
`355`		`- pub fn new_stmts(stmts: ThinVec<ast::Stmt>) -> BlockOrExpr {`
	`355`	`+ pub(crate) fn new_stmts(stmts: ThinVec<ast::Stmt>) -> BlockOrExpr {`
`356`	`356`	`BlockOrExpr(stmts, None)`
`357`	`357`	`}`
`358`	`358`
`359`		`- pub fn new_expr(expr: P<Expr>) -> BlockOrExpr {`
	`359`	`+ pub(crate) fn new_expr(expr: P<Expr>) -> BlockOrExpr {`
`360`	`360`	`BlockOrExpr(ThinVec::new(), Some(expr))`
`361`	`361`	`}`
`362`	`362`
`363`		`- pub fn new_mixed(stmts: ThinVec<ast::Stmt>, expr: Option<P<Expr>>) -> BlockOrExpr {`
	`363`	`+ pub(crate) fn new_mixed(stmts: ThinVec<ast::Stmt>, expr: Option<P<Expr>>) -> BlockOrExpr {`
`364`	`364`	`BlockOrExpr(stmts, expr)`
`365`	`365`	`}`
`366`	`366`
`@@ -462,7 +462,7 @@ fn find_type_parameters(`
`462`	`462`	`}`
`463`	`463`
`464`	`464`	`impl<'a> TraitDef<'a> {`
`465`		`- pub fn expand(`
	`465`	`+ pub(crate) fn expand(`
`466`	`466`	`self,`
`467`	`467`	`cx: &ExtCtxt<'_>,`
`468`	`468`	`mitem: &ast::MetaItem,`
`@@ -472,7 +472,7 @@ impl<'a> TraitDef<'a> {`
`472`	`472`	`self.expand_ext(cx, mitem, item, push, false);`
`473`	`473`	`}`
`474`	`474`
`475`		`- pub fn expand_ext(`
	`475`	`+ pub(crate) fn expand_ext(`
`476`	`476`	`self,`
`477`	`477`	`cx: &ExtCtxt<'_>,`
`478`	`478`	`mitem: &ast::MetaItem,`
Original file line number	Diff line number	Diff line change
`@@ -28,17 +28,17 @@ pub(crate) enum PathKind {`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`impl Path {`
`31`		`- pub fn new(path: Vec<Symbol>) -> Path {`
	`31`	`+ pub(crate) fn new(path: Vec<Symbol>) -> Path {`
`32`	`32`	`Path::new_(path, Vec::new(), PathKind::Std)`
`33`	`33`	`}`
`34`		`- pub fn new_local(path: Symbol) -> Path {`
	`34`	`+ pub(crate) fn new_local(path: Symbol) -> Path {`
`35`	`35`	`Path::new_(vec![path], Vec::new(), PathKind::Local)`
`36`	`36`	`}`
`37`		`- pub fn new_(path: Vec<Symbol>, params: Vec<Box<Ty>>, kind: PathKind) -> Path {`
	`37`	`+ pub(crate) fn new_(path: Vec<Symbol>, params: Vec<Box<Ty>>, kind: PathKind) -> Path {`
`38`	`38`	`Path { path, params, kind }`
`39`	`39`	`}`
`40`	`40`
`41`		`- pub fn to_ty(`
	`41`	`+ pub(crate) fn to_ty(`
`42`	`42`	`&self,`
`43`	`43`	`cx: &ExtCtxt<'_>,`
`44`	`44`	`span: Span,`
`@@ -47,7 +47,7 @@ impl Path {`
`47`	`47`	`) -> P<ast::Ty> {`
`48`	`48`	`cx.ty_path(self.to_path(cx, span, self_ty, self_generics))`
`49`	`49`	`}`
`50`		`- pub fn to_path(`
	`50`	`+ pub(crate) fn to_path(`
`51`	`51`	`&self,`
`52`	`52`	`cx: &ExtCtxt<'_>,`
`53`	`53`	`span: Span,`
`@@ -88,7 +88,7 @@ pub(crate) fn self_ref() -> Ty {`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`impl Ty {`
`91`		`- pub fn to_ty(`
	`91`	`+ pub(crate) fn to_ty(`
`92`	`92`	`&self,`
`93`	`93`	`cx: &ExtCtxt<'_>,`
`94`	`94`	`span: Span,`
`@@ -109,7 +109,7 @@ impl Ty {`
`109`	`109`	`}`
`110`	`110`	`}`
`111`	`111`
`112`		`- pub fn to_path(`
	`112`	`+ pub(crate) fn to_path(`
`113`	`113`	`&self,`
`114`	`114`	`cx: &ExtCtxt<'_>,`
`115`	`115`	`span: Span,`
`@@ -168,10 +168,10 @@ pub(crate) struct Bounds {`
`168`	`168`	`}`
`169`	`169`
`170`	`170`	`impl Bounds {`
`171`		`- pub fn empty() -> Bounds {`
	`171`	`+ pub(crate) fn empty() -> Bounds {`
`172`	`172`	`Bounds { bounds: Vec::new() }`
`173`	`173`	`}`
`174`		`- pub fn to_generics(`
	`174`	`+ pub(crate) fn to_generics(`
`175`	`175`	`&self,`
`176`	`176`	`cx: &ExtCtxt<'_>,`
`177`	`177`	`span: Span,`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ macro_rules! path {`
`16`	`16`	`($span:expr, $($part:ident)::) => { vec![$(Ident::new(sym::$part, $span),)] }`
`17`	`17`	`}`
`18`	`18`
`19`		`-pub fn expand_deriving_smart_ptr(`
	`19`	`+pub(crate) fn expand_deriving_smart_ptr(`
`20`	`20`	`cx: &ExtCtxt<'_>,`
`21`	`21`	`span: Span,`
`22`	`22`	`_mitem: &MetaItem,`