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,13 @@ impl<'a, 'sess> MetaItemListParserContext<'a, 'sess> {
             };
         }
 
-        let path = self.parser.parse_path(PathStyle::Mod)?;
+        let path = if self.parser.parse_cfg_pred {
+            let path = self.parser.parse_path(PathStyle::CfgPred)?;
+            self.parser.parse_cfg_pred = false;
+            path
+        } 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 +527,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 +563,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

@@ -63,8 +63,8 @@ pub(crate) fn parse_cfg(dcx: DiagCtxtHandle<'_>, cfgs: Vec<String>) -> Cfg {
                     #[allow(rustc::untranslatable_diagnostic)]
                     #[allow(rustc::diagnostic_outside_of_impl)]
                     dcx.fatal(format!(
-                        concat!("invalid `--cfg` argument: `{}` (", $reason, ")"),
-                        s
+                        concat!("invalid `--cfg` argument: `{}` ({})"),
+                        s, $reason,
                     ));
                 };
             }
@@ -83,6 +83,19 @@ 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");
+
+                                if ident.is_reserved() {
+                                    if !ident.name.can_be_raw() {
+                                        if s.trim().starts_with(&format!("r#{}", ident.as_str())) {
+                                            error!(format!("argument key must be an identifier, but `{}` cannot be a raw identifier", ident.name));
+                                        } else {
+                                            error!(format!("argument key must be an identifier but found keyword `{}`", ident.name));
+                                        }
+                                    } else if !s.trim().starts_with(&ident.to_string()) {
+                                        error!(format!("argument key must be an identifier but found keyword `{}`, escape it using `{}`", ident.as_str(), ident));
+                                    }
+                                }
+
                                 return (ident.name, meta_item.value_str());
                             }
                         }
@@ -91,7 +104,7 @@ pub(crate) fn parse_cfg(dcx: DiagCtxtHandle<'_>, cfgs: Vec<String>) -> Cfg {
                     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.
@@ -202,18 +215,54 @@ pub(crate) fn parse_check_cfg(dcx: DiagCtxtHandle<'_>, specs: Vec<String>) -> Ch
         let mut values_specified = false;
         let mut values_any_specified = false;
 
+        let arg_strs = s
+            .trim()
+            .trim_start_matches("cfg(")
+            .trim_end_matches(')')
+            .split(',')
+            .collect::<Vec<_>>();
+
         for arg in args {
             if arg.is_word()
                 && let Some(ident) = arg.ident()
             {
                 if values_specified {
                     error!("`cfg()` names cannot be after values");
                 }
+
+                if ident.is_reserved() {
+                    if !ident.name.can_be_raw() {
+                        if arg_strs[names.len()].starts_with(&format!("r#{}", ident.as_str())) {
+                            error!(format!(
+                                "argument key must be an identifier, but `{}` cannot be a raw identifier",
+                                ident.name
+                            ));
+                        } else {
+                            error!(format!(
+                                "argument key must be an identifier but found keyword `{}`",
+                                ident.name
+                            ));
+                        }
+                    } else if !arg_strs[names.len()].starts_with(&ident.to_string()) {
+                        error!(format!(
+                            "argument key must be an identifier but found keyword `{}`, escape it using `{}`",
+                            ident.as_str(),
+                            ident
+                        ));
+                    }
+                }
+
                 names.push(ident);
             } else if let Some(boolean) = arg.boolean_literal() {
                 if values_specified {
                     error!("`cfg()` names cannot be after values");
                 }
+
+                let lit_str = arg_strs[names.len()];
+                if !lit_str.starts_with("r#") {
+                    error!(in arg, format!("`cfg()` names must be identifiers but found keyword `{lit_str}`, escape it using `r#{lit_str}`"));
+                }
+
                 names.push(rustc_span::Ident::new(
                     if boolean { rustc_span::kw::True } else { rustc_span::kw::False },
                     arg.span(),

compiler/rustc_parse/src/parser/attr.rs

@@ -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,14 @@ impl<'a> Parser<'a> {
             ast::Safety::Default
         };
 
-        let path = self.parse_path(PathStyle::Mod)?;
+        let path = if self.parse_cfg_pred {
+            let path = self.parse_path(PathStyle::CfgPred)?;
+            self.parse_cfg_pred = false;
+            path
+        } 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_parse/src/parser/path.rs

@@ -57,6 +57,8 @@ pub enum PathStyle {
     /// anyway, due to macros), but it is used to avoid weird suggestions about expected
     /// tokens when something goes wrong.
     Mod,
+    /// Disallow path segment keywords when parsing cfg preds
+    CfgPred,
 }
 
 impl PathStyle {
@@ -299,7 +301,12 @@ impl<'a> Parser<'a> {
         style: PathStyle,
         ty_generics: Option<&Generics>,
     ) -> PResult<'a, PathSegment> {
-        let ident = self.parse_path_segment_ident()?;
+        let ident = if style == PathStyle::CfgPred {
+            self.parse_ident()?
+        } else {
+            self.parse_path_segment_ident()?
+        };
+
         let is_args_start = |token: &Token| {
             matches!(token.kind, token::Lt | token::Shl | token::OpenParen | token::LArrow)
         };

compiler/rustc_span/src/symbol.rs

@@ -3048,7 +3048,7 @@ impl Symbol {
         self == kw::True || self == kw::False
     }
 
-    /// Returns `true` if this symbol can be a raw identifier.
+    /// Returns `true` if this symbol can be a raw identifier in path segment.
     pub fn can_be_raw(self) -> bool {
         self != sym::empty && self != kw::Underscore && !self.is_path_segment_keyword()
     }

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

@@ -0,0 +1,2 @@
+error: invalid `--cfg` argument: `async` (argument key must be an identifier but found keyword `async`, escape it using `r#async`)
+