WIP: deny path-segment kw in cfg

mu001999 · mu001999 · commit 97cd2c7037cb · 2025-10-09T19:16:04.000+08:00
diff --git a/compiler/rustc_attr_parsing/src/attributes/cfg.rs b/compiler/rustc_attr_parsing/src/attributes/cfg.rs
@@ -69,8 +69,7 @@ pub(crate) fn parse_cfg_entry<S: Stage>(
                 }
             },
             a @ (ArgParser::NoArgs | ArgParser::NameValue(_)) => {
-                let Some(name) = meta.path().word_sym().filter(|s| !s.is_path_segment_keyword())
-                else {
+                let Some(name) = meta.path().word_sym() else {
                     cx.emit_err(session_diagnostics::CfgPredicateIdentifier {
                         span: meta.path().span(),
                     });
@@ -149,7 +148,7 @@ fn parse_cfg_entry_target<S: Stage>(
         };
 
         // Then, parse it as a name-value item
-        let Some(name) = sub_item.path().word_sym().filter(|s| !s.is_path_segment_keyword()) else {
+        let Some(name) = sub_item.path().word_sym() else {
             cx.emit_err(session_diagnostics::CfgPredicateIdentifier {
                 span: sub_item.path().span(),
             });
diff --git a/compiler/rustc_attr_parsing/src/attributes/cfg_old.rs b/compiler/rustc_attr_parsing/src/attributes/cfg_old.rs
@@ -220,10 +220,7 @@ pub fn eval_condition(
                 }
             }
         }
-        MetaItemKind::Word | MetaItemKind::NameValue(..)
-            if cfg.path.segments.len() != 1
-                || cfg.path.segments[0].ident.is_path_segment_keyword() =>
-        {
+        MetaItemKind::Word | MetaItemKind::NameValue(..) if cfg.path.segments.len() != 1 => {
             dcx.emit_err(session_diagnostics::CfgPredicateIdentifier { span: cfg.path.span });
             true
         }
diff --git a/compiler/rustc_attr_parsing/src/interface.rs b/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;
                         };
diff --git a/compiler/rustc_attr_parsing/src/parser.rs b/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) => {
diff --git a/compiler/rustc_errors/src/emitter.rs b/compiler/rustc_errors/src/emitter.rs
@@ -548,7 +548,7 @@ impl Emitter for FatalOnlyEmitter {
     }
 
     fn emit_diagnostic(&mut self, mut diag: DiagInner, registry: &Registry) {
-        if diag.level == Level::Fatal {
+        if diag.level.is_error() {
             if let Some(fatal_note) = &self.fatal_note {
                 diag.sub(Level::Note, fatal_note.clone(), MultiSpan::new());
             }
diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs
@@ -1998,6 +1998,10 @@ impl Level {
         matches!(*self, FailureNote)
     }
 
+    pub fn is_error(&self) -> bool {
+        matches!(*self, Bug | DelayedBug | Fatal | Error)
+    }
+
     // Can this level be used in a subdiagnostic message?
     fn can_be_subdiag(&self) -> bool {
         match self {
diff --git a/compiler/rustc_expand/src/config.rs b/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 {
diff --git a/compiler/rustc_interface/src/interface.rs b/compiler/rustc_interface/src/interface.rs
@@ -71,27 +71,31 @@ pub(crate) fn parse_cfg(dcx: DiagCtxtHandle<'_>, cfgs: Vec<String>) -> Cfg {
 
             match new_parser_from_source_str(&psess, filename, s.to_string(), StripTokens::Nothing)
             {
-                Ok(mut parser) => match parser.parse_meta_item(AllowLeadingUnsafe::No) {
-                    Ok(meta_item) if parser.token == token::Eof => {
-                        if meta_item.path.segments.len() != 1 {
-                            error!("argument key must be an identifier");
-                        }
-                        match &meta_item.kind {
-                            MetaItemKind::List(..) => {}
-                            MetaItemKind::NameValue(lit) if !lit.kind.is_str() => {
-                                error!("argument value must be a string");
+                Ok(mut parser) => {
+                    parser.parse_cfg_pred = true;
+
+                    match parser.parse_meta_item(AllowLeadingUnsafe::No) {
+                        Ok(meta_item) if parser.token == token::Eof => {
+                            if meta_item.path.segments.len() != 1 {
+                                error!("argument key must be an identifier");
                             }
-                            MetaItemKind::NameValue(..) | MetaItemKind::Word => {
-                                let ident = meta_item.ident().expect("multi-segment cfg key");
-                                return (ident.name, meta_item.value_str());
+                            match &meta_item.kind {
+                                MetaItemKind::List(..) => {}
+                                MetaItemKind::NameValue(lit) if !lit.kind.is_str() => {
+                                    error!("argument value must be a string");
+                                }
+                                MetaItemKind::NameValue(..) | MetaItemKind::Word => {
+                                    let ident = meta_item.ident().expect("multi-segment cfg key");
+                                    return (ident.name, meta_item.value_str());
+                                }
                             }
                         }
+                        Ok(..) => {}
+                        Err(err) => err.cancel(),
                     }
-                    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.
@@ -177,6 +181,7 @@ pub(crate) fn parse_check_cfg(dcx: DiagCtxtHandle<'_>, specs: Vec<String>) -> Ch
                     expected_error();
                 }
             };
+        parser.parse_cfg_pred = true;
 
         let meta_item = match parser.parse_meta_item(AllowLeadingUnsafe::No) {
             Ok(meta_item) if parser.token == token::Eof => meta_item,
diff --git a/compiler/rustc_parse/src/parser/attr.rs b/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))?;
diff --git a/compiler/rustc_parse/src/parser/mod.rs b/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.
diff --git a/compiler/rustc_span/src/symbol.rs b/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?
diff --git a/tests/ui/cfg/path-kw-as-pred.rs b/tests/ui/cfg/path-kw-as-pred.rs
@@ -1,72 +1,76 @@
 //@ edition: 2024
 
+#![allow(unexpected_cfgs)]
+
 macro_rules! foo {
     () => {
-        #[cfg($crate)] //~ ERROR `cfg` predicate key must be an identifier
-        #[cfg_attr($crate, path = "foo")] //~ ERROR `cfg` predicate key must be an identifier
-        mod _x {}
+        #[cfg($crate)] //~ ERROR expected identifier, found reserved identifier `$crate`
+        mod _cfg_dollar_crate {}
+        #[cfg_attr($crate, path = "foo")] //~ ERROR expected identifier, found reserved identifier `$crate`
+        mod _cfg_attr_dollar_crate {}
 
         cfg!($crate); //~ ERROR `cfg` predicate key must be an identifier
     };
 }
 
-#[cfg(crate)] //~ ERROR `cfg` predicate key must be an identifier
-#[cfg(super)] //~ ERROR `cfg` predicate key must be an identifier
-#[cfg(self)] //~ ERROR `cfg` predicate key must be an identifier
-#[cfg(Self)] //~ ERROR `cfg` predicate key must be an identifier
-#[cfg_attr(crate, path = "foo")] //~ ERROR `cfg` predicate key must be an identifier
-#[cfg_attr(super, path = "foo")] //~ ERROR `cfg` predicate key must be an identifier
-#[cfg_attr(self, path = "foo")] //~ ERROR `cfg` predicate key must be an identifier
-#[cfg_attr(Self, path = "foo")] //~ ERROR `cfg` predicate key must be an identifier
-mod _path_kw {}
+#[cfg(crate)] //~ ERROR expected identifier, found keyword `crate`
+mod _cfg_crate {}
+#[cfg(super)] //~ ERROR expected identifier, found keyword `super`
+mod _cfg_super {}
+#[cfg(self)] //~ ERROR expected identifier, found keyword `self`
+mod _cfg_self_lower {}
+#[cfg(Self)] //~ ERROR expected identifier, found keyword `Self`
+mod _cfg_self_upper {}
+#[cfg_attr(crate, path = "foo")] //~ ERROR expected identifier, found keyword `crate`
+mod _cfg_attr_crate {}
+#[cfg_attr(super, path = "foo")] //~ ERROR expected identifier, found keyword `super`
+mod _cfg_attr_super {}
+#[cfg_attr(self, path = "foo")] //~ ERROR expected identifier, found keyword `self`
+mod _cfg_attr_self_lower {}
+#[cfg_attr(Self, path = "foo")] //~ ERROR expected identifier, found keyword `Self`
+mod _cfg_attr_self_upper {}
 
 #[cfg(struct)] //~ ERROR expected identifier, found keyword
-//~^ WARNING unexpected `cfg` condition name
-mod _non_path_kw1 {}
+mod _cfg_struct {}
 #[cfg(enum)] //~ ERROR expected identifier, found keyword
-//~^ WARNING unexpected `cfg` condition name
-mod _non_path_kw2 {}
+mod _cfg_enum {}
 #[cfg(async)] //~ ERROR expected identifier, found keyword
-//~^ WARNING unexpected `cfg` condition name
-mod _non_path_kw3 {}
+mod _cfg_async {}
 #[cfg(impl)] //~ ERROR expected identifier, found keyword
-//~^ WARNING unexpected `cfg` condition name
-mod _non_path_kw4 {}
+mod _cfg_impl {}
 #[cfg(trait)] //~ ERROR expected identifier, found keyword
-//~^ WARNING unexpected `cfg` condition name
-mod _non_path_kw5 {}
+mod _cfg_trait {}
 #[cfg_attr(struct, path = "foo")] //~ ERROR expected identifier, found keyword
-//~^ WARNING unexpected `cfg` condition name
-mod _non_path_kw6 {}
+mod _cfg_attr_struct {}
 #[cfg_attr(enum, path = "foo")] //~ ERROR expected identifier, found keyword
-//~^ WARNING unexpected `cfg` condition name
-mod _non_path_kw7 {}
+mod _cfg_attr_enum {}
 #[cfg_attr(async, path = "foo")] //~ ERROR expected identifier, found keyword
-//~^ WARNING unexpected `cfg` condition name
-mod _non_path_kw8 {}
+mod _cfg_attr_async {}
 #[cfg_attr(impl, path = "foo")] //~ ERROR expected identifier, found keyword
-//~^ WARNING unexpected `cfg` condition name
-mod _non_path_kw9 {}
+mod _cfg_attr_impl {}
 #[cfg_attr(trait, path = "foo")] //~ ERROR expected identifier, found keyword
-//~^ WARNING unexpected `cfg` condition name
-mod _non_path_kw10 {}
+mod _cfg_attr_trait {}
 
 fn main() {
     foo!();
 
-    cfg!(crate); //~ ERROR `cfg` predicate key must be an identifier
-    cfg!(super); //~ ERROR `cfg` predicate key must be an identifier
-    cfg!(self); //~ ERROR `cfg` predicate key must be an identifier
-    cfg!(Self); //~ ERROR `cfg` predicate key must be an identifier
+    cfg!(crate); //~ ERROR expected identifier, found keyword `crate`
+    cfg!(super); //~ ERROR expected identifier, found keyword `super`
+    cfg!(self); //~ ERROR expected identifier, found keyword `self`
+    cfg!(Self); //~ ERROR expected identifier, found keyword `Self`
 
     cfg!(struct); //~ ERROR expected identifier, found keyword
-    //~^ WARNING unexpected `cfg` condition name
     cfg!(enum); //~ ERROR expected identifier, found keyword
-    //~^ WARNING unexpected `cfg` condition name
     cfg!(async); //~ ERROR expected identifier, found keyword
-    //~^ WARNING unexpected `cfg` condition name
     cfg!(impl); //~ ERROR expected identifier, found keyword
-    //~^ WARNING unexpected `cfg` condition name
     cfg!(trait); //~ ERROR expected identifier, found keyword
-    //~^ WARNING unexpected `cfg` condition name
 }
+
+#[cfg(r#crate)] // Ok
+mod _cfg_r_crate {}
+#[cfg(r#super)] // Ok
+mod _cfg_r_super {}
+#[cfg(r#self)] // Ok
+mod _cfg_r_self_lower {}
+#[cfg(r#Self)] // Ok
+mod _cfg_r_self_upper {}
diff --git a/tests/ui/cfg/path-kw-as-pred.stderr b/tests/ui/cfg/path-kw-as-pred.stderr

Original file line number	Diff line number	Diff line change
`@@ -220,10 +220,7 @@ pub fn eval_condition(`
`220`	`220`	`}`
`221`	`221`	`}`
`222`	`222`	`}`
`223`		`- MetaItemKind::Word \| MetaItemKind::NameValue(..)`
`224`		`- if cfg.path.segments.len() != 1`
`225`		`- \|\| cfg.path.segments[0].ident.is_path_segment_keyword() =>`
`226`		`- {`
	`223`	`+ MetaItemKind::Word \| MetaItemKind::NameValue(..) if cfg.path.segments.len() != 1 => {`
`227`	`224`	`dcx.emit_err(session_diagnostics::CfgPredicateIdentifier { span: cfg.path.span });`
`228`	`225`	`true`
`229`	`226`	`}`
Original file line number	Diff line number	Diff line change
`@@ -548,7 +548,7 @@ impl Emitter for FatalOnlyEmitter {`
`548`	`548`	`}`
`549`	`549`
`550`	`550`	`fn emit_diagnostic(&mut self, mut diag: DiagInner, registry: &Registry) {`
`551`		`- if diag.level == Level::Fatal {`
	`551`	`+ if diag.level.is_error() {`
`552`	`552`	`if let Some(fatal_note) = &self.fatal_note {`
`553`	`553`	`diag.sub(Level::Note, fatal_note.clone(), MultiSpan::new());`
`554`	`554`	`}`