Add deny(unreachable_pub) to rustc_attr.

Author: nnethercote

compiler/rustc_attr/src/lib.rs

@@ -5,6 +5,7 @@
 //! to this crate.
 
 #![allow(internal_features)]
+#![deny(unreachable_pub)]
 #![feature(rustdoc_internals)]
 #![doc(rust_logo)]
 #![feature(let_chains)]

compiler/rustc_attr/src/session_diagnostics.rs

@@ -12,39 +12,39 @@ use crate::UnsupportedLiteralReason;
 #[diag(attr_expected_one_cfg_pattern, code = E0536)]
 pub(crate) struct ExpectedOneCfgPattern {
     #[primary_span]
-    pub span: Span,
+    pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(attr_invalid_predicate, code = E0537)]
 pub(crate) struct InvalidPredicate {
     #[primary_span]
-    pub span: Span,
+    pub(crate) span: Span,
 
-    pub predicate: String,
+    pub(crate) predicate: String,
 }
 
 #[derive(Diagnostic)]
 #[diag(attr_multiple_item, code = E0538)]
 pub(crate) struct MultipleItem {
     #[primary_span]
-    pub span: Span,
+    pub(crate) span: Span,
 
-    pub item: String,
+    pub(crate) item: String,
 }
 
 #[derive(Diagnostic)]
 #[diag(attr_incorrect_meta_item, code = E0539)]
 pub(crate) struct IncorrectMetaItem {
     #[primary_span]
-    pub span: Span,
+    pub(crate) span: Span,
 }
 
 /// Error code: E0541
 pub(crate) struct UnknownMetaItem<'a> {
-    pub span: Span,
-    pub item: String,
-    pub expected: &'a [&'a str],
+    pub(crate) span: Span,
+    pub(crate) item: String,
+    pub(crate) expected: &'a [&'a str],
 }
 
 // Manual implementation to be able to format `expected` items correctly.
@@ -64,31 +64,31 @@ impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for UnknownMetaItem<'_> {
 #[diag(attr_missing_since, code = E0542)]
 pub(crate) struct MissingSince {
     #[primary_span]
-    pub span: Span,
+    pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(attr_missing_note, code = E0543)]
 pub(crate) struct MissingNote {
     #[primary_span]
-    pub span: Span,
+    pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(attr_multiple_stability_levels, code = E0544)]
 pub(crate) struct MultipleStabilityLevels {
     #[primary_span]
-    pub span: Span,
+    pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(attr_invalid_issue_string, code = E0545)]
 pub(crate) struct InvalidIssueString {
     #[primary_span]
-    pub span: Span,
+    pub(crate) span: Span,
 
     #[subdiagnostic]
-    pub cause: Option<InvalidIssueStringCause>,
+    pub(crate) cause: Option<InvalidIssueStringCause>,
 }
 
 // The error kinds of `IntErrorKind` are duplicated here in order to allow the messages to be
