Warn against cfg(any()) and cfg(all())

Author: jamie-osec

compiler/rustc_attr_parsing/messages.ftl

@@ -233,5 +233,8 @@ attr_parsing_unused_multiple =
     .suggestion = remove this attribute
     .note = attribute also specified here
 
+attr_parsing_use_cfg_boolean_lit = use of empty `cfg({$pred}())`
+    .suggestion = consider using a boolean literal
+
 attr_parsing_whole_archive_needs_static =
     linking modifier `whole-archive` is only compatible with `static` linking kind

compiler/rustc_attr_parsing/src/attributes/cfg.rs

@@ -66,14 +66,32 @@ pub fn parse_cfg_entry<S: Stage>(
                     };
                     CfgEntry::Not(Box::new(parse_cfg_entry(cx, single)?), list.span)
                 }
-                Some(sym::any) => CfgEntry::Any(
-                    list.mixed().flat_map(|sub_item| parse_cfg_entry(cx, sub_item)).collect(),
-                    list.span,
-                ),
-                Some(sym::all) => CfgEntry::All(
-                    list.mixed().flat_map(|sub_item| parse_cfg_entry(cx, sub_item)).collect(),
-                    list.span,
-                ),
+                Some(sym::any) => {
+                    if list.is_empty() {
+                        cx.emit_warn(session_diagnostics::UseCfgBooleanLit {
+                            span: meta.span(),
+                            lit: false,
+                            pred: sym::any,
+                        });
+                    }
+                    CfgEntry::Any(
+                        list.mixed().flat_map(|sub_item| parse_cfg_entry(cx, sub_item)).collect(),
+                        list.span,
+                    )
+                }
+                Some(sym::all) => {
+                    if list.is_empty() {
+                        cx.emit_warn(session_diagnostics::UseCfgBooleanLit {
+                            span: meta.span(),
+                            lit: true,
+                            pred: sym::all,
+                        });
+                    }
+                    CfgEntry::All(
+                        list.mixed().flat_map(|sub_item| parse_cfg_entry(cx, sub_item)).collect(),
+                        list.span,
+                    )
+                }
                 Some(sym::target) => parse_cfg_entry_target(cx, list, meta.span())?,
                 Some(sym::version) => parse_cfg_entry_version(cx, list, meta.span())?,
                 _ => {

compiler/rustc_attr_parsing/src/attributes/cfg_old.rs

@@ -165,16 +165,32 @@ pub fn eval_condition(
             // The unwraps below may look dangerous, but we've already asserted
             // that they won't fail with the loop above.
             match cfg.name() {
-                Some(sym::any) => mis
-                    .iter()
-                    // We don't use any() here, because we want to evaluate all cfg condition
-                    // as eval_condition can (and does) extra checks
-                    .fold(false, |res, mi| res | eval_condition(mi, sess, features, eval)),
-                Some(sym::all) => mis
-                    .iter()
-                    // We don't use all() here, because we want to evaluate all cfg condition
-                    // as eval_condition can (and does) extra checks
-                    .fold(true, |res, mi| res & eval_condition(mi, sess, features, eval)),
+                Some(sym::any) => {
+                    if mis.is_empty() {
+                        dcx.emit_warn(session_diagnostics::UseCfgBooleanLit {
+                            span: cfg.span,
+                            lit: false,
+                            pred: sym::any,
+                        });
+                    }
+                    mis.iter()
+                        // We don't use any() here, because we want to evaluate all cfg condition
+                        // as eval_condition can (and does) extra checks
+                        .fold(false, |res, mi| res | eval_condition(mi, sess, features, eval))
+                }
+                Some(sym::all) => {
+                    if mis.is_empty() {
+                        dcx.emit_warn(session_diagnostics::UseCfgBooleanLit {
+                            span: cfg.span,
+                            lit: true,
+                            pred: sym::all,
+                        });
+                    }
+                    mis.iter()
+                        // We don't use all() here, because we want to evaluate all cfg condition
+                        // as eval_condition can (and does) extra checks
+                        .fold(true, |res, mi| res & eval_condition(mi, sess, features, eval))
+                }
                 Some(sym::not) => {
                     let [mi] = mis.as_slice() else {
                         dcx.emit_err(session_diagnostics::ExpectedOneCfgPattern { span: cfg.span });

compiler/rustc_attr_parsing/src/context.rs

@@ -271,6 +271,8 @@ pub trait Stage: Sized + 'static + Sealed {
 
     fn parsers() -> &'static GroupType<Self>;
 
+    fn emit_warn<'sess>(&self, sess: &'sess Session, diag: impl for<'x> Diagnostic<'x, ()>);
+
     fn emit_err<'sess>(
         &self,
         sess: &'sess Session,
@@ -298,6 +300,10 @@ impl Stage for Early {
         self.should_emit().emit_err(sess.dcx().create_err(diag))
     }
 
+    fn emit_warn<'sess>(&self, sess: &'sess Session, diag: impl for<'x> Diagnostic<'x, ()>) {
+        sess.dcx().emit_warn(diag);
+    }
+
     fn should_emit(&self) -> ShouldEmit {
         self.emit_errors
     }
@@ -323,6 +329,10 @@ impl Stage for Late {
         tcx.dcx().emit_err(diag)
     }
 
+    fn emit_warn<'sess>(&self, tcx: &'sess Session, diag: impl for<'x> Diagnostic<'x, ()>) {
+        tcx.dcx().emit_warn(diag);
+    }
+
     fn should_emit(&self) -> ShouldEmit {
         ShouldEmit::ErrorsAndLints
     }
@@ -375,6 +385,10 @@ pub struct AcceptContext<'f, 'sess, S: Stage> {
 }
 
 impl<'f, 'sess: 'f, S: Stage> SharedContext<'f, 'sess, S> {
+    pub(crate) fn emit_warn(&self, diag: impl for<'x> Diagnostic<'x, ()>) {
+        self.stage.emit_warn(&self.sess, diag)
+    }
+
     pub(crate) fn emit_err(&self, diag: impl for<'x> Diagnostic<'x>) -> ErrorGuaranteed {
         self.stage.emit_err(&self.sess, diag)
     }

compiler/rustc_attr_parsing/src/session_diagnostics.rs

@@ -538,6 +538,16 @@ pub(crate) struct NakedFunctionIncompatibleAttribute {
     pub attr: String,
 }
 
+#[derive(Diagnostic)]
+#[diag(attr_parsing_use_cfg_boolean_lit)]
+pub(crate) struct UseCfgBooleanLit {
+    #[primary_span]
+    #[suggestion(code = "{lit}")]
+    pub span: Span,
+    pub lit: bool,
+    pub pred: Symbol,
+}
+
 #[derive(Diagnostic)]
 #[diag(attr_parsing_link_ordinal_out_of_range)]
 #[note]

tests/ui/attributes/unsafe/cfg-unsafe-attributes.rs

@@ -1,6 +1,6 @@
 //@ build-pass
 
-#[cfg_attr(all(), unsafe(no_mangle))]
+#[cfg_attr(true, unsafe(no_mangle))]
 fn a() {}
 
 fn main() {}

tests/ui/cfg/conditional-compilation-struct-11085.rs

@@ -11,7 +11,7 @@ struct Foo {
 }
 
 struct Foo2 {
-    #[cfg(all())]
+    #[cfg(true)]
     foo: isize,
 }
 

tests/ui/cfg/conditional-compile.rs

@@ -151,5 +151,5 @@ mod test_methods {
     }
 }
 
-#[cfg(any())]
+#[cfg(false)]
 mod nonexistent_file; // Check that unconfigured non-inline modules are not loaded or parsed.

tests/ui/cfg/empty-any-all.rs

@@ -0,0 +1,9 @@
+//! Check that we suggest `cfg(any())` -> `false` and `cfg(all())` -> true
+//@ check-pass
+
+#[cfg(any())]  //~ WARN: use of empty `cfg(any())`
+struct A;
+#[cfg(all())]  //~ WARN: use of empty `cfg(all())`
+struct B;
+
+fn main() {}

tests/ui/cfg/empty-any-all.stderr

@@ -0,0 +1,14 @@
+warning: use of empty `cfg(any())`
+  --> $DIR/empty-any-all.rs:4:7
+   |
+LL | #[cfg(any())]
+   |       ^^^^^ help: consider using a boolean literal: `false`
+
+warning: use of empty `cfg(all())`
+  --> $DIR/empty-any-all.rs:6:7
+   |
+LL | #[cfg(all())]
+   |       ^^^^^ help: consider using a boolean literal: `true`
+
+warning: 2 warnings emitted
+