update check_unstable_variants's handling of -C linker-features=[-+]lld

- separate enabling and disabling the feature in the error
- add both polarities to the dedicated test
- update documentation and precondition

Author: lqd

compiler/rustc_session/src/config.rs

@@ -451,32 +451,41 @@ impl LinkerFeaturesCli {
         }
     }
 
-    /// Checks usage of unstable variants for linker features for the given `target_tuple`.
-    /// Returns `Ok` if no unstable variants are used.
+    /// When *not* using `-Z unstable-options` on the CLI, ensure only stable linker features are
+    /// used, for the given `TargetTuple`. Returns `Ok` if no unstable variants are used.
+    /// The caller should ensure that e.g. `nightly_options::is_unstable_enabled()`
+    /// returns false.
     pub(crate) fn check_unstable_variants(&self, target_tuple: &TargetTuple) -> Result<(), String> {
-        let mentioned_features = self.enabled.union(self.disabled);
-        let has_lld = mentioned_features.is_lld_enabled();
-
-        // Check that -Clinker-features=[-+]lld is not used anywhere else than on x64
-        // without -Zunstable-options.
-        if has_lld && target_tuple.tuple() != "x86_64-unknown-linux-gnu" {
+        // `-C linker-features=[-+]lld` is only stable on x64 linux.
+        let check_lld = |features: LinkerFeatures, polarity: &str| {
+            let has_lld = features.is_lld_enabled();
+            if has_lld && target_tuple.tuple() != "x86_64-unknown-linux-gnu" {
+                return Err(format!(
+                    "`-C linker-features={polarity}lld` is unstable on the `{target_tuple}` \
+                    target. The `-Z unstable-options` flag must also be passed to use it on this target",
+                ));
+            }
+            Ok(())
+        };
+        check_lld(self.enabled, "+")?;
+        check_lld(self.disabled, "-")?;
+
+        // Since only lld is stable, any non-lld feature used is unstable, and that's an error.
+        let unstable_enabled = self.enabled - LinkerFeatures::LLD;
+        let unstable_disabled = self.disabled - LinkerFeatures::LLD;
+        if !unstable_enabled.union(unstable_disabled).is_empty() {
+            let unstable_features: Vec<_> = unstable_enabled
+                .iter()
+                .map(|f| format!("+{}", f.as_str().unwrap()))
+                .chain(unstable_disabled.iter().map(|f| format!("-{}", f.as_str().unwrap())))
+                .collect();
             return Err(format!(
-                "`-C linker-features` with lld are unstable for the `{target_tuple}` target, \
-the `-Z unstable-options` flag must also be passed to use it on this target",
+                "the requested `-C linker-features={}` are unstable, and also require the \
+                `-Z unstable-options` flag to be usable",
+                unstable_features.join(","),
             ));
         }
 
-        for feature in LinkerFeatures::all() {
-            // Check that no other features were enabled without -Zunstable-options
-            // Note that this should currently be unreachable, because the `-Clinker-features` parser
-            // currently only accepts lld.
-            if feature != LinkerFeatures::LLD && mentioned_features.contains(feature) {
-                return Err("`-C linker-features` is stable only for the lld feature, \
-the`-Z unstable-options` flag must also be passed to use it with other features"
-                    .to_string());
-            }
-        }
-
         Ok(())
     }
 }

compiler/rustc_target/src/spec/mod.rs

@@ -761,6 +761,17 @@ impl LinkerFeatures {
         })
     }
 
+    /// Return the linker feature name, as would be passed on the CLI.
+    ///
+    /// Returns `None` if the bitflags aren't a singular component (but a mix of multiple flags).
+    pub fn as_str(self) -> Option<&'static str> {
+        Some(match self {
+            LinkerFeatures::CC => "cc",
+            LinkerFeatures::LLD => "lld",
+            _ => return None,
+        })
+    }
+
     /// Returns whether the `lld` linker feature is enabled.
     pub fn is_lld_enabled(self) -> bool {
         self.contains(LinkerFeatures::LLD)

tests/ui/linking/linker-features-lld-disallowed-target.negative.stderr

@@ -0,0 +1,2 @@
+error: `-C linker-features=-lld` is unstable on the `x86_64-unknown-linux-musl` target. The `-Z unstable-options` flag must also be passed to use it on this target
+

tests/ui/linking/linker-features-lld-disallowed-target.positive.stderr

@@ -0,0 +1,2 @@
+error: `-C linker-features=+lld` is unstable on the `x86_64-unknown-linux-musl` target. The `-Z unstable-options` flag must also be passed to use it on this target
+

tests/ui/linking/linker-features-lld-disallowed-target.rs

@@ -1,11 +1,16 @@
 // Check that `-C linker-features=[+-]lld` is only stable on x64 linux, and needs `-Z
 // unstable-options` elsewhere.
-//
-//@ check-fail
-//@ compile-flags: --target=x86_64-unknown-linux-musl -C linker-features=-lld --crate-type=rlib
-//@ needs-llvm-components: x86
+
+// ignore-tidy-linelength
+
+//@ revisions: positive negative
+//@ [negative] compile-flags: --target=x86_64-unknown-linux-musl -C linker-features=-lld --crate-type=rlib
+//@ [negative] needs-llvm-components: x86
+//@ [positive] compile-flags: --target=x86_64-unknown-linux-musl -C linker-features=+lld --crate-type=rlib
+//@ [positive] needs-llvm-components: x86
 
 #![feature(no_core)]
 #![no_core]
 
-//~? ERROR `-C linker-features` with lld are unstable for the `x86_64-unknown-linux-musl` target, the `-Z unstable-options` flag must also be passed to use it on this target
+//[negative]~? ERROR `-C linker-features=-lld` is unstable on the `x86_64-unknown-linux-musl` target. The `-Z unstable-options` flag must also be passed to use it on this target
+//[positive]~? ERROR `-C linker-features=+lld` is unstable on the `x86_64-unknown-linux-musl` target. The `-Z unstable-options` flag must also be passed to use it on this target