allow denying mitigations in earlier editions

Author: Ariel Ben-Yehuda

compiler/rustc_metadata/src/creader.rs

@@ -25,9 +25,10 @@ use rustc_middle::ty::data_structures::IndexSet;
 use rustc_middle::ty::{TyCtxt, TyCtxtFeed};
 use rustc_proc_macro::bridge::client::ProcMacro;
 use rustc_session::Session;
+use rustc_session::config::enforced_mitigations::EnforcedMitigationLevel;
 use rustc_session::config::{
-    CrateType, EnforcedMitigationLevel, ExtendedTargetModifierInfo, ExternLocation, Externs,
-    OptionsTargetModifiers, TargetModifier,
+    CrateType, ExtendedTargetModifierInfo, ExternLocation, Externs, OptionsTargetModifiers,
+    TargetModifier,
 };
 use rustc_session::cstore::{CrateDepKind, CrateSource, ExternCrate, ExternCrateSource};
 use rustc_session::lint::{self, BuiltinLintDiag};
@@ -483,12 +484,9 @@ impl CStore {
 
     pub fn report_incompatible_enforced_mitigations(&self, tcx: TyCtxt<'_>, krate: &Crate) {
         let my_mitigations = tcx.sess.gather_enabled_enforced_mitigations();
-        let mut my_mitigations: BTreeMap<_, _> = my_mitigations
-            .iter()
-            .filter(|mitigation| mitigation.kind.enforced_since() <= tcx.sess.edition())
-            .map(|mitigation| (mitigation.kind, mitigation))
-            .collect();
-        for skipped_mitigation in tcx.sess.opts.allowed_partial_mitigations() {
+        let mut my_mitigations: BTreeMap<_, _> =
+            my_mitigations.iter().map(|mitigation| (mitigation.kind, mitigation)).collect();
+        for skipped_mitigation in tcx.sess.opts.allowed_partial_mitigations(tcx.sess.edition()) {
             my_mitigations.remove(&skipped_mitigation);
         }
         const MAX_ERRORS_PER_MITIGATION: usize = 5;

compiler/rustc_metadata/src/rmeta/decoder.rs

@@ -29,7 +29,8 @@ use rustc_proc_macro::bridge::client::ProcMacro;
 use rustc_serialize::opaque::MemDecoder;
 use rustc_serialize::{Decodable, Decoder};
 use rustc_session::Session;
-use rustc_session::config::{EnforcedMitigation, TargetModifier};
+use rustc_session::config::TargetModifier;
+use rustc_session::config::enforced_mitigations::EnforcedMitigation;
 use rustc_session::cstore::{CrateSource, ExternCrate};
 use rustc_span::hygiene::HygieneDecodeContext;
 use rustc_span::{

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -27,7 +27,8 @@ use rustc_middle::ty::codec::TyEncoder;
 use rustc_middle::ty::fast_reject::{self, TreatParams};
 use rustc_middle::{bug, span_bug};
 use rustc_serialize::{Decodable, Decoder, Encodable, Encoder, opaque};
-use rustc_session::config::{CrateType, EnforcedMitigation, OptLevel, TargetModifier};
+use rustc_session::config::enforced_mitigations::EnforcedMitigation;
+use rustc_session::config::{CrateType, OptLevel, TargetModifier};
 use rustc_span::hygiene::HygieneEncodeContext;
 use rustc_span::{
     ByteSymbol, ExternalSource, FileName, SourceFile, SpanData, SpanEncoder, StableSourceFileId,

compiler/rustc_metadata/src/rmeta/mod.rs

@@ -34,7 +34,8 @@ use rustc_middle::ty::fast_reject::SimplifiedType;
 use rustc_middle::ty::{self, Ty, TyCtxt, UnusedGenericParams};
 use rustc_middle::util::Providers;
 use rustc_serialize::opaque::FileEncoder;
-use rustc_session::config::{EnforcedMitigation, SymbolManglingVersion, TargetModifier};
+use rustc_session::config::enforced_mitigations::EnforcedMitigation;
+use rustc_session::config::{SymbolManglingVersion, TargetModifier};
 use rustc_session::cstore::{CrateDepKind, ForeignModule, LinkagePreference, NativeLib};
 use rustc_span::edition::Edition;
 use rustc_span::hygiene::{ExpnIndex, MacroKind, SyntaxContextKey};

compiler/rustc_metadata/src/rmeta/parameterized.rs

@@ -116,8 +116,8 @@ trivially_parameterized_over_tcx! {
     rustc_middle::ty::Visibility<DefIndex>,
     rustc_middle::ty::adjustment::CoerceUnsizedInfo,
     rustc_middle::ty::fast_reject::SimplifiedType,
-    rustc_session::config::EnforcedMitigation,
     rustc_session::config::TargetModifier,
+    rustc_session::config::enforced_mitigations::EnforcedMitigation,
     rustc_session::cstore::ForeignModule,
     rustc_session::cstore::LinkagePreference,
     rustc_session::cstore::NativeLib,

compiler/rustc_session/src/config.rs

@@ -35,7 +35,6 @@ use rustc_target::spec::{
 use tracing::debug;
 
 pub use crate::config::cfg::{Cfg, CheckCfg, ExpectedValues};
-use crate::config::enforced_mitigations::EnforcedMitigationKind;
 use crate::config::native_libs::parse_native_libs;
 pub use crate::config::print_request::{PrintKind, PrintRequest};
 use crate::errors::FileWriteFail;
@@ -1479,18 +1478,6 @@ impl Options {
     pub fn autodiff_enabled(&self) -> bool {
         self.unstable_opts.autodiff.contains(&AutoDiff::Enable)
     }
-
-    pub fn allowed_partial_mitigations(&self) -> impl Iterator<Item = EnforcedMitigationKind> {
-        let mut result = BTreeSet::default();
-        for mitigation in &self.unstable_opts.allow_partial_mitigations {
-            if mitigation.enabled {
-                result.insert(mitigation.kind);
-            } else {
-                result.remove(&mitigation.kind);
-            }
-        }
-        result.into_iter()
-    }
 }
 
 impl UnstableOptions {

compiler/rustc_session/src/options/enforced_mitigations.rs

@@ -1,10 +1,12 @@
+use std::collections::BTreeSet;
 use std::str::FromStr;
 
 use rustc_macros::{Decodable, Encodable};
 use rustc_span::edition::Edition;
 use rustc_target::spec::StackProtector;
 
 use crate::Session;
+use crate::config::Options;
 use crate::options::CFGuard;
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Encodable, Decodable)]
@@ -120,6 +122,12 @@ macro_rules! enforced_mitigations {
             }
         }
 
+        impl Options {
+            pub fn all_enforced_mitigations(&self) -> impl Iterator<Item = EnforcedMitigationKind> {
+                [$(EnforcedMitigationKind::$name),*].into_iter()
+            }
+        }
+
         impl Session {
             pub fn gather_enabled_enforced_mitigations(&$self) -> Vec<EnforcedMitigation> {
                 let mut mitigations = [
@@ -151,3 +159,24 @@ pub struct EnforcedMitigation {
     pub kind: EnforcedMitigationKind,
     pub level: EnforcedMitigationLevel,
 }
+
+impl Options {
+    // Return the list of mitigations that are allowed to be partial
+    pub fn allowed_partial_mitigations(
+        &self,
+        edition: Edition,
+    ) -> impl Iterator<Item = EnforcedMitigationKind> {
+        let mut result: BTreeSet<_> = self
+            .all_enforced_mitigations()
+            .filter(|mitigation| mitigation.enforced_since() > edition)
+            .collect();
+        for mitigation in &self.unstable_opts.allow_partial_mitigations {
+            if mitigation.enabled {
+                result.insert(mitigation.kind);
+            } else {
+                result.remove(&mitigation.kind);
+            }
+        }
+        result.into_iter()
+    }
+}

tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-current-edition.rs

@@ -0,0 +1,17 @@
+// ignore-tidy-linelength
+//@ check-fail
+//@ ignore-nvptx64 stack protector is not supported
+//@ ignore-wasm32-unknown-unknown stack protector is not supported
+//@ edition: 2024
+//@ compile-flags: -Z allow-partial-mitigations=!control-flow-guard -C control-flow-guard=on
+
+// check that in edition 2024, it is still possible to explicitly
+// disallow partial mitigations (in edition=future, they are
+// disallowed by default)
+
+fn main() {}
+//~^ ERROR that is not protected by
+//~| ERROR that is not protected by
+//~| ERROR that is not protected by
+//~| ERROR that is not protected by
+//~| ERROR that is not protected by

tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-current-edition.stderr

@@ -0,0 +1,32 @@
+error: your program uses the crate `std`, that is not protected by `control-flow-guard`
+  --> $DIR/err-allow-partial-mitigations-current-edition.rs:12:1
+   |
+LL | fn main() {}
+   | ^
+
+error: your program uses the crate `core`, that is not protected by `control-flow-guard`
+  --> $DIR/err-allow-partial-mitigations-current-edition.rs:12:1
+   |
+LL | fn main() {}
+   | ^
+
+error: your program uses the crate `alloc`, that is not protected by `control-flow-guard`
+  --> $DIR/err-allow-partial-mitigations-current-edition.rs:12:1
+   |
+LL | fn main() {}
+   | ^
+
+error: your program uses the crate `compiler_builtins`, that is not protected by `control-flow-guard`
+  --> $DIR/err-allow-partial-mitigations-current-edition.rs:12:1
+   |
+LL | fn main() {}
+   | ^
+
+error: your program uses the crate `libc`, that is not protected by `control-flow-guard`
+  --> $DIR/err-allow-partial-mitigations-current-edition.rs:12:1
+   |
+LL | fn main() {}
+   | ^
+
+error: aborting due to 5 previous errors
+