EnforcableMitigation => DeniedPartialMitigation

compiler/rustc_metadata/src/creader.rs

@@ -25,7 +25,7 @@
 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,
@@ -468,7 +468,7 @@ fn report_target_modifiers_extended(
 
     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);
     }
 
@@ -493,8 +493,8 @@ pub fn report_incompatible_target_modifiers(&self, tcx: TyCtxt<'_>, krate: &Crat
         }
     }
 
-    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()) {
@@ -506,12 +506,12 @@ pub fn report_incompatible_enforcable_mitigations(&self, tcx: TyCtxt<'_>, krate:
             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 {

compiler/rustc_metadata/src/rmeta/decoder.rs

@@ -30,7 +30,7 @@
 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::{
@@ -83,7 +83,7 @@ pub(crate) fn bytes(&self) -> &OwnedSlice {
 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.
@@ -964,11 +964,11 @@ pub(crate) fn decode_target_modifiers<'a>(
         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)
     }
 }
 
@@ -1952,8 +1952,8 @@ pub(crate) fn target_modifiers(&self) -> TargetModifiers {
         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

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -27,7 +27,7 @@
 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 @@ macro_rules! stat {
         // `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();
@@ -761,7 +761,7 @@ macro_rules! stat {
                 foreign_modules,
                 source_map,
                 target_modifiers,
-                enforcable_mitigations,
+                denied_partial_mitigations,
                 traits,
                 impls,
                 incoherent_impls,
@@ -2108,10 +2108,10 @@ fn encode_target_modifiers(&mut self) -> LazyArray<TargetModifier> {
         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)> {

compiler/rustc_metadata/src/rmeta/mod.rs

@@ -36,7 +36,7 @@
 use rustc_middle::ty::{self, Ty, TyCtxt};
 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;
@@ -287,7 +287,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,

compiler/rustc_metadata/src/rmeta/parameterized.rs

@@ -120,7 +120,7 @@ impl ParameterizedOverTcx for $ty {
     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,

compiler/rustc_session/src/options.rs

@@ -893,7 +893,7 @@ mod desc {
     pub(crate) const parse_align: &str = "a number that is a power of 2 between 1 and 2^29";
     pub(crate) const parse_assert_incr_state: &str = "one of: `loaded`, `not-loaded`";
     pub(crate) const parse_allow_partial_mitigations: &str =
-        super::enforcable_mitigations::EnforcableMitigationKind::KINDS;
+        super::enforcable_mitigations::DeniedPartialMitigationKind::KINDS;
 }
 
 pub mod parse {

compiler/rustc_session/src/options/enforcable_mitigations.rs

@@ -10,66 +10,66 @@
 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,7 +147,7 @@ pub fn gather_enabled_enforcable_mitigations(&$self) -> Vec<EnforcableMitigation
 
 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)
     }
@@ -155,9 +155,9 @@ enum EnforcableMitigationKind {
 
 /// 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 {
@@ -165,7 +165,7 @@ impl Options {
     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)