EnforcableMitigation => DeniedPartialMitigation

Ariel Ben-Yehuda · Ariel Ben-Yehuda · commit fc6f81c7e5ca · 2025-12-10T21:48:01.000Z
diff --git a/compiler/rustc_metadata/src/creader.rs b/compiler/rustc_metadata/src/creader.rs
@@ -25,7 +25,7 @@ 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::enforcable_mitigations::EnforcableMitigationLevel;
+use rustc_session::config::enforcable_mitigations::DeniedPartialMitigationLevel;
 use rustc_session::config::{
     CrateType, ExtendedTargetModifierInfo, ExternLocation, Externs, OptionsTargetModifiers,
     TargetModifier,
@@ -458,7 +458,7 @@ impl CStore {
 
     pub fn report_session_incompatibilities(&self, tcx: TyCtxt<'_>, krate: &Crate) {
         self.report_incompatible_target_modifiers(tcx, krate);
-        self.report_incompatible_enforcable_mitigations(tcx, krate);
+        self.report_incompatible_denied_partial_mitigations(tcx, krate);
         self.report_incompatible_async_drop_feature(tcx, krate);
     }
 
@@ -483,8 +483,8 @@ impl CStore {
         }
     }
 
-    pub fn report_incompatible_enforcable_mitigations(&self, tcx: TyCtxt<'_>, krate: &Crate) {
-        let my_mitigations = tcx.sess.gather_enabled_enforcable_mitigations();
+    pub fn report_incompatible_denied_partial_mitigations(&self, tcx: TyCtxt<'_>, krate: &Crate) {
+        let my_mitigations = tcx.sess.gather_enabled_denied_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()) {
@@ -496,12 +496,12 @@ impl CStore {
             if data.is_proc_macro_crate() {
                 continue;
             }
-            let their_mitigations = data.enabled_enforcable_mitigations();
+            let their_mitigations = data.enabled_denied_partial_mitigations();
             for my_mitigation in my_mitigations.values() {
                 let their_mitigation = their_mitigations
                     .iter()
                     .find(|mitigation| mitigation.kind == my_mitigation.kind)
-                    .map_or(EnforcableMitigationLevel::Enabled(false), |m| m.level);
+                    .map_or(DeniedPartialMitigationLevel::Enabled(false), |m| m.level);
                 if their_mitigation < my_mitigation.level {
                     let errors = errors_per_mitigation.entry(my_mitigation.kind).or_insert(0);
                     if *errors >= MAX_ERRORS_PER_MITIGATION {
diff --git a/compiler/rustc_metadata/src/rmeta/decoder.rs b/compiler/rustc_metadata/src/rmeta/decoder.rs
@@ -30,7 +30,7 @@ use rustc_proc_macro::bridge::client::ProcMacro;
 use rustc_serialize::opaque::MemDecoder;
 use rustc_serialize::{Decodable, Decoder};
 use rustc_session::config::TargetModifier;
-use rustc_session::config::enforcable_mitigations::EnforcableMitigation;
+use rustc_session::config::enforcable_mitigations::DeniedPartialMitigation;
 use rustc_session::cstore::{CrateSource, ExternCrate};
 use rustc_span::hygiene::HygieneDecodeContext;
 use rustc_span::{
@@ -82,7 +82,7 @@ pub(crate) type CrateNumMap = IndexVec<CrateNum, CrateNum>;
 pub(crate) type TargetModifiers = Vec<TargetModifier>;
 
 /// The set of enforcable mitigations (RFC 3855) that are currently enabled for this crate
-pub(crate) type EnforcableMitigations = Vec<EnforcableMitigation>;
+pub(crate) type DeniedPartialMitigations = Vec<DeniedPartialMitigation>;
 
 pub(crate) struct CrateMetadata {
     /// The primary crate data - binary metadata blob.
@@ -965,11 +965,11 @@ impl CrateRoot {
         self.target_modifiers.decode(metadata)
     }
 
-    pub(crate) fn decode_enforcable_mitigations<'a>(
+    pub(crate) fn decode_denied_partial_mitigations<'a>(
         &self,
         metadata: &'a MetadataBlob,
-    ) -> impl ExactSizeIterator<Item = EnforcableMitigation> {
-        self.enforcable_mitigations.decode(metadata)
+    ) -> impl ExactSizeIterator<Item = DeniedPartialMitigation> {
+        self.denied_partial_mitigations.decode(metadata)
     }
 }
 
@@ -1959,8 +1959,8 @@ impl CrateMetadata {
         self.root.decode_target_modifiers(&self.blob).collect()
     }
 
-    pub(crate) fn enabled_enforcable_mitigations(&self) -> EnforcableMitigations {
-        self.root.decode_enforcable_mitigations(&self.blob).collect()
+    pub(crate) fn enabled_denied_partial_mitigations(&self) -> DeniedPartialMitigations {
+        self.root.decode_denied_partial_mitigations(&self.blob).collect()
     }
 
     /// Keep `new_extern_crate` if it looks better in diagnostics
diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs
@@ -27,7 +27,7 @@ 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::enforcable_mitigations::EnforcableMitigation;
+use rustc_session::config::enforcable_mitigations::DeniedPartialMitigation;
 use rustc_session::config::{CrateType, OptLevel, TargetModifier};
 use rustc_span::hygiene::HygieneEncodeContext;
 use rustc_span::{
@@ -716,8 +716,8 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         // `SourceFiles` we actually need to encode.
         let source_map = stat!("source-map", || self.encode_source_map());
         let target_modifiers = stat!("target-modifiers", || self.encode_target_modifiers());
-        let enforcable_mitigations =
-            stat!("enforced-mitigations", || self.encode_enabled_enforcable_mitigations());
+        let denied_partial_mitigations =
+            stat!("enforced-mitigations", || self.encode_enabled_denied_partial_mitigations());
 
         let root = stat!("final", || {
             let attrs = tcx.hir_krate_attrs();
@@ -763,7 +763,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                 foreign_modules,
                 source_map,
                 target_modifiers,
-                enforcable_mitigations,
+                denied_partial_mitigations,
                 traits,
                 impls,
                 incoherent_impls,
@@ -2098,10 +2098,10 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         self.lazy_array(tcx.sess.opts.gather_target_modifiers())
     }
 
-    fn encode_enabled_enforcable_mitigations(&mut self) -> LazyArray<EnforcableMitigation> {
+    fn encode_enabled_denied_partial_mitigations(&mut self) -> LazyArray<DeniedPartialMitigation> {
         empty_proc_macro!(self);
         let tcx = self.tcx;
-        self.lazy_array(tcx.sess.gather_enabled_enforcable_mitigations())
+        self.lazy_array(tcx.sess.gather_enabled_denied_partial_mitigations())
     }
 
     fn encode_lib_features(&mut self) -> LazyArray<(Symbol, FeatureStability)> {
diff --git a/compiler/rustc_metadata/src/rmeta/mod.rs b/compiler/rustc_metadata/src/rmeta/mod.rs
@@ -34,7 +34,7 @@ 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::enforcable_mitigations::EnforcableMitigation;
+use rustc_session::config::enforcable_mitigations::DeniedPartialMitigation;
 use rustc_session::config::{SymbolManglingVersion, TargetModifier};
 use rustc_session::cstore::{CrateDepKind, ForeignModule, LinkagePreference, NativeLib};
 use rustc_span::edition::Edition;
@@ -284,7 +284,7 @@ pub(crate) struct CrateRoot {
 
     source_map: LazyTable<u32, Option<LazyValue<rustc_span::SourceFile>>>,
     target_modifiers: LazyArray<TargetModifier>,
-    enforcable_mitigations: LazyArray<EnforcableMitigation>,
+    denied_partial_mitigations: LazyArray<DeniedPartialMitigation>,
 
     compiler_builtins: bool,
     needs_allocator: bool,
diff --git a/compiler/rustc_metadata/src/rmeta/parameterized.rs b/compiler/rustc_metadata/src/rmeta/parameterized.rs
@@ -118,7 +118,7 @@ trivially_parameterized_over_tcx! {
     rustc_middle::ty::adjustment::CoerceUnsizedInfo,
     rustc_middle::ty::fast_reject::SimplifiedType,
     rustc_session::config::TargetModifier,
-    rustc_session::config::enforcable_mitigations::EnforcableMitigation,
+    rustc_session::config::enforcable_mitigations::DeniedPartialMitigation,
     rustc_session::cstore::ForeignModule,
     rustc_session::cstore::LinkagePreference,
     rustc_session::cstore::NativeLib,
diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs
@@ -883,7 +883,7 @@ mod desc {
         "either a boolean (`yes`, `no`, `on`, `off`, etc), or `nll` (default: `nll`)";
     pub(crate) const parse_align: &str = "a number that is a power of 2 between 1 and 2^29";
     pub(crate) const parse_allow_partial_mitigations: &str =
-        super::enforcable_mitigations::EnforcableMitigationKind::KINDS;
+        super::enforcable_mitigations::DeniedPartialMitigationKind::KINDS;
 }
 
 pub mod parse {
diff --git a/compiler/rustc_session/src/options/enforcable_mitigations.rs b/compiler/rustc_session/src/options/enforcable_mitigations.rs
@@ -10,66 +10,66 @@ use crate::config::Options;
 use crate::options::CFGuard;
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Encodable, BlobDecodable)]
-pub enum EnforcableMitigationLevel {
+pub enum DeniedPartialMitigationLevel {
     // Enabled(false) should be the bottom of the Ord hierarchy
     Enabled(bool),
     StackProtector(StackProtector),
 }
 
-impl EnforcableMitigationLevel {
+impl DeniedPartialMitigationLevel {
     pub fn level_str(&self) -> &'static str {
         match self {
-            EnforcableMitigationLevel::StackProtector(StackProtector::All) => "=all",
-            EnforcableMitigationLevel::StackProtector(StackProtector::Basic) => "=basic",
-            EnforcableMitigationLevel::StackProtector(StackProtector::Strong) => "=strong",
+            DeniedPartialMitigationLevel::StackProtector(StackProtector::All) => "=all",
+            DeniedPartialMitigationLevel::StackProtector(StackProtector::Basic) => "=basic",
+            DeniedPartialMitigationLevel::StackProtector(StackProtector::Strong) => "=strong",
             // currently `=disabled` should not appear
-            EnforcableMitigationLevel::Enabled(false) => "=disabled",
-            EnforcableMitigationLevel::StackProtector(StackProtector::None)
-            | EnforcableMitigationLevel::Enabled(true) => "",
+            DeniedPartialMitigationLevel::Enabled(false) => "=disabled",
+            DeniedPartialMitigationLevel::StackProtector(StackProtector::None)
+            | DeniedPartialMitigationLevel::Enabled(true) => "",
         }
     }
 }
 
-impl std::fmt::Display for EnforcableMitigationLevel {
+impl std::fmt::Display for DeniedPartialMitigationLevel {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            EnforcableMitigationLevel::StackProtector(StackProtector::All) => {
+            DeniedPartialMitigationLevel::StackProtector(StackProtector::All) => {
                 write!(f, "all")
             }
-            EnforcableMitigationLevel::StackProtector(StackProtector::Basic) => {
+            DeniedPartialMitigationLevel::StackProtector(StackProtector::Basic) => {
                 write!(f, "basic")
             }
-            EnforcableMitigationLevel::StackProtector(StackProtector::Strong) => {
+            DeniedPartialMitigationLevel::StackProtector(StackProtector::Strong) => {
                 write!(f, "strong")
             }
-            EnforcableMitigationLevel::Enabled(true) => {
+            DeniedPartialMitigationLevel::Enabled(true) => {
                 write!(f, "enabled")
             }
-            EnforcableMitigationLevel::StackProtector(StackProtector::None)
-            | EnforcableMitigationLevel::Enabled(false) => {
+            DeniedPartialMitigationLevel::StackProtector(StackProtector::None)
+            | DeniedPartialMitigationLevel::Enabled(false) => {
                 write!(f, "disabled")
             }
         }
     }
 }
 
-impl From<bool> for EnforcableMitigationLevel {
+impl From<bool> for DeniedPartialMitigationLevel {
     fn from(value: bool) -> Self {
-        EnforcableMitigationLevel::Enabled(value)
+        DeniedPartialMitigationLevel::Enabled(value)
     }
 }
 
-impl From<StackProtector> for EnforcableMitigationLevel {
+impl From<StackProtector> for DeniedPartialMitigationLevel {
     fn from(value: StackProtector) -> Self {
-        EnforcableMitigationLevel::StackProtector(value)
+        DeniedPartialMitigationLevel::StackProtector(value)
     }
 }
 
-pub struct EnforcableMitigationKindParseError;
+pub struct DeniedPartialMitigationKindParseError;
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Encodable, BlobDecodable)]
 pub struct MitigationEnablement {
-    pub kind: EnforcableMitigationKind,
+    pub kind: DeniedPartialMitigationKind,
     pub enabled: bool,
 }
 
@@ -82,58 +82,58 @@ macro_rules! intersperse {
 macro_rules! enforced_mitigations {
     ([$self:ident] enum $kind:ident {$(($name:ident, $text:expr, $since:ident, $code:expr)),*}) => {
         #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Encodable, BlobDecodable)]
-        pub enum EnforcableMitigationKind {
+        pub enum DeniedPartialMitigationKind {
             $($name),*
         }
 
-        impl std::fmt::Display for EnforcableMitigationKind {
+        impl std::fmt::Display for DeniedPartialMitigationKind {
             fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                 match self {
-                    $(EnforcableMitigationKind::$name => write!(f, $text)),*
+                    $(DeniedPartialMitigationKind::$name => write!(f, $text)),*
                 }
             }
         }
 
-        impl EnforcableMitigationKind {
+        impl DeniedPartialMitigationKind {
             pub(crate) const KINDS: &'static str = concat!("comma-separated list of mitigation kinds (available: ",
                 intersperse!(", ", ($(concat!("`", $text, "`")),*)), ")");
         }
 
-        impl FromStr for EnforcableMitigationKind {
-            type Err = EnforcableMitigationKindParseError;
+        impl FromStr for DeniedPartialMitigationKind {
+            type Err = DeniedPartialMitigationKindParseError;
 
-            fn from_str(v: &str) -> Result<EnforcableMitigationKind, EnforcableMitigationKindParseError> {
+            fn from_str(v: &str) -> Result<DeniedPartialMitigationKind, DeniedPartialMitigationKindParseError> {
                 match v {
-                    $($text => Ok(EnforcableMitigationKind::$name)),*
+                    $($text => Ok(DeniedPartialMitigationKind::$name)),*
                     ,
-                    _ => Err(EnforcableMitigationKindParseError),
+                    _ => Err(DeniedPartialMitigationKindParseError),
                 }
             }
         }
 
         #[allow(unused)]
-        impl EnforcableMitigationKind {
+        impl DeniedPartialMitigationKind {
             pub fn enforced_since(&self) -> Edition {
                 match self {
                     // Should change the enforced-since edition of StackProtector to 2015
                     // (all editions) when `-C stack-protector` is stabilized.
-                    $(EnforcableMitigationKind::$name => Edition::$since),*
+                    $(DeniedPartialMitigationKind::$name => Edition::$since),*
                 }
             }
         }
 
         impl Options {
-            pub fn all_enforced_mitigations(&self) -> impl Iterator<Item = EnforcableMitigationKind> {
-                [$(EnforcableMitigationKind::$name),*].into_iter()
+            pub fn all_enforced_mitigations(&self) -> impl Iterator<Item = DeniedPartialMitigationKind> {
+                [$(DeniedPartialMitigationKind::$name),*].into_iter()
             }
         }
 
         impl Session {
-            pub fn gather_enabled_enforcable_mitigations(&$self) -> Vec<EnforcableMitigation> {
+            pub fn gather_enabled_denied_partial_mitigations(&$self) -> Vec<DeniedPartialMitigation> {
                 let mut mitigations = [
                     $(
-                    EnforcableMitigation {
-                        kind: EnforcableMitigationKind::$name,
+                    DeniedPartialMitigation {
+                        kind: DeniedPartialMitigationKind::$name,
                         level: From::from($code),
                     }
                     ),*
@@ -147,25 +147,25 @@ macro_rules! enforced_mitigations {
 
 enforced_mitigations! {
     [self]
-    enum EnforcableMitigationKind {
+    enum DeniedPartialMitigationKind {
         (StackProtector, "stack-protector", EditionFuture, self.stack_protector()),
         (ControlFlowGuard, "control-flow-guard", EditionFuture, self.opts.cg.control_flow_guard == CFGuard::Checks)
     }
 }
 
 /// Enforced mitigations, see [RFC 3855](https://github.com/rust-lang/rfcs/pull/3855)
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Encodable, BlobDecodable)]
-pub struct EnforcableMitigation {
-    pub kind: EnforcableMitigationKind,
-    pub level: EnforcableMitigationLevel,
+pub struct DeniedPartialMitigation {
+    pub kind: DeniedPartialMitigationKind,
+    pub level: DeniedPartialMitigationLevel,
 }
 
 impl Options {
     // Return the list of mitigations that are allowed to be partial
     pub fn allowed_partial_mitigations(
         &self,
         edition: Edition,
-    ) -> impl Iterator<Item = EnforcableMitigationKind> {
+    ) -> impl Iterator<Item = DeniedPartialMitigationKind> {
         let mut result: BTreeSet<_> = self
             .all_enforced_mitigations()
             .filter(|mitigation| mitigation.enforced_since() > edition)

Original file line number	Diff line number	Diff line change
`@@ -883,7 +883,7 @@ mod desc {`
`883`	`883`	"either a boolean (`yes`, `no`, `on`, `off`, etc), or `nll` (default: `nll`)";
`884`	`884`	`pub(crate) const parse_align: &str = "a number that is a power of 2 between 1 and 2^29";`
`885`	`885`	`pub(crate) const parse_allow_partial_mitigations: &str =`
`886`		`- super::enforcable_mitigations::EnforcableMitigationKind::KINDS;`
	`886`	`+ super::enforcable_mitigations::DeniedPartialMitigationKind::KINDS;`
`887`	`887`	`}`
`888`	`888`
`889`	`889`	`pub mod parse {`
Original file line number	Diff line number	Diff line change
`@@ -10,66 +10,66 @@ use crate::config::Options;`
`10`	`10`	`use crate::options::CFGuard;`
`11`	`11`
`12`	`12`	`#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Encodable, BlobDecodable)]`
`13`		`-pub enum EnforcableMitigationLevel {`
	`13`	`+pub enum DeniedPartialMitigationLevel {`
`14`	`14`	`// Enabled(false) should be the bottom of the Ord hierarchy`
`15`	`15`	`Enabled(bool),`
`16`	`16`	`StackProtector(StackProtector),`
`17`	`17`	`}`
`18`	`18`
`19`		`-impl EnforcableMitigationLevel {`
	`19`	`+impl DeniedPartialMitigationLevel {`
`20`	`20`	`pub fn level_str(&self) -> &'static str {`
`21`	`21`	`match self {`
`22`		`- EnforcableMitigationLevel::StackProtector(StackProtector::All) => "=all",`
`23`		`- EnforcableMitigationLevel::StackProtector(StackProtector::Basic) => "=basic",`
`24`		`- EnforcableMitigationLevel::StackProtector(StackProtector::Strong) => "=strong",`
	`22`	`+ DeniedPartialMitigationLevel::StackProtector(StackProtector::All) => "=all",`
	`23`	`+ DeniedPartialMitigationLevel::StackProtector(StackProtector::Basic) => "=basic",`
	`24`	`+ DeniedPartialMitigationLevel::StackProtector(StackProtector::Strong) => "=strong",`
`25`	`25`	// currently `=disabled` should not appear
`26`		`- EnforcableMitigationLevel::Enabled(false) => "=disabled",`
`27`		`- EnforcableMitigationLevel::StackProtector(StackProtector::None)`
`28`		`- \| EnforcableMitigationLevel::Enabled(true) => "",`
	`26`	`+ DeniedPartialMitigationLevel::Enabled(false) => "=disabled",`
	`27`	`+ DeniedPartialMitigationLevel::StackProtector(StackProtector::None)`
	`28`	`+ \| DeniedPartialMitigationLevel::Enabled(true) => "",`
`29`	`29`	`}`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`
`33`		`-impl std::fmt::Display for EnforcableMitigationLevel {`
	`33`	`+impl std::fmt::Display for DeniedPartialMitigationLevel {`
`34`	`34`	`fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
`35`	`35`	`match self {`
`36`		`- EnforcableMitigationLevel::StackProtector(StackProtector::All) => {`
	`36`	`+ DeniedPartialMitigationLevel::StackProtector(StackProtector::All) => {`
`37`	`37`	`write!(f, "all")`
`38`	`38`	`}`
`39`		`- EnforcableMitigationLevel::StackProtector(StackProtector::Basic) => {`
	`39`	`+ DeniedPartialMitigationLevel::StackProtector(StackProtector::Basic) => {`
`40`	`40`	`write!(f, "basic")`
`41`	`41`	`}`
`42`		`- EnforcableMitigationLevel::StackProtector(StackProtector::Strong) => {`
	`42`	`+ DeniedPartialMitigationLevel::StackProtector(StackProtector::Strong) => {`
`43`	`43`	`write!(f, "strong")`
`44`	`44`	`}`
`45`		`- EnforcableMitigationLevel::Enabled(true) => {`
	`45`	`+ DeniedPartialMitigationLevel::Enabled(true) => {`
`46`	`46`	`write!(f, "enabled")`
`47`	`47`	`}`
`48`		`- EnforcableMitigationLevel::StackProtector(StackProtector::None)`
`49`		`- \| EnforcableMitigationLevel::Enabled(false) => {`
	`48`	`+ DeniedPartialMitigationLevel::StackProtector(StackProtector::None)`
	`49`	`+ \| DeniedPartialMitigationLevel::Enabled(false) => {`
`50`	`50`	`write!(f, "disabled")`
`51`	`51`	`}`
`52`	`52`	`}`
`53`	`53`	`}`
`54`	`54`	`}`
`55`	`55`
`56`		`-impl From<bool> for EnforcableMitigationLevel {`
	`56`	`+impl From<bool> for DeniedPartialMitigationLevel {`
`57`	`57`	`fn from(value: bool) -> Self {`
`58`		`- EnforcableMitigationLevel::Enabled(value)`
	`58`	`+ DeniedPartialMitigationLevel::Enabled(value)`
`59`	`59`	`}`
`60`	`60`	`}`
`61`	`61`
`62`		`-impl From<StackProtector> for EnforcableMitigationLevel {`
	`62`	`+impl From<StackProtector> for DeniedPartialMitigationLevel {`
`63`	`63`	`fn from(value: StackProtector) -> Self {`
`64`		`- EnforcableMitigationLevel::StackProtector(value)`
	`64`	`+ DeniedPartialMitigationLevel::StackProtector(value)`
`65`	`65`	`}`
`66`	`66`	`}`
`67`	`67`
`68`		`-pub struct EnforcableMitigationKindParseError;`
	`68`	`+pub struct DeniedPartialMitigationKindParseError;`
`69`	`69`
`70`	`70`	`#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Encodable, BlobDecodable)]`
`71`	`71`	`pub struct MitigationEnablement {`
`72`		`- pub kind: EnforcableMitigationKind,`
	`72`	`+ pub kind: DeniedPartialMitigationKind,`
`73`	`73`	`pub enabled: bool,`
`74`	`74`	`}`
`75`	`75`
`@@ -82,58 +82,58 @@ macro_rules! intersperse {`
`82`	`82`	`macro_rules! enforced_mitigations {`
`83`	`83`	`([$self:ident] enum $kind:ident {$(($name:ident, $text:expr, $since:ident, $code:expr)),*}) => {`
`84`	`84`	`#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Encodable, BlobDecodable)]`
`85`		`- pub enum EnforcableMitigationKind {`
	`85`	`+ pub enum DeniedPartialMitigationKind {`
`86`	`86`	`$($name),*`
`87`	`87`	`}`
`88`	`88`
`89`		`- impl std::fmt::Display for EnforcableMitigationKind {`
	`89`	`+ impl std::fmt::Display for DeniedPartialMitigationKind {`
`90`	`90`	`fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
`91`	`91`	`match self {`
`92`		`- $(EnforcableMitigationKind::$name => write!(f, $text)),*`
	`92`	`+ $(DeniedPartialMitigationKind::$name => write!(f, $text)),*`
`93`	`93`	`}`
`94`	`94`	`}`
`95`	`95`	`}`
`96`	`96`
`97`		`- impl EnforcableMitigationKind {`
	`97`	`+ impl DeniedPartialMitigationKind {`
`98`	`98`	`pub(crate) const KINDS: &'static str = concat!("comma-separated list of mitigation kinds (available: ",`
`99`	`99`	intersperse!(", ", ($(concat!("`", $text, "`")),*)), ")");
`100`	`100`	`}`
`101`	`101`
`102`		`- impl FromStr for EnforcableMitigationKind {`
`103`		`- type Err = EnforcableMitigationKindParseError;`
	`102`	`+ impl FromStr for DeniedPartialMitigationKind {`
	`103`	`+ type Err = DeniedPartialMitigationKindParseError;`
`104`	`104`
`105`		`- fn from_str(v: &str) -> Result<EnforcableMitigationKind, EnforcableMitigationKindParseError> {`
	`105`	`+ fn from_str(v: &str) -> Result<DeniedPartialMitigationKind, DeniedPartialMitigationKindParseError> {`
`106`	`106`	`match v {`
`107`		`- $($text => Ok(EnforcableMitigationKind::$name)),*`
	`107`	`+ $($text => Ok(DeniedPartialMitigationKind::$name)),*`
`108`	`108`	`,`
`109`		`- _ => Err(EnforcableMitigationKindParseError),`
	`109`	`+ _ => Err(DeniedPartialMitigationKindParseError),`
`110`	`110`	`}`
`111`	`111`	`}`
`112`	`112`	`}`
`113`	`113`
`114`	`114`	`#[allow(unused)]`
`115`		`- impl EnforcableMitigationKind {`
	`115`	`+ impl DeniedPartialMitigationKind {`
`116`	`116`	`pub fn enforced_since(&self) -> Edition {`
`117`	`117`	`match self {`
`118`	`118`	`// Should change the enforced-since edition of StackProtector to 2015`
`119`	`119`	// (all editions) when `-C stack-protector` is stabilized.
`120`		`- $(EnforcableMitigationKind::$name => Edition::$since),*`
	`120`	`+ $(DeniedPartialMitigationKind::$name => Edition::$since),*`
`121`	`121`	`}`
`122`	`122`	`}`
`123`	`123`	`}`
`124`	`124`
`125`	`125`	`impl Options {`
`126`		`- pub fn all_enforced_mitigations(&self) -> impl Iterator<Item = EnforcableMitigationKind> {`
`127`		`- [$(EnforcableMitigationKind::$name),*].into_iter()`
	`126`	`+ pub fn all_enforced_mitigations(&self) -> impl Iterator<Item = DeniedPartialMitigationKind> {`
	`127`	`+ [$(DeniedPartialMitigationKind::$name),*].into_iter()`
`128`	`128`	`}`
`129`	`129`	`}`
`130`	`130`
`131`	`131`	`impl Session {`
`132`		`- pub fn gather_enabled_enforcable_mitigations(&$self) -> Vec<EnforcableMitigation> {`
	`132`	`+ pub fn gather_enabled_denied_partial_mitigations(&$self) -> Vec<DeniedPartialMitigation> {`
`133`	`133`	`let mut mitigations = [`
`134`	`134`	`$(`
`135`		`- EnforcableMitigation {`
`136`		`- kind: EnforcableMitigationKind::$name,`
	`135`	`+ DeniedPartialMitigation {`
	`136`	`+ kind: DeniedPartialMitigationKind::$name,`
`137`	`137`	`level: From::from($code),`
`138`	`138`	`}`
`139`	`139`	`),*`
`@@ -147,25 +147,25 @@ macro_rules! enforced_mitigations {`
`147`	`147`
`148`	`148`	`enforced_mitigations! {`
`149`	`149`	`[self]`
`150`		`- enum EnforcableMitigationKind {`
	`150`	`+ enum DeniedPartialMitigationKind {`
`151`	`151`	`(StackProtector, "stack-protector", EditionFuture, self.stack_protector()),`
`152`	`152`	`(ControlFlowGuard, "control-flow-guard", EditionFuture, self.opts.cg.control_flow_guard == CFGuard::Checks)`
`153`	`153`	`}`
`154`	`154`	`}`
`155`	`155`
`156`	`156`	`/// Enforced mitigations, see [RFC 3855](https://github.com/rust-lang/rfcs/pull/3855)`
`157`	`157`	`#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Encodable, BlobDecodable)]`
`158`		`-pub struct EnforcableMitigation {`
`159`		`- pub kind: EnforcableMitigationKind,`
`160`		`- pub level: EnforcableMitigationLevel,`
	`158`	`+pub struct DeniedPartialMitigation {`
	`159`	`+ pub kind: DeniedPartialMitigationKind,`
	`160`	`+ pub level: DeniedPartialMitigationLevel,`
`161`	`161`	`}`
`162`	`162`
`163`	`163`	`impl Options {`
`164`	`164`	`// Return the list of mitigations that are allowed to be partial`
`165`	`165`	`pub fn allowed_partial_mitigations(`
`166`	`166`	`&self,`
`167`	`167`	`edition: Edition,`
`168`		`- ) -> impl Iterator<Item = EnforcableMitigationKind> {`
	`168`	`+ ) -> impl Iterator<Item = DeniedPartialMitigationKind> {`
`169`	`169`	`let mut result: BTreeSet<_> = self`
`170`	`170`	`.all_enforced_mitigations()`
`171`	`171`	`.filter(\|mitigation\| mitigation.enforced_since() > edition)`