fix(lints): Switch to -Zlints so stable projects can experiment

In rust-lang#12115, we explored how we can let stable projects
experiment with `[lints]` to provide feedback.  What we settled on is
switching from the `cargo-features` manifest key to the `-Z` flag as
`cargo-features` always requires nightly while `-Z` only requires it
when being passed in.  This means a project can have a `[lints]` table
and have CI / contributors run `cargo +nightly check -Zlints` when they
care about warnings.

src/cargo/core/features.rs

@@ -483,9 +483,6 @@ features! {
 
     // Allow specifying rustflags directly in a profile
     (stable, workspace_inheritance, "1.64", "reference/unstable.html#workspace-inheritance"),
-
-    // Allow specifying rustflags directly in a profile
-    (unstable, lints, "", "reference/unstable.html#lints"),
 }
 
 pub struct Feature {
@@ -734,6 +731,7 @@ unstable_cli_options!(
     skip_rustdoc_fingerprint: bool = (HIDDEN),
     rustdoc_scrape_examples: bool = ("Allows Rustdoc to scrape code examples from reverse-dependencies"),
     msrv_policy: bool = ("Enable rust-version aware policy within cargo"),
+    lints: bool = ("Pass `[lints]` to the linting tools"),
 );
 
 const STABILIZED_COMPILE_PROGRESS: &str = "The progress bar is now always \
@@ -1097,6 +1095,7 @@ impl CliUnstable {
             "codegen-backend" => self.codegen_backend = parse_empty(k, v)?,
             "profile-rustflags" => self.profile_rustflags = parse_empty(k, v)?,
             "msrv-policy" => self.msrv_policy = parse_empty(k, v)?,
+            "lints" => self.lints = parse_empty(k, v)?,
             _ => bail!("unknown `-Z` flag specified: {}", k),
         }
 

src/cargo/util/toml/mod.rs

@@ -2045,12 +2045,7 @@ impl TomlManifest {
                 let mut inheritable = toml_config.package.clone().unwrap_or_default();
                 inheritable.update_ws_path(package_root.to_path_buf());
                 inheritable.update_deps(toml_config.dependencies.clone());
-                let lints = parse_unstable_lints(
-                    toml_config.lints.clone(),
-                    &features,
-                    config,
-                    &mut warnings,
-                )?;
+                let lints = parse_unstable_lints(toml_config.lints.clone(), config, &mut warnings)?;
                 let lints = verify_lints(lints)?;
                 inheritable.update_lints(lints);
                 if let Some(ws_deps) = &inheritable.dependencies {
@@ -2316,14 +2311,10 @@ impl TomlManifest {
             &inherit_cell,
         )?;
 
-        let lints = parse_unstable_lints::<MaybeWorkspaceLints>(
-            me.lints.clone(),
-            &features,
-            config,
-            cx.warnings,
-        )?
-        .map(|mw| mw.resolve("lints", || inherit()?.lints()))
-        .transpose()?;
+        let lints =
+            parse_unstable_lints::<MaybeWorkspaceLints>(me.lints.clone(), config, cx.warnings)?
+                .map(|mw| mw.resolve("lints", || inherit()?.lints()))
+                .transpose()?;
         let lints = verify_lints(lints)?;
         let default = TomlLints::default();
         let rustflags = lints_to_rustflags(lints.as_ref().unwrap_or(&default));
@@ -2757,12 +2748,7 @@ impl TomlManifest {
                 let mut inheritable = toml_config.package.clone().unwrap_or_default();
                 inheritable.update_ws_path(root.to_path_buf());
                 inheritable.update_deps(toml_config.dependencies.clone());
-                let lints = parse_unstable_lints(
-                    toml_config.lints.clone(),
-                    &features,
-                    config,
-                    &mut warnings,
-                )?;
+                let lints = parse_unstable_lints(toml_config.lints.clone(), config, &mut warnings)?;
                 let lints = verify_lints(lints)?;
                 inheritable.update_lints(lints);
                 let ws_root_config = WorkspaceRootConfig::new(
@@ -2911,44 +2897,46 @@ impl TomlManifest {
 
 fn parse_unstable_lints<T: Deserialize<'static>>(
     lints: Option<toml::Value>,
-    features: &Features,
     config: &Config,
     warnings: &mut Vec<String>,
 ) -> CargoResult<Option<T>> {
     let Some(lints) = lints else { return Ok(None); };
 
-    if !features.is_enabled(Feature::lints()) {
-        warn_for_feature("lints", config, warnings);
+    if !config.cli_unstable().lints {
+        warn_for_lint_feature(config, warnings);
         return Ok(None);
     }
 
     lints.try_into().map(Some).map_err(|err| err.into())
 }
 
-fn warn_for_feature(name: &str, config: &Config, warnings: &mut Vec<String>) {
+fn warn_for_lint_feature(config: &Config, warnings: &mut Vec<String>) {
     use std::fmt::Write as _;
 
+    let key_name = "lints";
+    let feature_name = "lints";
+
     let mut message = String::new();
 
     let _ = write!(
         message,
-        "feature `{name}` is not supported on this version of Cargo and will be ignored"
+        "unused manifest key `{key_name}` (may be supported in a future version)"
     );
     if config.nightly_features_allowed {
         let _ = write!(
             message,
             "
 
-consider adding `cargo-features = [\"{name}\"]` to the manifest"
+consider passing `-Z{feature_name}` to enable this feature."
         );
     } else {
         let _ = write!(
             message,
             "
 
 this Cargo does not support nightly features, but if you
-switch to nightly channel you can add
-`cargo-features = [\"{name}\"]` to enable this feature",
+switch to nightly channel you can pass
+`-Z{feature_name}` to enable this feature.",
         );
     }
     warnings.push(message);