diff --git a/compiler/rustc_metadata/src/creader.rs b/compiler/rustc_metadata/src/creader.rs index 972c1e2df932..cee7a41a1182 100644 --- a/compiler/rustc_metadata/src/creader.rs +++ b/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 { diff --git a/compiler/rustc_metadata/src/rmeta/decoder.rs b/compiler/rustc_metadata/src/rmeta/decoder.rs index 7344be2cb317..00ca24c6b750 100644 --- a/compiler/rustc_metadata/src/rmeta/decoder.rs +++ b/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; /// The set of enforcable mitigations (RFC 3855) that are currently enabled for this crate -pub(crate) type EnforcableMitigations = Vec; +pub(crate) type DeniedPartialMitigations = Vec; 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 { - self.enforcable_mitigations.decode(metadata) + ) -> impl ExactSizeIterator { + 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 diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs index 712c5aa0e2b8..ef5416ac427d 100644 --- a/compiler/rustc_metadata/src/rmeta/encoder.rs +++ b/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 { self.lazy_array(tcx.sess.opts.gather_target_modifiers()) } - fn encode_enabled_enforcable_mitigations(&mut self) -> LazyArray { + fn encode_enabled_denied_partial_mitigations(&mut self) -> LazyArray { 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 index 6d9627b9528d..bcc0aa1f3be8 100644 --- a/compiler/rustc_metadata/src/rmeta/mod.rs +++ b/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>>, target_modifiers: LazyArray, - enforcable_mitigations: LazyArray, + denied_partial_mitigations: LazyArray, compiler_builtins: bool, needs_allocator: bool, diff --git a/compiler/rustc_metadata/src/rmeta/parameterized.rs b/compiler/rustc_metadata/src/rmeta/parameterized.rs index b993932eb70d..35ea06b38453 100644 --- a/compiler/rustc_metadata/src/rmeta/parameterized.rs +++ b/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, diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs index 4bf92c3304f8..c84c9318fcf2 100644 --- a/compiler/rustc_session/src/options.rs +++ b/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 { diff --git a/compiler/rustc_session/src/options/enforcable_mitigations.rs b/compiler/rustc_session/src/options/enforcable_mitigations.rs index 667dd0b8aadc..851659f416e8 100644 --- a/compiler/rustc_session/src/options/enforcable_mitigations.rs +++ b/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 for EnforcableMitigationLevel { +impl From for DeniedPartialMitigationLevel { fn from(value: bool) -> Self { - EnforcableMitigationLevel::Enabled(value) + DeniedPartialMitigationLevel::Enabled(value) } } -impl From for EnforcableMitigationLevel { +impl From 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 { + fn from_str(v: &str) -> Result { 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 { - [$(EnforcableMitigationKind::$name),*].into_iter() + pub fn all_enforced_mitigations(&self) -> impl Iterator { + [$(DeniedPartialMitigationKind::$name),*].into_iter() } } impl Session { - pub fn gather_enabled_enforcable_mitigations(&$self) -> Vec { + pub fn gather_enabled_denied_partial_mitigations(&$self) -> Vec { 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 impl Iterator { + ) -> impl Iterator { let mut result: BTreeSet<_> = self .all_enforced_mitigations() .filter(|mitigation| mitigation.enforced_since() > edition)