Eagerly emit the error in parse_meta

Author: oli-obk

compiler/rustc_expand/src/config.rs

@@ -370,8 +370,7 @@ impl<'a> StripUnconfigured<'a> {
     pub(crate) fn cfg_true(&self, attr: &Attribute) -> (bool, Option<MetaItem>) {
         let meta_item = match validate_attr::parse_meta(&self.sess.psess, attr) {
             Ok(meta_item) => meta_item,
-            Err(err) => {
-                err.emit();
+            Err(_guar) => {
                 return (true, None);
             }
         };

compiler/rustc_expand/src/expand.rs

@@ -765,10 +765,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
                                 fragment_kind.expect_from_annotatables(items)
                             }
                         }
-                        Err(err) => {
-                            let guar = err.emit();
-                            fragment_kind.dummy(span, guar)
-                        }
+                        Err(guar) => fragment_kind.dummy(span, guar),
                     }
                 }
                 SyntaxExtensionKind::NonMacroAttr => {

compiler/rustc_parse/src/validate_attr.rs

@@ -8,15 +8,15 @@ use rustc_ast::{
     self as ast, AttrArgs, AttrArgsEq, Attribute, DelimArgs, MetaItem, MetaItemKind,
     NestedMetaItem, Safety,
 };
-use rustc_errors::{Applicability, FatalError, PResult};
+use rustc_errors::{Applicability, FatalError};
 use rustc_feature::{
     AttributeSafety, AttributeTemplate, BuiltinAttribute, Features, BUILTIN_ATTRIBUTE_MAP,
 };
 use rustc_session::errors::report_lit_error;
 use rustc_session::lint::builtin::{ILL_FORMED_ATTRIBUTE_INPUT, UNSAFE_ATTR_OUTSIDE_UNSAFE};
 use rustc_session::lint::BuiltinLintDiag;
 use rustc_session::parse::ParseSess;
-use rustc_span::{sym, BytePos, Span, Symbol};
+use rustc_span::{sym, BytePos, ErrorGuaranteed, Span, Symbol};
 
 pub fn check_attr(features: &Features, psess: &ParseSess, attr: &Attribute) {
     if attr.is_doc_comment() {
@@ -81,25 +81,21 @@ pub fn check_attr(features: &Features, psess: &ParseSess, attr: &Attribute) {
         Some(BuiltinAttribute { name, template, .. }) if *name != sym::rustc_dummy => {
             match parse_meta(psess, attr) {
                 Ok(meta) => check_builtin_meta_item(psess, &meta, attr.style, *name, *template),
-                Err(err) => {
-                    err.emit();
-                }
+                Err(_guar) => {}
             }
         }
         _ if let AttrArgs::Eq(..) = attr_item.args => {
             // All key-value attributes are restricted to meta-item syntax.
             match parse_meta(psess, attr) {
                 Ok(_) => {}
-                Err(err) => {
-                    err.emit();
-                }
+                Err(_guar) => {}
             }
         }
         _ => {}
     }
 }
 
-pub fn parse_meta<'a>(psess: &'a ParseSess, attr: &Attribute) -> PResult<'a, MetaItem> {
+pub fn parse_meta(psess: &ParseSess, attr: &Attribute) -> Result<MetaItem, ErrorGuaranteed> {
     let item = attr.get_normal_item();
     Ok(MetaItem {
         unsafety: item.unsafety,
@@ -109,8 +105,8 @@ pub fn parse_meta<'a>(psess: &'a ParseSess, attr: &Attribute) -> PResult<'a, Met
             AttrArgs::Empty => MetaItemKind::Word,
             AttrArgs::Delimited(DelimArgs { dspan, delim, tokens }) => {
                 check_meta_bad_delim(psess, *dspan, *delim);
-                let nmis =
-                    parse_in(psess, tokens.clone(), "meta list", |p| p.parse_meta_seq_top())?;
+                let nmis = parse_in(psess, tokens.clone(), "meta list", |p| p.parse_meta_seq_top())
+                    .map_err(|d| d.emit())?;
                 MetaItemKind::List(nmis)
             }
             AttrArgs::Eq(_, AttrArgsEq::Ast(expr)) => {
@@ -127,7 +123,7 @@ pub fn parse_meta<'a>(psess: &'a ParseSess, attr: &Attribute) -> PResult<'a, Met
                                     "instead of using a suffixed literal (`1u8`, `1.0f32`, etc.), \
                                     use an unsuffixed version (`1`, `1.0`, etc.)",
                                 );
-                                return Err(err);
+                                return Err(err.emit());
                             } else {
                                 MetaItemKind::NameValue(lit)
                             }
@@ -156,7 +152,7 @@ pub fn parse_meta<'a>(psess: &'a ParseSess, attr: &Attribute) -> PResult<'a, Met
                     if let ast::ExprKind::Err(_) = expr.kind {
                         err.downgrade_to_delayed_bug();
                     }
-                    return Err(err);
+                    return Err(err.emit());
                 }
             }
             AttrArgs::Eq(_, AttrArgsEq::Hir(lit)) => MetaItemKind::NameValue(lit.clone()),