Emit error when using path-segment keyword as cfg pred

Author: mu001999

compiler/rustc_attr_parsing/src/attributes/cfg.rs

@@ -83,7 +83,8 @@ pub(crate) fn parse_cfg_entry<S: Stage>(
                 }
             },
             a @ (ArgParser::NoArgs | ArgParser::NameValue(_)) => {
-                let Some(name) = meta.path().word_sym() else {
+                let Some(name) = meta.path().word_sym().filter(|s| !s.is_path_segment_keyword())
+                else {
                     cx.expected_identifier(meta.path().span());
                     return None;
                 };
@@ -160,7 +161,7 @@ fn parse_cfg_entry_target<S: Stage>(
         };
 
         // Then, parse it as a name-value item
-        let Some(name) = sub_item.path().word_sym() else {
+        let Some(name) = sub_item.path().word_sym().filter(|s| !s.is_path_segment_keyword()) else {
             cx.expected_identifier(sub_item.path().span());
             return None;
         };

compiler/rustc_attr_parsing/src/attributes/cfg_old.rs

@@ -220,7 +220,10 @@ pub fn eval_condition(
                 }
             }
         }
-        MetaItemKind::Word | MetaItemKind::NameValue(..) if cfg.path.segments.len() != 1 => {
+        MetaItemKind::Word | MetaItemKind::NameValue(..)
+            if cfg.path.segments.len() != 1
+                || cfg.path.segments[0].ident.is_path_segment_keyword() =>
+        {
             dcx.emit_err(session_diagnostics::CfgPredicateIdentifier { span: cfg.path.span });
             true
         }

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(),

tests/codegen-llvm/cf-protection.rs

@@ -1,12 +1,12 @@
 // Test that the correct module flags are emitted with different control-flow protection flags.
 
 //@ add-core-stubs
-//@ revisions: undefined none branch return full
+//@ revisions: undefined none branch return_ full
 //@ needs-llvm-components: x86
 // [undefined] no extra compile-flags
 //@ [none] compile-flags: -Z cf-protection=none
 //@ [branch] compile-flags: -Z cf-protection=branch
-//@ [return] compile-flags: -Z cf-protection=return
+//@ [return_] compile-flags: -Z cf-protection=return
 //@ [full] compile-flags: -Z cf-protection=full
 //@ compile-flags: --target x86_64-unknown-linux-gnu
 
@@ -30,9 +30,9 @@ pub fn test() {}
 // branch: !"cf-protection-branch", i32 1
 // branch-NOT: !"cf-protection-return"
 
-// return-NOT: !"cf-protection-branch"
-// return: !"cf-protection-return", i32 1
-// return-NOT: !"cf-protection-branch"
+// return_-NOT: !"cf-protection-branch"
+// return_: !"cf-protection-return", i32 1
+// return_-NOT: !"cf-protection-branch"
 
 // full: !"cf-protection-branch", i32 1
 // full: !"cf-protection-return", i32 1

tests/ui/cfg/cmdline-false.rs

@@ -1,5 +1,5 @@
 /// Test that `--cfg false` doesn't cause `cfg(false)` to evaluate to `true`
-//@ compile-flags: --cfg false
+//@ compile-flags: --cfg r#false
 
 #[cfg(false)]
 fn foo() {}

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

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

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

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

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

@@ -0,0 +1,2 @@
+error: invalid `--cfg` argument: `r#crate` (argument key must be an identifier, but `crate` cannot be a raw identifier)
+

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

@@ -0,0 +1,2 @@
+error: invalid `--cfg` argument: `r#self` (argument key must be an identifier, but `self` cannot be a raw identifier)
+

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

@@ -0,0 +1,2 @@
+error: invalid `--cfg` argument: `r#Self` (argument key must be an identifier, but `Self` cannot be a raw identifier)
+