address review comments

Author: Ariel Ben-Yehuda

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::enforceable_mitigations::DeniedPartialMitigationLevel;
+use rustc_session::config::mitigation_coverage::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_denied_partial_mitigations(tcx, krate);
+        self.report_incompatible_partial_mitigations(tcx, krate);
         self.report_incompatible_async_drop_feature(tcx, krate);
     }
 
@@ -483,7 +483,7 @@ impl CStore {
         }
     }
 
-    pub fn report_incompatible_denied_partial_mitigations(&self, tcx: TyCtxt<'_>, krate: &Crate) {
+    pub fn report_incompatible_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();

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::enforceable_mitigations::DeniedPartialMitigation;
+use rustc_session::config::mitigation_coverage::DeniedPartialMitigation;
 use rustc_session::cstore::{CrateSource, ExternCrate};
 use rustc_span::hygiene::HygieneDecodeContext;
 use rustc_span::{

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::enforceable_mitigations::DeniedPartialMitigation;
+use rustc_session::config::mitigation_coverage::DeniedPartialMitigation;
 use rustc_session::config::{CrateType, OptLevel, TargetModifier};
 use rustc_span::hygiene::HygieneEncodeContext;
 use rustc_span::{

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::enforceable_mitigations::DeniedPartialMitigation;
+use rustc_session::config::mitigation_coverage::DeniedPartialMitigation;
 use rustc_session::config::{SymbolManglingVersion, TargetModifier};
 use rustc_session::cstore::{CrateDepKind, ForeignModule, LinkagePreference, NativeLib};
 use rustc_span::edition::Edition;

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::enforceable_mitigations::DeniedPartialMitigation,
+    rustc_session::config::mitigation_coverage::DeniedPartialMitigation,
     rustc_session::cstore::ForeignModule,
     rustc_session::cstore::LinkagePreference,
     rustc_session::cstore::NativeLib,

compiler/rustc_session/src/options.rs

@@ -19,7 +19,7 @@ use rustc_target::spec::{
     TargetTuple, TlsModel,
 };
 
-use crate::config::enforceable_mitigations::MitigationEnablement;
+use crate::config::mitigation_coverage::MitigationCoverage;
 use crate::config::*;
 use crate::search_paths::SearchPath;
 use crate::utils::NativeLib;
@@ -84,7 +84,7 @@ pub struct TargetModifier {
     pub value_name: String,
 }
 
-pub mod enforceable_mitigations;
+pub mod mitigation_coverage;
 
 mod target_modifier_consistency_check {
     use super::*;
@@ -886,16 +886,16 @@ 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::enforceable_mitigations::DeniedPartialMitigationKind::KINDS;
+        super::mitigation_coverage::DeniedPartialMitigationKind::KINDS;
     pub(crate) const parse_deny_partial_mitigations: &str =
-        super::enforceable_mitigations::DeniedPartialMitigationKind::KINDS;
+        super::mitigation_coverage::DeniedPartialMitigationKind::KINDS;
 }
 
 pub mod parse {
     use std::str::FromStr;
 
     pub(crate) use super::*;
-    use crate::config::enforceable_mitigations::MitigationEnablement;
+    use crate::config::mitigation_coverage::MitigationCoverage;
     pub(crate) const MAX_THREADS_CAP: usize = 256;
 
     /// This is for boolean options that don't take a value, and are true simply
@@ -2065,15 +2065,15 @@ pub mod parse {
     }
 
     fn parse_partial_mitigations(
-        slot: &mut Vec<MitigationEnablement>,
+        slot: &mut Vec<MitigationCoverage>,
         v: Option<&str>,
         enabled: bool,
     ) -> bool {
         match v {
             Some(s) => {
                 for sub in s.split(',') {
                     match sub.parse() {
-                        Ok(kind) => slot.push(MitigationEnablement { kind, enabled }),
+                        Ok(kind) => slot.push(MitigationCoverage { kind, enabled }),
                         Err(_) => return false,
                     }
                 }
@@ -2084,14 +2084,14 @@ pub mod parse {
     }
 
     pub(crate) fn parse_allow_partial_mitigations(
-        slot: &mut Vec<MitigationEnablement>,
+        slot: &mut Vec<MitigationCoverage>,
         v: Option<&str>,
     ) -> bool {
         parse_partial_mitigations(slot, v, true)
     }
 
     pub(crate) fn parse_deny_partial_mitigations(
-        slot: &mut Vec<MitigationEnablement>,
+        slot: &mut Vec<MitigationCoverage>,
         v: Option<&str>,
     ) -> bool {
         parse_partial_mitigations(slot, v, false)
@@ -2256,7 +2256,7 @@ options! {
     // tidy-alphabetical-start
     allow_features: Option<Vec<String>> = (None, parse_opt_comma_list, [TRACKED],
         "only allow the listed language features to be enabled in code (comma separated)"),
-    allow_partial_mitigations: Vec<MitigationEnablement> = (Vec::new(), parse_allow_partial_mitigations, [UNTRACKED],
+    allow_partial_mitigations: Vec<MitigationCoverage> = (Vec::new(), parse_allow_partial_mitigations, [UNTRACKED],
         "Allow mitigations not enabled for all dependency crates (comma separated list)"),
     always_encode_mir: bool = (false, parse_bool, [TRACKED],
         "encode MIR of all functions into the crate metadata (default: no)"),
@@ -2323,7 +2323,7 @@ options! {
         "deduplicate identical diagnostics (default: yes)"),
     default_visibility: Option<SymbolVisibility> = (None, parse_opt_symbol_visibility, [TRACKED],
         "overrides the `default_visibility` setting of the target"),
-    deny_partial_mitigations: Vec<MitigationEnablement> = (Vec::new(), parse_deny_partial_mitigations, [UNTRACKED],
+    deny_partial_mitigations: Vec<MitigationCoverage> = (Vec::new(), parse_deny_partial_mitigations, [UNTRACKED],
         "Deny mitigations not enabled for all dependency crates (comma separated list)"),
     dep_info_omit_d_target: bool = (false, parse_bool, [TRACKED],
         "in dep-info output, omit targets for tracking dependencies of the dep-info files \

…n/src/options/enforceable_mitigations.rs …ssion/src/options/mitigation_coverage.rscompiler/rustc_session/src/options/enforceable_mitigations.rs renamed to compiler/rustc_session/src/options/mitigation_coverage.rs compiler/rustc_session/src/options/enforceable_mitigations.rs renamed to compiler/rustc_session/src/options/mitigation_coverage.rs

@@ -68,7 +68,7 @@ impl From<StackProtector> for DeniedPartialMitigationLevel {
 pub struct DeniedPartialMitigationKindParseError;
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Encodable, BlobDecodable)]
-pub struct MitigationEnablement {
+pub struct MitigationCoverage {
     pub kind: DeniedPartialMitigationKind,
     pub enabled: bool,
 }
@@ -79,7 +79,7 @@ macro_rules! intersperse {
     };
 }
 
-macro_rules! enforced_mitigations {
+macro_rules! denied_partial_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 DeniedPartialMitigationKind {
@@ -123,7 +123,7 @@ macro_rules! enforced_mitigations {
         }
 
         impl Options {
-            pub fn all_enforced_mitigations(&self) -> impl Iterator<Item = DeniedPartialMitigationKind> {
+            pub fn all_denied_partial_mitigations(&self) -> impl Iterator<Item = DeniedPartialMitigationKind> {
                 [$(DeniedPartialMitigationKind::$name),*].into_iter()
             }
         }
@@ -145,15 +145,15 @@ macro_rules! enforced_mitigations {
     }
 }
 
-enforced_mitigations! {
+denied_partial_mitigations! {
     [self]
     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)
+/// Denied-partial mitigations, see [RFC 3855](https://github.com/rust-lang/rfcs/pull/3855)
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Encodable, BlobDecodable)]
 pub struct DeniedPartialMitigation {
     pub kind: DeniedPartialMitigationKind,
@@ -167,7 +167,7 @@ impl Options {
         edition: Edition,
     ) -> impl Iterator<Item = DeniedPartialMitigationKind> {
         let mut result: BTreeSet<_> = self
-            .all_enforced_mitigations()
+            .all_denied_partial_mitigations()
             .filter(|mitigation| mitigation.enforced_since() > edition)
             .collect();
         for mitigation in &self.unstable_opts.allow_partial_mitigations {