Remove should_emit from stage

Author: JonathanBrouwer

compiler/rustc_ast_lowering/src/lib.rs

@@ -41,7 +41,7 @@ use std::sync::Arc;
 use rustc_ast::node_id::NodeMap;
 use rustc_ast::visit::Visitor;
 use rustc_ast::{self as ast, *};
-use rustc_attr_parsing::{AttributeParser, EmitAttribute, Late, OmitDoc};
+use rustc_attr_parsing::{AttributeParser, EmitAttribute, OmitDoc, Recovery, ShouldEmit};
 use rustc_data_structures::fingerprint::Fingerprint;
 use rustc_data_structures::fx::FxIndexSet;
 use rustc_data_structures::sorted_map::SortedMap;
@@ -212,7 +212,7 @@ impl<'a, 'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'a, 'hir, R> {
                 tcx.sess,
                 tcx.features(),
                 registered_tools,
-                Late,
+                ShouldEmit::ErrorsAndLints { recovery: Recovery::Allowed },
             ),
             delayed_lints: Vec::new(),
         }

compiler/rustc_attr_parsing/src/attributes/diagnostic/on_unknown.rs

@@ -31,7 +31,7 @@ impl OnUnknownParser {
 
         // At early parsing we get passed `Target::Crate` regardless of the item we're on.
         // Only do target checking if we're late.
-        let early = matches!(cx.stage.should_emit(), ShouldEmit::Nothing);
+        let early = matches!(cx.should_emit, ShouldEmit::Nothing);
 
         if !early && !matches!(cx.target, Target::Use) {
             let target_span = cx.target_span;

compiler/rustc_attr_parsing/src/context.rs

@@ -355,8 +355,6 @@ pub trait Stage: Sized + 'static + Sealed {
     type Id: Copy;
 
     fn parsers() -> &'static GroupType<Self>;
-
-    fn should_emit(&self) -> ShouldEmit;
 }
 
 // allow because it's a sealed trait
@@ -367,10 +365,6 @@ impl Stage for Early {
     fn parsers() -> &'static GroupType<Self> {
         &early::ATTRIBUTE_PARSERS
     }
-
-    fn should_emit(&self) -> ShouldEmit {
-        self.emit_errors
-    }
 }
 
 // allow because it's a sealed trait
@@ -381,19 +375,11 @@ impl Stage for Late {
     fn parsers() -> &'static GroupType<Self> {
         &late::ATTRIBUTE_PARSERS
     }
-
-    fn should_emit(&self) -> ShouldEmit {
-        ShouldEmit::ErrorsAndLints { recovery: Recovery::Allowed }
-    }
 }
 
 /// Used when parsing attributes for miscellaneous things *before* ast lowering
-pub struct Early {
-    /// Whether to emit errors or delay them as a bug.
-    /// For most attributes, the attribute will be parsed again in the `Late` stage and in this case the errors should be delayed.
-    /// But for some, such as `cfg`, the attribute will be removed before the `Late` stage so errors must be emitted.
-    pub emit_errors: ShouldEmit,
-}
+pub struct Early;
+
 /// used when parsing attributes during ast lowering
 pub struct Late;
 
