Deny using path-segment kw when parsing cfg pred

Author: mu001999

compiler/rustc_attr_parsing/src/interface.rs

@@ -118,6 +118,7 @@ impl<'sess> AttributeParser<'sess, Early> {
         target_node_id: NodeId,
         features: Option<&'sess Features>,
         emit_errors: ShouldEmit,
+        parsing_cfg: bool,
         parse_fn: fn(cx: &mut AcceptContext<'_, '_, Early>, item: &ArgParser<'_>) -> Option<T>,
         template: &AttributeTemplate,
     ) -> Option<T> {
@@ -133,7 +134,8 @@ impl<'sess> AttributeParser<'sess, Early> {
         };
         let parts =
             normal_attr.item.path.segments.iter().map(|seg| seg.ident.name).collect::<Vec<_>>();
-        let meta_parser = MetaItemParser::from_attr(normal_attr, &parts, &sess.psess, emit_errors)?;
+        let meta_parser =
+            MetaItemParser::from_attr(normal_attr, &parts, &sess.psess, emit_errors, parsing_cfg)?;
         let path = meta_parser.path();
         let args = meta_parser.args();
         let mut cx: AcceptContext<'_, 'sess, Early> = AcceptContext {
@@ -251,6 +253,7 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
                             &parts,
                             &self.sess.psess,
                             self.stage.should_emit(),
+                            false,
                         ) else {
                             continue;
                         };

compiler/rustc_attr_parsing/src/parser.rs

@@ -104,6 +104,7 @@ impl<'a> ArgParser<'a> {
         parts: &[Symbol],
         psess: &'sess ParseSess,
         should_emit: ShouldEmit,
+        parsing_cfg: bool,
     ) -> Option<Self> {
         Some(match value {
             AttrArgs::Empty => Self::NoArgs,
@@ -124,7 +125,7 @@ impl<'a> ArgParser<'a> {
                     return None;
                 }
 
-                Self::List(MetaItemListParser::new(args, psess, should_emit)?)
+                Self::List(MetaItemListParser::new(args, psess, should_emit, parsing_cfg)?)
             }
             AttrArgs::Eq { eq_span, expr } => Self::NameValue(NameValueParser {
                 eq_span: *eq_span,
@@ -248,10 +249,17 @@ impl<'a> MetaItemParser<'a> {
         parts: &[Symbol],
         psess: &'sess ParseSess,
         should_emit: ShouldEmit,
+        parsing_cfg: bool,
     ) -> Option<Self> {
         Some(Self {
             path: PathParser(Cow::Borrowed(&attr.item.path)),
-            args: ArgParser::from_attr_args(&attr.item.args, parts, psess, should_emit)?,
+            args: ArgParser::from_attr_args(
+                &attr.item.args,
+                parts,
+                psess,
+                should_emit,
+                parsing_cfg,
+            )?,
         })
     }
 }
@@ -425,7 +433,12 @@ impl<'a, 'sess> MetaItemListParserContext<'a, 'sess> {
             };
         }
 
-        let path = self.parser.parse_path(PathStyle::Mod)?;
+        let path = if self.parser.parse_cfg_pred {
+            self.parser.parse_cfg_pred = false;
+            Path::from_ident(self.parser.parse_ident()?)
+        } else {
+            self.parser.parse_path(PathStyle::Mod)?
+        };
 
         // Check style of arguments that this meta item has
         let args = if self.parser.check(exp!(OpenParen)) {
@@ -513,8 +526,11 @@ impl<'a, 'sess> MetaItemListParserContext<'a, 'sess> {
         psess: &'sess ParseSess,
         span: Span,
         should_emit: ShouldEmit,
+        parsing_cfg: bool,
     ) -> PResult<'sess, MetaItemListParser<'static>> {
         let mut parser = Parser::new(psess, tokens, None);
+        parser.parse_cfg_pred = parsing_cfg;
+
         let mut this = MetaItemListParserContext { parser: &mut parser, should_emit };
 
         // Presumably, the majority of the time there will only be one attr.
@@ -546,12 +562,14 @@ impl<'a> MetaItemListParser<'a> {
         delim: &'a DelimArgs,
         psess: &'sess ParseSess,
         should_emit: ShouldEmit,
+        parsing_cfg: bool,
     ) -> Option<Self> {
         match MetaItemListParserContext::parse(
             delim.tokens.clone(),
             psess,
             delim.dspan.entire(),
             should_emit,
+            parsing_cfg,
         ) {
             Ok(s) => Some(s),
             Err(e) => {

compiler/rustc_builtin_macros/src/cfg.rs

@@ -42,6 +42,7 @@ fn parse_cfg<'a>(
     tts: TokenStream,
 ) -> PResult<'a, ast::MetaItemInner> {
     let mut p = cx.new_parser_from_tts(tts);
+    p.parse_cfg_pred = true;
 
     if p.token == token::Eof {
         return Err(cx.dcx().create_err(errors::RequiresCfgPattern { span }));

compiler/rustc_expand/src/config.rs

@@ -428,6 +428,7 @@ impl<'a> StripUnconfigured<'a> {
             node,
             self.features,
             emit_errors,
+            true,
             parse_cfg_attr,
             &CFG_TEMPLATE,
         ) else {

compiler/rustc_interface/src/interface.rs

@@ -83,15 +83,22 @@ pub(crate) fn parse_cfg(dcx: DiagCtxtHandle<'_>, cfgs: Vec<String>) -> Cfg {
                             }
                             MetaItemKind::NameValue(..) | MetaItemKind::Word => {
                                 let ident = meta_item.ident().expect("multi-segment cfg key");
-                                return (ident.name, meta_item.value_str());
+
+                                if ident.is_reserved()
+                                    && !s.contains(&format!("r#{}", ident.as_str()))
+                                {
+                                    error!("argument key must be an identifier");
+                                } else {
+                                    return (ident.name, meta_item.value_str());
+                                }
                             }
                         }
                     }
                     Ok(..) => {}
                     Err(err) => err.cancel(),
                 },
                 Err(errs) => errs.into_iter().for_each(|err| err.cancel()),
-            }
+            };
 
             // If the user tried to use a key="value" flag, but is missing the quotes, provide
             // a hint about how to resolve this.

compiler/rustc_parse/src/parser/attr.rs

@@ -1,7 +1,7 @@
 use rustc_ast as ast;
 use rustc_ast::token::{self, MetaVarKind};
 use rustc_ast::tokenstream::ParserRange;
-use rustc_ast::{Attribute, attr};
+use rustc_ast::{Attribute, Path, attr};
 use rustc_errors::codes::*;
 use rustc_errors::{Diag, PResult};
 use rustc_span::{BytePos, Span};
@@ -381,6 +381,7 @@ impl<'a> Parser<'a> {
     pub fn parse_cfg_attr(
         &mut self,
     ) -> PResult<'a, (ast::MetaItemInner, Vec<(ast::AttrItem, Span)>)> {
+        self.parse_cfg_pred = true;
         let cfg_predicate = self.parse_meta_item_inner()?;
         self.expect(exp!(Comma))?;
 
@@ -449,7 +450,13 @@ impl<'a> Parser<'a> {
             ast::Safety::Default
         };
 
-        let path = self.parse_path(PathStyle::Mod)?;
+        let path = if self.parse_cfg_pred {
+            self.parse_cfg_pred = false;
+            Path::from_ident(self.parse_ident()?)
+        } else {
+            self.parse_path(PathStyle::Mod)?
+        };
+
         let kind = self.parse_meta_item_kind()?;
         if is_unsafe {
             self.expect(exp!(CloseParen))?;

compiler/rustc_parse/src/parser/mod.rs

@@ -181,6 +181,7 @@ pub struct Parser<'a> {
     /// The previous token.
     pub prev_token: Token,
     pub capture_cfg: bool,
+    pub parse_cfg_pred: bool,
     restrictions: Restrictions,
     expected_token_types: TokenTypeSet,
     token_cursor: TokenCursor,
@@ -372,6 +373,7 @@ impl<'a> Parser<'a> {
             },
             current_closure: None,
             recovery: Recovery::Allowed,
+            parse_cfg_pred: false,
         };
 
         // Make parser point to the first token.

compiler/rustc_span/src/symbol.rs

@@ -3034,7 +3034,9 @@ impl Symbol {
 
     /// Returns `true` if this symbol can be a raw identifier.
     pub fn can_be_raw(self) -> bool {
-        self != sym::empty && self != kw::Underscore && !self.is_path_segment_keyword()
+        self != sym::empty
+            && self != kw::Underscore
+            && !matches!(self, kw::PathRoot | kw::DollarCrate)
     }
 
     /// Was this symbol index predefined in the compiler's `symbols!` macro?

tests/ui/cfg/path-kw-as-pred-cli-allow.rs

@@ -0,0 +1,5 @@
+//@ edition: 2024
+//@ check-pass
+//@ compile-flags: --cfg r#crate --cfg r#super --cfg r#self --cfg r#Self --cfg r#struct --cfg r#enum --cfg r#async --cfg r#impl --cfg r#trait
+
+fn main() {}

tests/ui/cfg/path-kw-as-pred-cli.cfg_async.stderr

@@ -0,0 +1,2 @@
+error: invalid `--cfg` argument: `async` (argument key must be an identifier)
+