Auto merge of #164898 - JonathanBrouwer:silence-early-lint, r=<try>

Don't emit diagnostics during early lint attribute parsing

Author: bors

compiler/rustc_attr_ir/src/diagnostic.rs

@@ -2,8 +2,10 @@
 use std::fmt;
 use std::fmt::Debug;
 
-use rustc_macros::{Decodable, Encodable, PrintAttribute, StableHash};
-use rustc_span::{DesugaringKind, Span, Symbol, kw};
+use rustc_macros::{
+    Decodable, Decodable_NoContext, Encodable, Encodable_NoContext, PrintAttribute, StableHash,
+};
+use rustc_span::{DesugaringKind, ErrorGuaranteed, Span, Symbol, kw};
 use thin_vec::ThinVec;
 use tracing::debug;
 
@@ -481,3 +483,28 @@ impl FilterOptions {
         }
     }
 }
+
+/// An `AttrErrorGuaranteed` is the same thing as a normal `ErrorGuaranteed`, except attribute parsers sometimes don't emit diagnostics.
+/// This will contain a `None` if and only if `ShouldEmit::NothingNoBug` is used.
+#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(StableHash, Encodable_NoContext, Decodable_NoContext, PrintAttribute)]
+pub struct AttrErrorGuaranteed(Option<ErrorGuaranteed>);
+
+impl AttrErrorGuaranteed {
+    /// Constructs a `AttrErrorGuaranteed` with a `None` inside, this should only be called in `ShouldEmit::emit_err`.
+    pub fn unchecked_attr_error_guaranteed() -> Self {
+        Self(None)
+    }
+
+    /// Retrieve the inner `ErrorGuaranteed`
+    /// This will panic if and only if `ShouldEmit::NothingNoBug` is used.
+    pub fn unwrap(self) -> ErrorGuaranteed {
+        self.0.unwrap()
+    }
+}
+
+impl From<ErrorGuaranteed> for AttrErrorGuaranteed {
+    fn from(value: ErrorGuaranteed) -> Self {
+        Self(Some(value))
+    }
+}

compiler/rustc_attr_ir/src/lib.rs

@@ -17,6 +17,7 @@
 
 pub use attr::*;
 pub use data_structures::*;
+pub use diagnostic::AttrErrorGuaranteed;
 pub use encode_cross_crate::EncodeCrossCrate;
 pub use lang_items::*;
 pub use pretty_printing::PrintAttribute;

compiler/rustc_attr_ir/src/stability.rs

@@ -2,9 +2,9 @@ use std::num::NonZero;
 
 use rustc_ast::attr::version::RustcVersion;
 use rustc_macros::{BlobDecodable, Decodable, Encodable, PrintAttribute, StableHash};
-use rustc_span::{ErrorGuaranteed, Symbol, sym};
+use rustc_span::{Symbol, sym};
 
-use crate::PrintAttribute;
+use crate::{AttrErrorGuaranteed, PrintAttribute};
 
 /// The version placeholder that recently stabilized features contain inside the
 /// `since` field of the `#[stable]` attribute.
