From 45c55540a821d767445f7419102b5ef8ce850481 Mon Sep 17 00:00:00 2001 From: Smitty Date: Mon, 17 May 2021 17:19:48 -0400 Subject: [PATCH] Remove some last remants of {push,pop}_unsafe! These macros have already been removed, but there was still some code handling these macros. That code is now removed. --- compiler/rustc_hir/src/hir.rs | 2 -- compiler/rustc_hir_pretty/src/lib.rs | 2 -- compiler/rustc_middle/src/mir/mod.rs | 2 -- compiler/rustc_middle/src/thir.rs | 2 -- .../rustc_mir/src/transform/check_unsafety.rs | 1 - compiler/rustc_mir_build/src/build/block.rs | 22 ++++--------------- compiler/rustc_mir_build/src/build/mod.rs | 11 +++------- compiler/rustc_mir_build/src/thir/cx/block.rs | 2 -- compiler/rustc_typeck/src/check/mod.rs | 19 +++++----------- src/tools/clippy/clippy_lints/src/derive.rs | 4 +--- 10 files changed, 13 insertions(+), 54 deletions(-) diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs index 577d43b1c8e..bb8d6386d8a 100644 --- a/compiler/rustc_hir/src/hir.rs +++ b/compiler/rustc_hir/src/hir.rs @@ -1205,8 +1205,6 @@ pub struct ExprField<'hir> { pub enum BlockCheckMode { DefaultBlock, UnsafeBlock(UnsafeSource), - PushUnsafeBlock(UnsafeSource), - PopUnsafeBlock(UnsafeSource), } #[derive(Copy, Clone, PartialEq, Encodable, Debug, HashStable_Generic)] diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs index 2b932b7c953..d11dca1cba4 100644 --- a/compiler/rustc_hir_pretty/src/lib.rs +++ b/compiler/rustc_hir_pretty/src/lib.rs @@ -1070,8 +1070,6 @@ impl<'a> State<'a> { ) { match blk.rules { hir::BlockCheckMode::UnsafeBlock(..) => self.word_space("unsafe"), - hir::BlockCheckMode::PushUnsafeBlock(..) => self.word_space("push_unsafe"), - hir::BlockCheckMode::PopUnsafeBlock(..) => self.word_space("pop_unsafe"), hir::BlockCheckMode::DefaultBlock => (), } self.maybe_print_comment(blk.span.lo()); diff --git a/compiler/rustc_middle/src/mir/mod.rs b/compiler/rustc_middle/src/mir/mod.rs index 7ae7eab6e5a..0daaec272fd 100644 --- a/compiler/rustc_middle/src/mir/mod.rs +++ b/compiler/rustc_middle/src/mir/mod.rs @@ -494,8 +494,6 @@ impl<'tcx> Body<'tcx> { #[derive(Copy, Clone, PartialEq, Eq, Debug, TyEncodable, TyDecodable, HashStable)] pub enum Safety { Safe, - /// Unsafe because of a PushUnsafeBlock - BuiltinUnsafe, /// Unsafe because of an unsafe fn FnUnsafe, /// Unsafe because of an `unsafe` block diff --git a/compiler/rustc_middle/src/thir.rs b/compiler/rustc_middle/src/thir.rs index a5069113702..bd0f9f1ef0b 100644 --- a/compiler/rustc_middle/src/thir.rs +++ b/compiler/rustc_middle/src/thir.rs @@ -101,8 +101,6 @@ pub struct Block { pub enum BlockSafety { Safe, ExplicitUnsafe(hir::HirId), - PushUnsafe, - PopUnsafe, } #[derive(Debug, HashStable)] diff --git a/compiler/rustc_mir/src/transform/check_unsafety.rs b/compiler/rustc_mir/src/transform/check_unsafety.rs index 103ddda1a1d..324a5257f5d 100644 --- a/compiler/rustc_mir/src/transform/check_unsafety.rs +++ b/compiler/rustc_mir/src/transform/check_unsafety.rs @@ -321,7 +321,6 @@ impl<'a, 'tcx> UnsafetyChecker<'a, 'tcx> { } false } - Safety::BuiltinUnsafe => true, Safety::ExplicitUnsafe(hir_id) => { // mark unsafe block as used if there are any unsafe operations inside if !violations.is_empty() { diff --git a/compiler/rustc_mir_build/src/build/block.rs b/compiler/rustc_mir_build/src/build/block.rs index 8426b24270d..4e1983aca94 100644 --- a/compiler/rustc_mir_build/src/build/block.rs +++ b/compiler/rustc_mir_build/src/build/block.rs @@ -74,8 +74,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { // First we build all the statements in the block. let mut let_scope_stack = Vec::with_capacity(8); let outer_source_scope = this.source_scope; - let outer_push_unsafe_count = this.push_unsafe_count; - let outer_unpushed_unsafe = this.unpushed_unsafe; + let outer_in_scope_unsafe = this.in_scope_unsafe; this.update_source_scope_for_safety_mode(span, safety_mode); let source_info = this.source_info(span); @@ -206,8 +205,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { } // Restore the original source scope. this.source_scope = outer_source_scope; - this.push_unsafe_count = outer_push_unsafe_count; - this.unpushed_unsafe = outer_unpushed_unsafe; + this.in_scope_unsafe = outer_in_scope_unsafe; block.unit() } @@ -217,8 +215,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { let new_unsafety = match safety_mode { BlockSafety::Safe => None, BlockSafety::ExplicitUnsafe(hir_id) => { - assert_eq!(self.push_unsafe_count, 0); - match self.unpushed_unsafe { + match self.in_scope_unsafe { Safety::Safe => {} // no longer treat `unsafe fn`s as `unsafe` contexts (see RFC #2585) Safety::FnUnsafe @@ -226,20 +223,9 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { != Level::Allow => {} _ => return, } - self.unpushed_unsafe = Safety::ExplicitUnsafe(hir_id); + self.in_scope_unsafe = Safety::ExplicitUnsafe(hir_id); Some(Safety::ExplicitUnsafe(hir_id)) } - BlockSafety::PushUnsafe => { - self.push_unsafe_count += 1; - Some(Safety::BuiltinUnsafe) - } - BlockSafety::PopUnsafe => { - self.push_unsafe_count = self - .push_unsafe_count - .checked_sub(1) - .unwrap_or_else(|| span_bug!(span, "unsafe count underflow")); - if self.push_unsafe_count == 0 { Some(self.unpushed_unsafe) } else { None } - } }; if let Some(unsafety) = new_unsafety { diff --git a/compiler/rustc_mir_build/src/build/mod.rs b/compiler/rustc_mir_build/src/build/mod.rs index 10d6521e7de..f5f6da3ec0b 100644 --- a/compiler/rustc_mir_build/src/build/mod.rs +++ b/compiler/rustc_mir_build/src/build/mod.rs @@ -367,12 +367,8 @@ struct Builder<'a, 'tcx> { /// `{ STMTS; EXPR1 } + EXPR2`. block_context: BlockContext, - /// The current unsafe block in scope, even if it is hidden by - /// a `PushUnsafeBlock`. - unpushed_unsafe: Safety, - - /// The number of `push_unsafe_block` levels in scope. - push_unsafe_count: usize, + /// The current unsafe block in scope + in_scope_unsafe: Safety, /// The vector of all scopes that we have created thus far; /// we track this for debuginfo later. @@ -877,8 +873,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { source_scopes: IndexVec::new(), source_scope: OUTERMOST_SOURCE_SCOPE, guard_context: vec![], - push_unsafe_count: 0, - unpushed_unsafe: safety, + in_scope_unsafe: safety, local_decls: IndexVec::from_elem_n(LocalDecl::new(return_ty, return_span), 1), canonical_user_type_annotations: IndexVec::new(), upvar_mutbls: vec![], diff --git a/compiler/rustc_mir_build/src/thir/cx/block.rs b/compiler/rustc_mir_build/src/thir/cx/block.rs index 77235fe9ab3..4fe8cd8541a 100644 --- a/compiler/rustc_mir_build/src/thir/cx/block.rs +++ b/compiler/rustc_mir_build/src/thir/cx/block.rs @@ -27,8 +27,6 @@ impl<'tcx> Cx<'tcx> { safety_mode: match block.rules { hir::BlockCheckMode::DefaultBlock => BlockSafety::Safe, hir::BlockCheckMode::UnsafeBlock(..) => BlockSafety::ExplicitUnsafe(block.hir_id), - hir::BlockCheckMode::PushUnsafeBlock(..) => BlockSafety::PushUnsafe, - hir::BlockCheckMode::PopUnsafeBlock(..) => BlockSafety::PopUnsafe, }, } } diff --git a/compiler/rustc_typeck/src/check/mod.rs b/compiler/rustc_typeck/src/check/mod.rs index ad7853b7cd0..d102896bfa6 100644 --- a/compiler/rustc_typeck/src/check/mod.rs +++ b/compiler/rustc_typeck/src/check/mod.rs @@ -174,13 +174,12 @@ impl Needs { pub struct UnsafetyState { pub def: hir::HirId, pub unsafety: hir::Unsafety, - pub unsafe_push_count: u32, from_fn: bool, } impl UnsafetyState { pub fn function(unsafety: hir::Unsafety, def: hir::HirId) -> UnsafetyState { - UnsafetyState { def, unsafety, unsafe_push_count: 0, from_fn: true } + UnsafetyState { def, unsafety, from_fn: true } } pub fn recurse(self, blk: &hir::Block<'_>) -> UnsafetyState { @@ -193,19 +192,11 @@ impl UnsafetyState { hir::Unsafety::Unsafe if self.from_fn => self, unsafety => { - let (unsafety, def, count) = match blk.rules { - BlockCheckMode::PushUnsafeBlock(..) => { - (unsafety, blk.hir_id, self.unsafe_push_count.checked_add(1).unwrap()) - } - BlockCheckMode::PopUnsafeBlock(..) => { - (unsafety, blk.hir_id, self.unsafe_push_count.checked_sub(1).unwrap()) - } - BlockCheckMode::UnsafeBlock(..) => { - (hir::Unsafety::Unsafe, blk.hir_id, self.unsafe_push_count) - } - BlockCheckMode::DefaultBlock => (unsafety, self.def, self.unsafe_push_count), + let (unsafety, def) = match blk.rules { + BlockCheckMode::UnsafeBlock(..) => (hir::Unsafety::Unsafe, blk.hir_id), + BlockCheckMode::DefaultBlock => (unsafety, self.def), }; - UnsafetyState { def, unsafety, unsafe_push_count: count, from_fn: false } + UnsafetyState { def, unsafety, from_fn: false } } } } diff --git a/src/tools/clippy/clippy_lints/src/derive.rs b/src/tools/clippy/clippy_lints/src/derive.rs index 840c1eba79d..729941f345a 100644 --- a/src/tools/clippy/clippy_lints/src/derive.rs +++ b/src/tools/clippy/clippy_lints/src/derive.rs @@ -411,9 +411,7 @@ impl<'tcx> Visitor<'tcx> for UnsafeVisitor<'_, 'tcx> { if let ExprKind::Block(block, _) = expr.kind { match block.rules { - BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided) - | BlockCheckMode::PushUnsafeBlock(UnsafeSource::UserProvided) - | BlockCheckMode::PopUnsafeBlock(UnsafeSource::UserProvided) => { + BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided) => { self.has_unsafe = true; }, _ => {},