@@ -127,7 +127,7 @@ pub(crate) enum InvalidIssueStringCause {
 }
 
 impl InvalidIssueStringCause {
-    pub fn from_int_error_kind(span: Span, kind: &IntErrorKind) -> Option<Self> {
+    pub(crate) fn from_int_error_kind(span: Span, kind: &IntErrorKind) -> Option<Self> {
         match kind {
             IntErrorKind::Empty => Some(Self::Empty { span }),
             IntErrorKind::InvalidDigit => Some(Self::InvalidDigit { span }),
@@ -143,21 +143,21 @@ impl InvalidIssueStringCause {
 #[diag(attr_missing_feature, code = E0546)]
 pub(crate) struct MissingFeature {
     #[primary_span]
-    pub span: Span,
+    pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(attr_non_ident_feature, code = E0546)]
 pub(crate) struct NonIdentFeature {
     #[primary_span]
-    pub span: Span,
+    pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(attr_missing_issue, code = E0547)]
 pub(crate) struct MissingIssue {
     #[primary_span]
-    pub span: Span,
+    pub(crate) span: Span,
 }
 
 // FIXME: Why is this the same error code as `InvalidReprHintNoParen` and `InvalidReprHintNoValue`?
@@ -166,39 +166,39 @@ pub(crate) struct MissingIssue {
 #[diag(attr_incorrect_repr_format_packed_one_or_zero_arg, code = E0552)]
 pub(crate) struct IncorrectReprFormatPackedOneOrZeroArg {
     #[primary_span]
-    pub span: Span,
+    pub(crate) span: Span,
 }
 #[derive(Diagnostic)]
 #[diag(attr_incorrect_repr_format_packed_expect_integer, code = E0552)]
 pub(crate) struct IncorrectReprFormatPackedExpectInteger {
     #[primary_span]
-    pub span: Span,
+    pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(attr_invalid_repr_hint_no_paren, code = E0552)]
 pub(crate) struct InvalidReprHintNoParen {
     #[primary_span]
-    pub span: Span,
+    pub(crate) span: Span,
 
-    pub name: String,
+    pub(crate) name: String,
 }
 
 #[derive(Diagnostic)]
 #[diag(attr_invalid_repr_hint_no_value, code = E0552)]
 pub(crate) struct InvalidReprHintNoValue {
     #[primary_span]
-    pub span: Span,
+    pub(crate) span: Span,
 
-    pub name: String,
+    pub(crate) name: String,
 }
 
 /// Error code: E0565
 pub(crate) struct UnsupportedLiteral {
-    pub span: Span,
-    pub reason: UnsupportedLiteralReason,
-    pub is_bytestr: bool,
-    pub start_point_span: Span,
+    pub(crate) span: Span,
+    pub(crate) reason: UnsupportedLiteralReason,
+    pub(crate) is_bytestr: bool,
+    pub(crate) start_point_span: Span,
 }
 
 impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for UnsupportedLiteral {
@@ -236,43 +236,43 @@ impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for UnsupportedLiteral {
 pub(crate) struct InvalidReprAlignNeedArg {
     #[primary_span]
     #[suggestion(code = "align(...)", applicability = "has-placeholders")]
-    pub span: Span,
+    pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(attr_invalid_repr_generic, code = E0589)]
 pub(crate) struct InvalidReprGeneric<'a> {
     #[primary_span]
-    pub span: Span,
+    pub(crate) span: Span,
 
-    pub repr_arg: String,
-    pub error_part: &'a str,
+    pub(crate) repr_arg: String,
+    pub(crate) error_part: &'a str,
 }
 
 #[derive(Diagnostic)]
 #[diag(attr_incorrect_repr_format_align_one_arg, code = E0693)]
 pub(crate) struct IncorrectReprFormatAlignOneArg {
     #[primary_span]
-    pub span: Span,
+    pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(attr_incorrect_repr_format_expect_literal_integer, code = E0693)]
 pub(crate) struct IncorrectReprFormatExpectInteger {
     #[primary_span]
-    pub span: Span,
+    pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(attr_incorrect_repr_format_generic, code = E0693)]
 pub(crate) struct IncorrectReprFormatGeneric<'a> {
     #[primary_span]
-    pub span: Span,
+    pub(crate) span: Span,
 
-    pub repr_arg: &'a str,
+    pub(crate) repr_arg: &'a str,
 
     #[subdiagnostic]
-    pub cause: Option<IncorrectReprFormatGenericCause<'a>>,
+    pub(crate) cause: Option<IncorrectReprFormatGenericCause<'a>>,
 }
 
 #[derive(Subdiagnostic)]
@@ -303,7 +303,7 @@ pub(crate) enum IncorrectReprFormatGenericCause<'a> {
 }
 
 impl<'a> IncorrectReprFormatGenericCause<'a> {
-    pub fn from_lit_kind(span: Span, kind: &ast::LitKind, name: &'a str) -> Option<Self> {
+    pub(crate) fn from_lit_kind(span: Span, kind: &ast::LitKind, name: &'a str) -> Option<Self> {
         match kind {
             ast::LitKind::Int(int, ast::LitIntType::Unsuffixed) => {
                 Some(Self::Int { span, name, int: int.get() })
@@ -318,85 +318,85 @@ impl<'a> IncorrectReprFormatGenericCause<'a> {
 #[diag(attr_rustc_promotable_pairing, code = E0717)]
 pub(crate) struct RustcPromotablePairing {
     #[primary_span]
-    pub span: Span,
+    pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(attr_rustc_allowed_unstable_pairing, code = E0789)]
 pub(crate) struct RustcAllowedUnstablePairing {
     #[primary_span]
-    pub span: Span,
+    pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(attr_cfg_predicate_identifier)]
 pub(crate) struct CfgPredicateIdentifier {
     #[primary_span]
-    pub span: Span,
+    pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(attr_deprecated_item_suggestion)]
 pub(crate) struct DeprecatedItemSuggestion {
     #[primary_span]
-    pub span: Span,
+    pub(crate) span: Span,
 
     #[help]
-    pub is_nightly: Option<()>,
+    pub(crate) is_nightly: Option<()>,
 
     #[note]
-    pub details: (),
+    pub(crate) details: (),
 }
 
 #[derive(Diagnostic)]
 #[diag(attr_expected_single_version_literal)]
 pub(crate) struct ExpectedSingleVersionLiteral {
     #[primary_span]
-    pub span: Span,
+    pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(attr_expected_version_literal)]
 pub(crate) struct ExpectedVersionLiteral {
     #[primary_span]
-    pub span: Span,
+    pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(attr_expects_feature_list)]
 pub(crate) struct ExpectsFeatureList {
     #[primary_span]
-    pub span: Span,
+    pub(crate) span: Span,
 
-    pub name: String,
+    pub(crate) name: String,
 }
 
 #[derive(Diagnostic)]
 #[diag(attr_expects_features)]
 pub(crate) struct ExpectsFeatures {
     #[primary_span]
-    pub span: Span,
+    pub(crate) span: Span,
 
-    pub name: String,
+    pub(crate) name: String,
 }
 
 #[derive(Diagnostic)]
 #[diag(attr_invalid_since)]
 pub(crate) struct InvalidSince {
     #[primary_span]
-    pub span: Span,
+    pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(attr_soft_no_args)]
 pub(crate) struct SoftNoArgs {
     #[primary_span]
-    pub span: Span,
+    pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(attr_unknown_version_literal)]
 pub(crate) struct UnknownVersionLiteral {
     #[primary_span]
-    pub span: Span,
+    pub(crate) span: Span,
 }