@@ -154,7 +154,7 @@ pub enum StableSince {
     /// Stabilized in the upcoming version, whatever number that is.
     Current,
     /// Failed to parse a stabilization version.
-    Err(ErrorGuaranteed),
+    Err(AttrErrorGuaranteed),
 }
 
 impl StabilityLevel {

compiler/rustc_attr_parsing/src/attributes/cfg.rs

@@ -4,7 +4,7 @@ use rustc_ast::token::Delimiter;
 use rustc_ast::tokenstream::{DelimSpan, WithTokens};
 use rustc_ast::{AttrItem, Attribute, LitKind, ast, token};
 use rustc_attr_ir::target::Target;
-use rustc_attr_ir::{AttrPath, CfgEntry, RustcVersion};
+use rustc_attr_ir::{AttrErrorGuaranteed, AttrPath, CfgEntry, RustcVersion};
 use rustc_errors::{Applicability, Diagnostic, PResult, msg};
 use rustc_feature::{Features, GatedCfg, find_gated_cfg};
 use rustc_lint_defs::builtin::UNEXPECTED_CFGS;
@@ -14,7 +14,7 @@ use rustc_session::Session;
 use rustc_session::config::ExpectedValues;
 use rustc_session::diagnostics::feature_err;
 use rustc_session::parse::ParseSess;
-use rustc_span::{ErrorGuaranteed, Span, Symbol, sym};
+use rustc_span::{Span, Symbol, sym};
 use thin_vec::ThinVec;
 
 use crate::attributes::AttributeSafety;
@@ -79,7 +79,7 @@ pub fn parse_cfg(cx: &mut AcceptContext<'_, '_>, args: &ArgParser) -> Option<Cfg
 pub fn parse_cfg_entry(
     cx: &mut AcceptContext<'_, '_>,
     item: &MetaItemOrLitParser,
-) -> Result<CfgEntry, ErrorGuaranteed> {
+) -> Result<CfgEntry, AttrErrorGuaranteed> {
     Ok(match item {
         MetaItemOrLitParser::MetaItemParser(meta) => match meta.args() {
             ArgParser::List(list) => match meta.path().word_sym() {
@@ -126,7 +126,7 @@ fn parse_cfg_entry_version(
     cx: &mut AcceptContext<'_, '_>,
     list: &MetaItemListParser,
     meta_span: Span,
-) -> Result<CfgEntry, ErrorGuaranteed> {
+) -> Result<CfgEntry, AttrErrorGuaranteed> {
     try_gate_cfg(sym::version, meta_span, cx.sess(), cx.features_option());
     let Some(version) = list.as_single() else {
         return Err(cx.emit_err(diagnostics::ExpectedSingleVersionLiteral { span: list.span }));
@@ -150,7 +150,7 @@ fn parse_cfg_entry_target(
     cx: &mut AcceptContext<'_, '_>,
     list: &MetaItemListParser,
     meta_span: Span,
-) -> Result<CfgEntry, ErrorGuaranteed> {
+) -> Result<CfgEntry, AttrErrorGuaranteed> {
     if let Some(features) = cx.features_option()
         && !features.cfg_target_compact()
     {
@@ -188,7 +188,7 @@ pub(crate) fn parse_name_value(
     value: Option<&NameValueParser>,
     span: Span,
     cx: &mut AcceptContext<'_, '_>,
-) -> Result<CfgEntry, ErrorGuaranteed> {
+) -> Result<CfgEntry, AttrErrorGuaranteed> {
     try_gate_cfg(name, span, cx.sess(), cx.features_option());
 
     let value = match value {
@@ -408,8 +408,8 @@ fn parse_cfg_attr_internal<'a>(
         parse_cfg_entry,
         &CFG_ATTR_TEMPLATE,
     )
-    .map_err(|_err: ErrorGuaranteed| {
-        // We have an `ErrorGuaranteed` so this delayed bug cannot fail, but we need a `Diag` for the `PResult` so we make one anyways
+    .map_err(|_err: AttrErrorGuaranteed| {
+        // We have an `AttrErrorGuaranteed` so this delayed bug cannot fail, but we need a `Diag` for the `PResult` so we make one anyways
         let mut diag = sess.dcx().struct_err(
             "cfg_entry parsing failing with `ShouldEmit::ErrorsAndLints` should emit a error.",
         );

compiler/rustc_attr_parsing/src/attributes/cfg_select.rs

@@ -2,15 +2,15 @@ use rustc_ast::token::Token;
 use rustc_ast::tokenstream::TokenStream;
 use rustc_ast::{AttrStyle, NodeId, token};
 use rustc_attr_ir::target::Target;
-use rustc_attr_ir::{AttrPath, CfgEntry};
+use rustc_attr_ir::{AttrErrorGuaranteed, AttrPath, CfgEntry};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Diagnostic;
 use rustc_feature::Features;
 use rustc_lint_defs::builtin::UNREACHABLE_CFG_SELECT_PREDICATES;
 use rustc_parse::exp;
 use rustc_parse::parser::{Parser, Recovery};
 use rustc_session::Session;
-use rustc_span::{ErrorGuaranteed, Span, Symbol, sym};
+use rustc_span::{Span, Symbol, sym};
 
 use crate::attributes::AttributeSafety;
 use crate::parser::{AllowExprMetavar, MetaItemOrLitParser};
@@ -85,7 +85,7 @@ pub fn parse_cfg_select(
     sess: &Session,
     features: Option<&Features>,
     lint_node_id: NodeId,
-) -> Result<CfgSelectBranches, ErrorGuaranteed> {
+) -> Result<CfgSelectBranches, AttrErrorGuaranteed> {
     let mut branches = CfgSelectBranches::default();
 
     while p.token != token::Eof {

compiler/rustc_attr_parsing/src/attributes/stability.rs

@@ -2,10 +2,9 @@ use std::num::NonZero;
 
 use rustc_attr_ir::target::{AssocCtxt, MethodKind, Target};
 use rustc_attr_ir::{
-    DefaultBodyStability, PartialConstStability, Stability, StabilityLevel, StableSince,
-    UnstableReason, UnstableRemovedFeature, VERSION_PLACEHOLDER,
+    AttrErrorGuaranteed, DefaultBodyStability, PartialConstStability, Stability, StabilityLevel,
+    StableSince, UnstableReason, UnstableRemovedFeature, VERSION_PLACEHOLDER,
 };
-use rustc_errors::ErrorGuaranteed;
 use rustc_feature::{ACCEPTED_LANG_FEATURES, AttributeStability};
 
 use super::prelude::*;
@@ -384,7 +383,7 @@ pub(crate) fn parse_stability(
             let level = StabilityLevel::Stable { since, allowed_through_unstable_modules: None };
             Some((feature, level))
         }
-        Err(ErrorGuaranteed { .. }) => None,
+        Err(AttrErrorGuaranteed { .. }) => None,
     }
 }
 
@@ -483,7 +482,7 @@ pub(crate) fn parse_unstability(
             };
             Some((feature, level))
         }
-        (Err(ErrorGuaranteed { .. }), _) | (_, Err(ErrorGuaranteed { .. })) => None,
+        (Err(AttrErrorGuaranteed { .. }), _) | (_, Err(AttrErrorGuaranteed { .. })) => None,
     }
 }