handle cfg on clobber_abi

Author: folkertdev

compiler/rustc_builtin_macros/src/asm.rs

@@ -62,9 +62,9 @@ fn eat_operand_keyword<'a>(
 
 /// A parsed list of attributes that is not attached to any item.
 /// Used to check whether `asm!` arguments are configured out.
-struct AsmAttrList(ast::AttrVec);
+struct AsmAttrVec(ast::AttrVec);
 
-impl AsmAttrList {
+impl AsmAttrVec {
     fn parse<'a>(ecx: &ExtCtxt<'a>, p: &mut Parser<'a>) -> PResult<'a, Self> {
         let span_start = p.token.span;
 
@@ -86,6 +86,28 @@ impl AsmAttrList {
         Ok(Self(attributes))
     }
 }
+impl ast::HasAttrs for AsmAttrVec {
+    // Follows `ast::Expr`.
+    const SUPPORTS_CUSTOM_INNER_ATTRS: bool = false;
+
+    fn attrs(&self) -> &[rustc_ast::Attribute] {
+        &self.0
+    }
+
+    fn visit_attrs(&mut self, f: impl FnOnce(&mut rustc_ast::AttrVec)) {
+        f(&mut self.0)
+    }
+}
+
+impl ast::HasTokens for AsmAttrVec {
+    fn tokens(&self) -> Option<&rustc_ast::tokenstream::LazyAttrTokenStream> {
+        None
+    }
+
+    fn tokens_mut(&mut self) -> Option<&mut Option<rustc_ast::tokenstream::LazyAttrTokenStream>> {
+        None
+    }
+}
 
 fn parse_args<'a>(
     ecx: &ExtCtxt<'a>,
@@ -107,11 +129,18 @@ pub fn parse_asm_args<'a>(
 ) -> PResult<'a, AsmArgs> {
     let dcx = p.dcx();
 
+    let strip_unconfigured = rustc_expand::config::StripUnconfigured {
+        sess: ecx.sess,
+        features: Some(ecx.ecfg.features),
+        config_tokens: false,
+        lint_node_id: ecx.current_expansion.lint_node_id,
+    };
+
     if p.token == token::Eof {
         return Err(dcx.create_err(errors::AsmRequiresTemplate { span: sp }));
     }
 
-    let _attributes = AsmAttrList::parse(ecx, p)?;
+    let _attributes = AsmAttrVec::parse(ecx, p)?;
     let first_template = p.parse_expr()?;
     let mut args = AsmArgs {
         templates: vec![first_template],
@@ -138,12 +167,16 @@ pub fn parse_asm_args<'a>(
             break;
         } // accept trailing commas
 
-        let _attributes = AsmAttrList::parse(ecx, p)?;
+        let attributes = AsmAttrVec::parse(ecx, p)?;
+        let is_configured_out = strip_unconfigured.configure(attributes).is_none();
 
         // Parse clobber_abi
         if p.eat_keyword(exp!(ClobberAbi)) {
-            parse_clobber_abi(p, &mut args)?;
-            allow_templates = false;
+            let new_abis = parse_clobber_abi(p)?;
+            if !is_configured_out {
+                args.clobber_abis.extend(new_abis);
+                allow_templates = false;
+            }
             continue;
         }
 
@@ -466,7 +499,7 @@ fn parse_options<'a>(
     Ok(())
 }
 
-fn parse_clobber_abi<'a>(p: &mut Parser<'a>, args: &mut AsmArgs) -> PResult<'a, ()> {
+fn parse_clobber_abi<'a>(p: &mut Parser<'a>) -> PResult<'a, Vec<(Symbol, Span)>> {
     let span_start = p.prev_token.span;
 
     p.expect(exp!(OpenParen))?;
@@ -497,17 +530,9 @@ fn parse_clobber_abi<'a>(p: &mut Parser<'a>, args: &mut AsmArgs) -> PResult<'a,
     let full_span = span_start.to(p.prev_token.span);
 
     match &new_abis[..] {
-        // should have errored above during parsing
-        [] => unreachable!(),
-        [(abi, _span)] => args.clobber_abis.push((*abi, full_span)),
-        abis => {
-            for (abi, span) in abis {
-                args.clobber_abis.push((*abi, *span));
-            }
-        }
+        [(abi, _span)] => Ok(vec![(*abi, full_span)]),
+        _ => Ok(new_abis),
     }
-
-    Ok(())
 }
 
 fn parse_reg<'a>(