@@ -473,7 +459,7 @@ impl<'f, 'sess: 'f, S: Stage> SharedContext<'f, 'sess, S> {
         span: impl Into<MultiSpan>,
     ) {
         if !matches!(
-            self.stage.should_emit(),
+            self.should_emit,
             ShouldEmit::ErrorsAndLints { .. } | ShouldEmit::EarlyFatal { also_emit_lints: true }
         ) {
             return;

compiler/rustc_attr_parsing/src/interface.rs

@@ -1,4 +1,5 @@
 use std::convert::identity;
+use std::marker::PhantomData;
 
 use rustc_ast as ast;
 use rustc_ast::token::DocFragmentKind;
@@ -11,7 +12,7 @@ use rustc_hir::lints::AttributeLintKind;
 use rustc_hir::{AttrArgs, AttrItem, AttrPath, Attribute, HashIgnoredAttrId, Target};
 use rustc_session::Session;
 use rustc_session::lint::LintId;
-use rustc_span::{DUMMY_SP, Span, Symbol, sym, ErrorGuaranteed};
+use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span, Symbol, sym};
 
 use crate::attributes::AttributeSafety;
 use crate::context::{AcceptContext, FinalizeContext, FinalizeFn, SharedContext, Stage};
@@ -35,7 +36,8 @@ pub struct AttributeParser<'sess, S: Stage = Late> {
     pub(crate) tools: Vec<Symbol>,
     pub(crate) features: Option<&'sess Features>,
     pub(crate) sess: &'sess Session,
-    pub(crate) stage: S,
+    pub(crate) stage: PhantomData<S>,
+    pub(crate) should_emit: ShouldEmit,
 
     /// *Only* parse attributes with this symbol.
     ///
@@ -117,10 +119,10 @@ impl<'sess> AttributeParser<'sess, Early> {
         target_span: Span,
         target_node_id: NodeId,
         features: Option<&'sess Features>,
-        emit_errors: ShouldEmit,
+        should_emit: ShouldEmit,
     ) -> Vec<Attribute> {
         let mut p =
-            Self { features, tools: Vec::new(), parse_only, sess, stage: Early { emit_errors } };
+            Self { features, tools: Vec::new(), parse_only, sess, stage: PhantomData, should_emit };
         p.parse_attribute_list(
             attrs,
             target_span,
@@ -202,7 +204,7 @@ impl<'sess> AttributeParser<'sess, Early> {
         target_node_id: NodeId,
         target: Target,
         features: Option<&'sess Features>,
-        emit_errors: ShouldEmit,
+        should_emit: ShouldEmit,
         args: &I,
         parse_fn: fn(cx: &mut AcceptContext<'_, '_, Early>, item: &I) -> T,
         template: &AttributeTemplate,
@@ -212,7 +214,8 @@ impl<'sess> AttributeParser<'sess, Early> {
             tools: Vec::new(),
             parse_only: None,
             sess,
-            stage: Early { emit_errors },
+            stage: PhantomData,
+            should_emit,
         };
         let mut emit_lint = |lint_id: LintId, span: MultiSpan, kind: EmitAttribute| match kind {
             EmitAttribute::Static(kind) => {
@@ -254,9 +257,16 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
         sess: &'sess Session,
         features: &'sess Features,
         tools: Vec<Symbol>,
-        stage: S,
+        should_emit: ShouldEmit,
     ) -> Self {
-        Self { features: Some(features), tools, parse_only: None, sess, stage }
+        Self {
+            features: Some(features),
+            tools,
+            parse_only: None,
+            sess,
+            should_emit,
+            stage: PhantomData,
+        }
     }
 
     pub(crate) fn sess(&self) -> &'sess Session {
@@ -276,7 +286,7 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
     }
 
     pub(crate) fn emit_err(&self, diag: impl for<'x> Diagnostic<'x>) -> ErrorGuaranteed {
-        self.stage.should_emit().emit_err(self.sess.dcx().create_err(diag))
+        self.should_emit.emit_err(self.sess.dcx().create_err(diag))
     }
 
     /// Parse a list of attributes.
@@ -364,7 +374,7 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
                             args,
                             &parts,
                             &self.sess.psess,
-                            self.stage.should_emit(),
+                            self.should_emit,
                             AllowExprMetavar::No,
                         ) else {
                             continue;
@@ -419,7 +429,7 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
                         (accept.accept_fn)(&mut cx, &args);
                         finalizers.push(&accept.finalizer);
 
-                        if !matches!(cx.stage.should_emit(), ShouldEmit::Nothing) {
+                        if !matches!(cx.should_emit, ShouldEmit::Nothing) {
                             Self::check_target(&accept.allowed_targets, target, &mut cx);
                         }
                     } else {
@@ -440,7 +450,7 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
                             &mut emit_lint,
                         );
 
-                        if !matches!(self.stage.should_emit(), ShouldEmit::Nothing)
+                        if !matches!(self.should_emit, ShouldEmit::Nothing)
                             && target == Target::Crate
                         {
                             self.check_invalid_crate_level_attr_item(&attr, n.item.span());
@@ -473,9 +483,7 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
             }
         }
 
-        if !matches!(self.stage.should_emit(), ShouldEmit::Nothing)
-            && target == Target::WherePredicate
-        {
+        if !matches!(self.should_emit, ShouldEmit::Nothing) && target == Target::WherePredicate {
             self.check_invalid_where_predicate_attrs(attributes.iter().chain(&dropped_attributes));
         }
 

compiler/rustc_attr_parsing/src/lib.rs

@@ -114,4 +114,5 @@ pub use attributes::cfg_select::*;
 pub use attributes::util::{is_builtin_attr, parse_version};
 pub use context::{Early, Late, OmitDoc, ShouldEmit};
 pub use interface::{AttributeParser, EmitAttribute};
+pub use rustc_parse::parser::Recovery;
 pub use session_diagnostics::ParsedDescription;

compiler/rustc_attr_parsing/src/safety.rs

@@ -18,7 +18,7 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
         expected_safety: AttributeSafety,
         emit_lint: &mut impl FnMut(LintId, MultiSpan, EmitAttribute),
     ) {
-        if matches!(self.stage.should_emit(), ShouldEmit::Nothing) {
+        if matches!(self.should_emit, ShouldEmit::Nothing) {
             return;
         }
 

compiler/rustc_resolve/src/def_collector.rs

@@ -150,7 +150,7 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
                     &self.r.tcx.sess,
                     self.r.tcx.features(),
                     Vec::new(),
-                    Early { emit_errors: ShouldEmit::Nothing },
+                    ShouldEmit::Nothing,
                 );
                 let attrs = parser.parse_attribute_list(
                     &i.attrs,