mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove UnsafetyState.

Browse Source 
`FnCtxt::ps` is the only occurrence. It gets updated during HIR
typechecking, but is never looked at.
This commit is contained in:
Nicholas Nethercote 2022-12-08 15:42:12 +11:00
parent e491d2b24d
commit 7a4669285a
4 changed files with 2 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
compiler/rustc_hir_typeck/src/check.rs
View File

@ -1,7 +1,7 @@
use crate::coercion::CoerceMany;
use crate::gather_locals::GatherLocalsVisitor;
use crate::FnCtxt;
use crate::{GeneratorTypes, UnsafetyState};
use crate::GeneratorTypes;
use rustc_hir as hir;
use rustc_hir::def::DefKind;
use rustc_hir::intravisit::Visitor;
@ -30,7 +30,6 @@ pub(super) fn check_fn<'a, 'tcx>(
can_be_generator: Option<hir::Movability>,
) -> Option<GeneratorTypes<'tcx>> {
let fn_id = fcx.tcx.hir().local_def_id_to_hir_id(fn_def_id);
fcx.ps.set(UnsafetyState::function(fn_sig.unsafety, fn_id));
let tcx = fcx.tcx;
let hir = tcx.hir();

3
compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
View File

@ -1393,8 +1393,6 @@ pub(in super::super) fn check_block_with_expected(
blk: &'tcx hir::Block<'tcx>,
expected: Expectation<'tcx>,
) -> Ty<'tcx> {
let prev = self.ps.replace(self.ps.get().recurse(blk));
// In some cases, blocks have just one exit, but other blocks
// can be targeted by multiple breaks. This can happen both
// with labeled blocks as well as when we desugar
@ -1558,7 +1556,6 @@ pub(in super::super) fn check_block_with_expected(
self.write_ty(blk.hir_id, ty);
self.ps.set(prev);
ty
}

5
compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs
View File

@ -8,7 +8,7 @@
pub use suggestions::*;
use crate::coercion::DynamicCoerceMany;
use crate::{Diverges, EnclosingBreakables, Inherited, UnsafetyState};
use crate::{Diverges, EnclosingBreakables, Inherited};
use rustc_hir as hir;
use rustc_hir::def_id::DefId;
use rustc_hir_analysis::astconv::AstConv;
@ -74,8 +74,6 @@ pub struct FnCtxt<'a, 'tcx> {
pub(super) resume_yield_tys: Option<(Ty<'tcx>, Ty<'tcx>)>,
pub(super) ps: Cell<UnsafetyState>,
/// Whether the last checked node generates a divergence (e.g.,
/// `return` will set this to `Always`). In general, when entering
/// an expression or other node in the tree, the initial value
@ -129,7 +127,6 @@ pub fn new(
ret_coercion: None,
ret_coercion_span: Cell::new(None),
resume_yield_tys: None,
ps: Cell::new(UnsafetyState::function(hir::Unsafety::Normal, hir::CRATE_HIR_ID)),
diverges: Cell::new(Diverges::Maybe),
enclosing_breakables: RefCell::new(EnclosingBreakables {
stack: Vec::new(),

32
compiler/rustc_hir_typeck/src/lib.rs
View File

@ -89,38 +89,6 @@ pub struct LocalTy<'tcx> {
revealed_ty: Ty<'tcx>,
}
#[derive(Copy, Clone)]
pub struct UnsafetyState {
pub def: hir::HirId,
pub unsafety: hir::Unsafety,
from_fn: bool,
}
impl UnsafetyState {
pub fn function(unsafety: hir::Unsafety, def: hir::HirId) -> UnsafetyState {
UnsafetyState { def, unsafety, from_fn: true }
}
pub fn recurse(self, blk: &hir::Block<'_>) -> UnsafetyState {
use hir::BlockCheckMode;
match self.unsafety {
// If this unsafe, then if the outer function was already marked as
// unsafe we shouldn't attribute the unsafe'ness to the block. This
// way the block can be warned about instead of ignoring this
// extraneous block (functions are never warned about).
hir::Unsafety::Unsafe if self.from_fn => self,
unsafety => {
let (unsafety, def) = match blk.rules {
BlockCheckMode::UnsafeBlock(..) => (hir::Unsafety::Unsafe, blk.hir_id),
BlockCheckMode::DefaultBlock => (unsafety, self.def),
};
UnsafetyState { def, unsafety, from_fn: false }
}
}
}
}
/// If this `DefId` is a "primary tables entry", returns
/// `Some((body_id, body_ty, fn_sig))`. Otherwise, returns `None`.
///