Auto merge of #53893 - petrochenkov:cfgexpr, r=pnkfelix

Validate syntax of `cfg` attributes

Fixes https://github.com/rust-lang/rust/issues/53298

2 files changed, 47 insertions, 13 deletions

diff --git a/src/libsyntax/attr/builtin.rs b/src/libsyntax/attr/builtin.rs
index 3eecdf14a4e..5fc9c5578e1 100644
--- a/src/libsyntax/attr/builtin.rs
+++ b/src/libsyntax/attr/builtin.rs
@@ -433,7 +433,21 @@ pub fn cfg_matches(cfg: &ast::MetaItem, sess: &ParseSess, features: Option<&Feat
         if let (Some(feats), Some(gated_cfg)) = (features, GatedCfg::gate(cfg)) {
             gated_cfg.check_and_emit(sess, feats);
         }
-        sess.config.contains(&(cfg.name(), cfg.value_str()))
+        let error = |span, msg| { sess.span_diagnostic.span_err(span, msg); true };
+        if cfg.ident.segments.len() != 1 {
+            return error(cfg.ident.span, "`cfg` predicate key must be an identifier");
+        }
+        match &cfg.node {
+            MetaItemKind::List(..) => {
+                error(cfg.span, "unexpected parentheses after `cfg` predicate key")
+            }
+            MetaItemKind::NameValue(lit) if !lit.node.is_str() => {
+                error(lit.span, "literal in `cfg` predicate value must be a string")
+            }
+            MetaItemKind::NameValue(..) | MetaItemKind::Word => {
+                sess.config.contains(&(cfg.name(), cfg.value_str()))
+            }
+        }
     })
 }
 
diff --git a/src/libsyntax/config.rs b/src/libsyntax/config.rs
index 5233267e3a9..63b70b12248 100644
--- a/src/libsyntax/config.rs
+++ b/src/libsyntax/config.rs
@@ -116,25 +116,45 @@ impl<'a> StripUnconfigured<'a> {
     // Determine if a node with the given attributes should be included in this configuration.
     pub fn in_cfg(&mut self, attrs: &[ast::Attribute]) -> bool {
         attrs.iter().all(|attr| {
-            let mis = if !is_cfg(attr) {
+            if !is_cfg(attr) {
                 return true;
-            } else if let Some(mis) = attr.meta_item_list() {
-                mis
+            }
+
+            let error = |span, msg, suggestion: &str| {
+                let mut err = self.sess.span_diagnostic.struct_span_err(span, msg);
+                if !suggestion.is_empty() {
+                    err.span_suggestion(span, "expected syntax is", suggestion.into());
+                }
+                err.emit();
+                true
+            };
+
+            let meta_item = if let Some(meta_item) = attr.meta() {
+                meta_item
             } else {
-                return true;
+                // Not a well-formed meta-item. Why? We don't know.
+                return error(attr.span, "`cfg` is not a well-formed meta-item",
+                                        "#[cfg(/* predicate */)]");
+            };
+            let nested_meta_items = if let Some(nested_meta_items) = meta_item.meta_item_list() {
+                nested_meta_items
+            } else {
+                return error(meta_item.span, "`cfg` is not followed by parentheses",
+                                             "cfg(/* predicate */)");
             };
 
-            if mis.len() != 1 {
-                self.sess.span_diagnostic.span_err(attr.span, "expected 1 cfg-pattern");
-                return true;
+            if nested_meta_items.is_empty() {
+                return error(meta_item.span, "`cfg` predicate is not specified", "");
+            } else if nested_meta_items.len() > 1 {
+                return error(nested_meta_items.last().unwrap().span,
+                             "multiple `cfg` predicates are specified", "");
             }
 
-            if !mis[0].is_meta_item() {
-                self.sess.span_diagnostic.span_err(mis[0].span, "unexpected literal");
-                return true;
+            match nested_meta_items[0].meta_item() {
+                Some(meta_item) => attr::cfg_matches(meta_item, self.sess, self.features),
+                None => error(nested_meta_items[0].span,
+                              "`cfg` predicate key cannot be a literal", ""),
             }
-
-            attr::cfg_matches(mis[0].meta_item().unwrap(), self.sess, self.features)
         })
     }