mirror of
https://github.com/rust-lang/rust.git
synced 2024-10-30 14:01:51 +00:00
Auto merge of #116300 - cjgillot:split-move, r=petrochenkov
Separate move path tracking between borrowck and drop elaboration. The primary goal of this PR is to skip creating a `MovePathIndex` for path that do not need dropping in drop elaboration. The 2 first commits are cleanups. The next 2 commits displace `move` errors from move-path builder to borrowck. Move-path builder keeps the same logic, but does not carry error information any more. The remaining commits allow to filter `MovePathIndex` creation according to types. This is used in drop elaboration, to avoid computing dataflow for paths that do not need dropping.
This commit is contained in:
commit
cd674d6179
@ -2633,9 +2633,10 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
|
||||
/* Check if the mpi is initialized as an argument */
|
||||
let mut is_argument = false;
|
||||
for arg in self.body.args_iter() {
|
||||
let path = self.move_data.rev_lookup.find_local(arg);
|
||||
if mpis.contains(&path) {
|
||||
is_argument = true;
|
||||
if let Some(path) = self.move_data.rev_lookup.find_local(arg) {
|
||||
if mpis.contains(&path) {
|
||||
is_argument = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -46,6 +46,7 @@ mod mutability_errors;
|
||||
mod region_errors;
|
||||
|
||||
pub(crate) use bound_region_errors::{ToUniverseInfo, UniverseInfo};
|
||||
pub(crate) use move_errors::{IllegalMoveOriginKind, MoveError};
|
||||
pub(crate) use mutability_errors::AccessKind;
|
||||
pub(crate) use outlives_suggestion::OutlivesSuggestionBuilder;
|
||||
pub(crate) use region_errors::{ErrorConstraintInfo, RegionErrorKind, RegionErrors};
|
||||
|
@ -1,9 +1,7 @@
|
||||
use rustc_errors::{Applicability, Diagnostic, DiagnosticBuilder, ErrorGuaranteed};
|
||||
use rustc_middle::mir::*;
|
||||
use rustc_middle::ty;
|
||||
use rustc_mir_dataflow::move_paths::{
|
||||
IllegalMoveOrigin, IllegalMoveOriginKind, LookupResult, MoveError, MovePathIndex,
|
||||
};
|
||||
use rustc_middle::ty::{self, Ty};
|
||||
use rustc_mir_dataflow::move_paths::{LookupResult, MovePathIndex};
|
||||
use rustc_span::{BytePos, Span};
|
||||
|
||||
use crate::diagnostics::CapturedMessageOpt;
|
||||
@ -11,6 +9,42 @@ use crate::diagnostics::{DescribePlaceOpt, UseSpans};
|
||||
use crate::prefixes::PrefixSet;
|
||||
use crate::MirBorrowckCtxt;
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum IllegalMoveOriginKind<'tcx> {
|
||||
/// Illegal move due to attempt to move from behind a reference.
|
||||
BorrowedContent {
|
||||
/// The place the reference refers to: if erroneous code was trying to
|
||||
/// move from `(*x).f` this will be `*x`.
|
||||
target_place: Place<'tcx>,
|
||||
},
|
||||
|
||||
/// Illegal move due to attempt to move from field of an ADT that
|
||||
/// implements `Drop`. Rust maintains invariant that all `Drop`
|
||||
/// ADT's remain fully-initialized so that user-defined destructor
|
||||
/// can safely read from all of the ADT's fields.
|
||||
InteriorOfTypeWithDestructor { container_ty: Ty<'tcx> },
|
||||
|
||||
/// Illegal move due to attempt to move out of a slice or array.
|
||||
InteriorOfSliceOrArray { ty: Ty<'tcx>, is_index: bool },
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub(crate) struct MoveError<'tcx> {
|
||||
place: Place<'tcx>,
|
||||
location: Location,
|
||||
kind: IllegalMoveOriginKind<'tcx>,
|
||||
}
|
||||
|
||||
impl<'tcx> MoveError<'tcx> {
|
||||
pub(crate) fn new(
|
||||
place: Place<'tcx>,
|
||||
location: Location,
|
||||
kind: IllegalMoveOriginKind<'tcx>,
|
||||
) -> Self {
|
||||
MoveError { place, location, kind }
|
||||
}
|
||||
}
|
||||
|
||||
// Often when desugaring a pattern match we may have many individual moves in
|
||||
// MIR that are all part of one operation from the user's point-of-view. For
|
||||
// example:
|
||||
@ -53,20 +87,18 @@ enum GroupedMoveError<'tcx> {
|
||||
}
|
||||
|
||||
impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
|
||||
pub(crate) fn report_move_errors(&mut self, move_errors: Vec<(Place<'tcx>, MoveError<'tcx>)>) {
|
||||
let grouped_errors = self.group_move_errors(move_errors);
|
||||
pub(crate) fn report_move_errors(&mut self) {
|
||||
let grouped_errors = self.group_move_errors();
|
||||
for error in grouped_errors {
|
||||
self.report(error);
|
||||
}
|
||||
}
|
||||
|
||||
fn group_move_errors(
|
||||
&self,
|
||||
errors: Vec<(Place<'tcx>, MoveError<'tcx>)>,
|
||||
) -> Vec<GroupedMoveError<'tcx>> {
|
||||
fn group_move_errors(&mut self) -> Vec<GroupedMoveError<'tcx>> {
|
||||
let mut grouped_errors = Vec::new();
|
||||
for (original_path, error) in errors {
|
||||
self.append_to_grouped_errors(&mut grouped_errors, original_path, error);
|
||||
let errors = std::mem::take(&mut self.move_errors);
|
||||
for error in errors {
|
||||
self.append_to_grouped_errors(&mut grouped_errors, error);
|
||||
}
|
||||
grouped_errors
|
||||
}
|
||||
@ -74,66 +106,58 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
|
||||
fn append_to_grouped_errors(
|
||||
&self,
|
||||
grouped_errors: &mut Vec<GroupedMoveError<'tcx>>,
|
||||
original_path: Place<'tcx>,
|
||||
error: MoveError<'tcx>,
|
||||
) {
|
||||
match error {
|
||||
MoveError::UnionMove { .. } => {
|
||||
unimplemented!("don't know how to report union move errors yet.")
|
||||
}
|
||||
MoveError::IllegalMove { cannot_move_out_of: IllegalMoveOrigin { location, kind } } => {
|
||||
// Note: that the only time we assign a place isn't a temporary
|
||||
// to a user variable is when initializing it.
|
||||
// If that ever stops being the case, then the ever initialized
|
||||
// flow could be used.
|
||||
if let Some(StatementKind::Assign(box (
|
||||
place,
|
||||
Rvalue::Use(Operand::Move(move_from)),
|
||||
))) = self.body.basic_blocks[location.block]
|
||||
.statements
|
||||
.get(location.statement_index)
|
||||
.map(|stmt| &stmt.kind)
|
||||
{
|
||||
if let Some(local) = place.as_local() {
|
||||
let local_decl = &self.body.local_decls[local];
|
||||
// opt_match_place is the
|
||||
// match_span is the span of the expression being matched on
|
||||
// match *x.y { ... } match_place is Some(*x.y)
|
||||
// ^^^^ match_span is the span of *x.y
|
||||
//
|
||||
// opt_match_place is None for let [mut] x = ... statements,
|
||||
// whether or not the right-hand side is a place expression
|
||||
if let LocalInfo::User(BindingForm::Var(VarBindingForm {
|
||||
opt_match_place: Some((opt_match_place, match_span)),
|
||||
binding_mode: _,
|
||||
opt_ty_info: _,
|
||||
pat_span: _,
|
||||
})) = *local_decl.local_info()
|
||||
{
|
||||
let stmt_source_info = self.body.source_info(location);
|
||||
self.append_binding_error(
|
||||
grouped_errors,
|
||||
kind,
|
||||
original_path,
|
||||
*move_from,
|
||||
local,
|
||||
opt_match_place,
|
||||
match_span,
|
||||
stmt_source_info.span,
|
||||
);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
let MoveError { place: original_path, location, kind } = error;
|
||||
|
||||
let move_spans = self.move_spans(original_path.as_ref(), location);
|
||||
grouped_errors.push(GroupedMoveError::OtherIllegalMove {
|
||||
use_spans: move_spans,
|
||||
original_path,
|
||||
kind,
|
||||
});
|
||||
// Note: that the only time we assign a place isn't a temporary
|
||||
// to a user variable is when initializing it.
|
||||
// If that ever stops being the case, then the ever initialized
|
||||
// flow could be used.
|
||||
if let Some(StatementKind::Assign(box (place, Rvalue::Use(Operand::Move(move_from))))) =
|
||||
self.body.basic_blocks[location.block]
|
||||
.statements
|
||||
.get(location.statement_index)
|
||||
.map(|stmt| &stmt.kind)
|
||||
{
|
||||
if let Some(local) = place.as_local() {
|
||||
let local_decl = &self.body.local_decls[local];
|
||||
// opt_match_place is the
|
||||
// match_span is the span of the expression being matched on
|
||||
// match *x.y { ... } match_place is Some(*x.y)
|
||||
// ^^^^ match_span is the span of *x.y
|
||||
//
|
||||
// opt_match_place is None for let [mut] x = ... statements,
|
||||
// whether or not the right-hand side is a place expression
|
||||
if let LocalInfo::User(BindingForm::Var(VarBindingForm {
|
||||
opt_match_place: Some((opt_match_place, match_span)),
|
||||
binding_mode: _,
|
||||
opt_ty_info: _,
|
||||
pat_span: _,
|
||||
})) = *local_decl.local_info()
|
||||
{
|
||||
let stmt_source_info = self.body.source_info(location);
|
||||
self.append_binding_error(
|
||||
grouped_errors,
|
||||
kind,
|
||||
original_path,
|
||||
*move_from,
|
||||
local,
|
||||
opt_match_place,
|
||||
match_span,
|
||||
stmt_source_info.span,
|
||||
);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let move_spans = self.move_spans(original_path.as_ref(), location);
|
||||
grouped_errors.push(GroupedMoveError::OtherIllegalMove {
|
||||
use_spans: move_spans,
|
||||
original_path,
|
||||
kind,
|
||||
});
|
||||
}
|
||||
|
||||
fn append_binding_error(
|
||||
|
@ -31,13 +31,8 @@ use rustc_index::{IndexSlice, IndexVec};
|
||||
use rustc_infer::infer::{
|
||||
InferCtxt, NllRegionVariableOrigin, RegionVariableOrigin, TyCtxtInferExt,
|
||||
};
|
||||
use rustc_middle::mir::{
|
||||
traversal, Body, ClearCrossCrate, Local, Location, MutBorrowKind, Mutability,
|
||||
NonDivergingIntrinsic, Operand, Place, PlaceElem, PlaceRef, VarDebugInfoContents,
|
||||
};
|
||||
use rustc_middle::mir::{AggregateKind, BasicBlock, BorrowCheckResult, BorrowKind};
|
||||
use rustc_middle::mir::{InlineAsmOperand, Terminator, TerminatorKind};
|
||||
use rustc_middle::mir::{ProjectionElem, Promoted, Rvalue, Statement, StatementKind};
|
||||
use rustc_middle::mir::tcx::PlaceTy;
|
||||
use rustc_middle::mir::*;
|
||||
use rustc_middle::query::Providers;
|
||||
use rustc_middle::traits::DefiningAnchor;
|
||||
use rustc_middle::ty::{self, CapturedPlace, ParamEnv, RegionVid, TyCtxt};
|
||||
@ -55,13 +50,13 @@ use rustc_mir_dataflow::impls::{
|
||||
EverInitializedPlaces, MaybeInitializedPlaces, MaybeUninitializedPlaces,
|
||||
};
|
||||
use rustc_mir_dataflow::move_paths::{InitIndex, MoveOutIndex, MovePathIndex};
|
||||
use rustc_mir_dataflow::move_paths::{InitLocation, LookupResult, MoveData, MoveError};
|
||||
use rustc_mir_dataflow::move_paths::{InitLocation, LookupResult, MoveData};
|
||||
use rustc_mir_dataflow::Analysis;
|
||||
use rustc_mir_dataflow::MoveDataParamEnv;
|
||||
|
||||
use crate::session_diagnostics::VarNeedNotMut;
|
||||
|
||||
use self::diagnostics::{AccessKind, RegionName};
|
||||
use self::diagnostics::{AccessKind, IllegalMoveOriginKind, MoveError, RegionName};
|
||||
use self::location::LocationTable;
|
||||
use self::prefixes::PrefixSet;
|
||||
use consumers::{BodyWithBorrowckFacts, ConsumerOptions};
|
||||
@ -224,14 +219,10 @@ fn do_mir_borrowck<'tcx>(
|
||||
let location_table_owned = LocationTable::new(body);
|
||||
let location_table = &location_table_owned;
|
||||
|
||||
let (move_data, move_errors): (MoveData<'tcx>, Vec<(Place<'tcx>, MoveError<'tcx>)>) =
|
||||
match MoveData::gather_moves(&body, tcx, param_env) {
|
||||
Ok(move_data) => (move_data, Vec::new()),
|
||||
Err((move_data, move_errors)) => (move_data, move_errors),
|
||||
};
|
||||
let promoted_errors = promoted
|
||||
let move_data = MoveData::gather_moves(&body, tcx, param_env, |_| true);
|
||||
let promoted_move_data = promoted
|
||||
.iter_enumerated()
|
||||
.map(|(idx, body)| (idx, MoveData::gather_moves(&body, tcx, param_env)));
|
||||
.map(|(idx, body)| (idx, MoveData::gather_moves(&body, tcx, param_env, |_| true)));
|
||||
|
||||
let mdpe = MoveDataParamEnv { move_data, param_env };
|
||||
|
||||
@ -313,36 +304,49 @@ fn do_mir_borrowck<'tcx>(
|
||||
true
|
||||
};
|
||||
|
||||
for (idx, move_data_results) in promoted_errors {
|
||||
let promoted_body = &promoted[idx];
|
||||
for (idx, move_data) in promoted_move_data {
|
||||
use rustc_middle::mir::visit::Visitor;
|
||||
|
||||
if let Err((move_data, move_errors)) = move_data_results {
|
||||
let mut promoted_mbcx = MirBorrowckCtxt {
|
||||
infcx: &infcx,
|
||||
param_env,
|
||||
body: promoted_body,
|
||||
move_data: &move_data,
|
||||
location_table, // no need to create a real one for the promoted, it is not used
|
||||
movable_coroutine,
|
||||
fn_self_span_reported: Default::default(),
|
||||
locals_are_invalidated_at_exit,
|
||||
access_place_error_reported: Default::default(),
|
||||
reservation_error_reported: Default::default(),
|
||||
uninitialized_error_reported: Default::default(),
|
||||
regioncx: regioncx.clone(),
|
||||
used_mut: Default::default(),
|
||||
used_mut_upvars: SmallVec::new(),
|
||||
borrow_set: Rc::clone(&borrow_set),
|
||||
upvars: Vec::new(),
|
||||
local_names: IndexVec::from_elem(None, &promoted_body.local_decls),
|
||||
region_names: RefCell::default(),
|
||||
next_region_name: RefCell::new(1),
|
||||
polonius_output: None,
|
||||
errors,
|
||||
};
|
||||
promoted_mbcx.report_move_errors(move_errors);
|
||||
errors = promoted_mbcx.errors;
|
||||
let promoted_body = &promoted[idx];
|
||||
let mut promoted_mbcx = MirBorrowckCtxt {
|
||||
infcx: &infcx,
|
||||
param_env,
|
||||
body: promoted_body,
|
||||
move_data: &move_data,
|
||||
location_table, // no need to create a real one for the promoted, it is not used
|
||||
movable_coroutine,
|
||||
fn_self_span_reported: Default::default(),
|
||||
locals_are_invalidated_at_exit,
|
||||
access_place_error_reported: Default::default(),
|
||||
reservation_error_reported: Default::default(),
|
||||
uninitialized_error_reported: Default::default(),
|
||||
regioncx: regioncx.clone(),
|
||||
used_mut: Default::default(),
|
||||
used_mut_upvars: SmallVec::new(),
|
||||
borrow_set: Rc::clone(&borrow_set),
|
||||
upvars: Vec::new(),
|
||||
local_names: IndexVec::from_elem(None, &promoted_body.local_decls),
|
||||
region_names: RefCell::default(),
|
||||
next_region_name: RefCell::new(1),
|
||||
polonius_output: None,
|
||||
move_errors: Vec::new(),
|
||||
errors,
|
||||
};
|
||||
MoveVisitor { ctxt: &mut promoted_mbcx }.visit_body(promoted_body);
|
||||
promoted_mbcx.report_move_errors();
|
||||
errors = promoted_mbcx.errors;
|
||||
|
||||
struct MoveVisitor<'a, 'cx, 'tcx> {
|
||||
ctxt: &'a mut MirBorrowckCtxt<'cx, 'tcx>,
|
||||
}
|
||||
|
||||
impl<'tcx> Visitor<'tcx> for MoveVisitor<'_, '_, 'tcx> {
|
||||
fn visit_operand(&mut self, operand: &Operand<'tcx>, location: Location) {
|
||||
if let Operand::Move(place) = operand {
|
||||
self.ctxt.check_movable_place(location, *place);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let mut mbcx = MirBorrowckCtxt {
|
||||
@ -366,6 +370,7 @@ fn do_mir_borrowck<'tcx>(
|
||||
region_names: RefCell::default(),
|
||||
next_region_name: RefCell::new(1),
|
||||
polonius_output,
|
||||
move_errors: Vec::new(),
|
||||
errors,
|
||||
};
|
||||
|
||||
@ -378,8 +383,6 @@ fn do_mir_borrowck<'tcx>(
|
||||
borrows: flow_borrows,
|
||||
};
|
||||
|
||||
mbcx.report_move_errors(move_errors);
|
||||
|
||||
rustc_mir_dataflow::visit_results(
|
||||
body,
|
||||
traversal::reverse_postorder(body).map(|(bb, _)| bb),
|
||||
@ -387,6 +390,8 @@ fn do_mir_borrowck<'tcx>(
|
||||
&mut mbcx,
|
||||
);
|
||||
|
||||
mbcx.report_move_errors();
|
||||
|
||||
// For each non-user used mutable variable, check if it's been assigned from
|
||||
// a user-declared local. If so, then put that local into the used_mut set.
|
||||
// Note that this set is expected to be small - only upvars from closures
|
||||
@ -595,6 +600,7 @@ struct MirBorrowckCtxt<'cx, 'tcx> {
|
||||
polonius_output: Option<Rc<PoloniusOutput>>,
|
||||
|
||||
errors: error::BorrowckErrors<'tcx>,
|
||||
move_errors: Vec<MoveError<'tcx>>,
|
||||
}
|
||||
|
||||
// Check that:
|
||||
@ -725,7 +731,6 @@ impl<'cx, 'tcx, R> rustc_mir_dataflow::ResultsVisitor<'cx, 'tcx, R> for MirBorro
|
||||
}
|
||||
TerminatorKind::Assert { cond, expected: _, msg, target: _, unwind: _ } => {
|
||||
self.consume_operand(loc, (cond, span), flow_state);
|
||||
use rustc_middle::mir::AssertKind;
|
||||
if let AssertKind::BoundsCheck { len, index } = &**msg {
|
||||
self.consume_operand(loc, (len, span), flow_state);
|
||||
self.consume_operand(loc, (index, span), flow_state);
|
||||
@ -1409,7 +1414,9 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
|
||||
// As such we have to search for the local that this
|
||||
// capture comes from and mark it as being used as mut.
|
||||
|
||||
let temp_mpi = self.move_data.rev_lookup.find_local(local);
|
||||
let Some(temp_mpi) = self.move_data.rev_lookup.find_local(local) else {
|
||||
bug!("temporary should be tracked");
|
||||
};
|
||||
let init = if let [init_index] = *self.move_data.init_path_map[temp_mpi] {
|
||||
&self.move_data.inits[init_index]
|
||||
} else {
|
||||
@ -1469,6 +1476,9 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
|
||||
);
|
||||
}
|
||||
Operand::Move(place) => {
|
||||
// Check if moving from this place makes sense.
|
||||
self.check_movable_place(location, place);
|
||||
|
||||
// move of place: check if this is move of already borrowed path
|
||||
self.access_place(
|
||||
location,
|
||||
@ -1590,6 +1600,131 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
|
||||
}
|
||||
}
|
||||
|
||||
fn check_movable_place(&mut self, location: Location, place: Place<'tcx>) {
|
||||
use IllegalMoveOriginKind::*;
|
||||
|
||||
let body = self.body;
|
||||
let tcx = self.infcx.tcx;
|
||||
let mut place_ty = PlaceTy::from_ty(body.local_decls[place.local].ty);
|
||||
for (place_ref, elem) in place.iter_projections() {
|
||||
match elem {
|
||||
ProjectionElem::Deref => match place_ty.ty.kind() {
|
||||
ty::Ref(..) | ty::RawPtr(..) => {
|
||||
self.move_errors.push(MoveError::new(
|
||||
place,
|
||||
location,
|
||||
BorrowedContent {
|
||||
target_place: place_ref.project_deeper(&[elem], tcx),
|
||||
},
|
||||
));
|
||||
return;
|
||||
}
|
||||
ty::Adt(adt, _) => {
|
||||
if !adt.is_box() {
|
||||
bug!("Adt should be a box type when Place is deref");
|
||||
}
|
||||
}
|
||||
ty::Bool
|
||||
| ty::Char
|
||||
| ty::Int(_)
|
||||
| ty::Uint(_)
|
||||
| ty::Float(_)
|
||||
| ty::Foreign(_)
|
||||
| ty::Str
|
||||
| ty::Array(_, _)
|
||||
| ty::Slice(_)
|
||||
| ty::FnDef(_, _)
|
||||
| ty::FnPtr(_)
|
||||
| ty::Dynamic(_, _, _)
|
||||
| ty::Closure(_, _)
|
||||
| ty::Coroutine(_, _, _)
|
||||
| ty::CoroutineWitness(..)
|
||||
| ty::Never
|
||||
| ty::Tuple(_)
|
||||
| ty::Alias(_, _)
|
||||
| ty::Param(_)
|
||||
| ty::Bound(_, _)
|
||||
| ty::Infer(_)
|
||||
| ty::Error(_)
|
||||
| ty::Placeholder(_) => {
|
||||
bug!("When Place is Deref it's type shouldn't be {place_ty:#?}")
|
||||
}
|
||||
},
|
||||
ProjectionElem::Field(_, _) => match place_ty.ty.kind() {
|
||||
ty::Adt(adt, _) => {
|
||||
if adt.has_dtor(tcx) {
|
||||
self.move_errors.push(MoveError::new(
|
||||
place,
|
||||
location,
|
||||
InteriorOfTypeWithDestructor { container_ty: place_ty.ty },
|
||||
));
|
||||
return;
|
||||
}
|
||||
}
|
||||
ty::Closure(_, _) | ty::Coroutine(_, _, _) | ty::Tuple(_) => (),
|
||||
ty::Bool
|
||||
| ty::Char
|
||||
| ty::Int(_)
|
||||
| ty::Uint(_)
|
||||
| ty::Float(_)
|
||||
| ty::Foreign(_)
|
||||
| ty::Str
|
||||
| ty::Array(_, _)
|
||||
| ty::Slice(_)
|
||||
| ty::RawPtr(_)
|
||||
| ty::Ref(_, _, _)
|
||||
| ty::FnDef(_, _)
|
||||
| ty::FnPtr(_)
|
||||
| ty::Dynamic(_, _, _)
|
||||
| ty::CoroutineWitness(..)
|
||||
| ty::Never
|
||||
| ty::Alias(_, _)
|
||||
| ty::Param(_)
|
||||
| ty::Bound(_, _)
|
||||
| ty::Infer(_)
|
||||
| ty::Error(_)
|
||||
| ty::Placeholder(_) => bug!(
|
||||
"When Place contains ProjectionElem::Field it's type shouldn't be {place_ty:#?}"
|
||||
),
|
||||
},
|
||||
ProjectionElem::ConstantIndex { .. } | ProjectionElem::Subslice { .. } => {
|
||||
match place_ty.ty.kind() {
|
||||
ty::Slice(_) => {
|
||||
self.move_errors.push(MoveError::new(
|
||||
place,
|
||||
location,
|
||||
InteriorOfSliceOrArray { ty: place_ty.ty, is_index: false },
|
||||
));
|
||||
return;
|
||||
}
|
||||
ty::Array(_, _) => (),
|
||||
_ => bug!("Unexpected type {:#?}", place_ty.ty),
|
||||
}
|
||||
}
|
||||
ProjectionElem::Index(_) => match place_ty.ty.kind() {
|
||||
ty::Array(..) | ty::Slice(..) => {
|
||||
self.move_errors.push(MoveError::new(
|
||||
place,
|
||||
location,
|
||||
InteriorOfSliceOrArray { ty: place_ty.ty, is_index: true },
|
||||
));
|
||||
return;
|
||||
}
|
||||
_ => bug!("Unexpected type {place_ty:#?}"),
|
||||
},
|
||||
// `OpaqueCast`: only transmutes the type, so no moves there.
|
||||
// `Downcast` : only changes information about a `Place` without moving.
|
||||
// `Subtype` : only transmutes the type, so no moves.
|
||||
// So it's safe to skip these.
|
||||
ProjectionElem::OpaqueCast(_)
|
||||
| ProjectionElem::Subtype(_)
|
||||
| ProjectionElem::Downcast(_, _) => (),
|
||||
}
|
||||
|
||||
place_ty = place_ty.projection_ty(tcx, elem);
|
||||
}
|
||||
}
|
||||
|
||||
fn check_if_full_path_is_moved(
|
||||
&mut self,
|
||||
location: Location,
|
||||
@ -2074,7 +2209,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
|
||||
local: Local,
|
||||
flow_state: &Flows<'cx, 'tcx>,
|
||||
) -> Option<InitIndex> {
|
||||
let mpi = self.move_data.rev_lookup.find_local(local);
|
||||
let mpi = self.move_data.rev_lookup.find_local(local)?;
|
||||
let ii = &self.move_data.init_path_map[mpi];
|
||||
ii.into_iter().find(|&&index| flow_state.ever_inits.contains(index)).copied()
|
||||
}
|
||||
|
@ -317,7 +317,7 @@ impl<'me, 'typeck, 'flow, 'tcx> LivenessResults<'me, 'typeck, 'flow, 'tcx> {
|
||||
fn compute_drop_live_points_for(&mut self, local: Local) {
|
||||
debug!("compute_drop_live_points_for(local={:?})", local);
|
||||
|
||||
let mpi = self.cx.move_data.rev_lookup.find_local(local);
|
||||
let Some(mpi) = self.cx.move_data.rev_lookup.find_local(local) else { return };
|
||||
debug!("compute_drop_live_points_for: mpi = {:?}", mpi);
|
||||
|
||||
// Find the drops where `local` is initialized.
|
||||
|
@ -1,6 +1,6 @@
|
||||
use crate::elaborate_drops::DropFlagState;
|
||||
use rustc_middle::mir::{self, Body, Location, Terminator, TerminatorKind};
|
||||
use rustc_middle::ty::{self, TyCtxt};
|
||||
use rustc_middle::ty::TyCtxt;
|
||||
use rustc_target::abi::VariantIdx;
|
||||
|
||||
use super::indexes::MovePathIndex;
|
||||
@ -55,60 +55,6 @@ pub fn on_all_children_bits<'tcx, F>(
|
||||
) where
|
||||
F: FnMut(MovePathIndex),
|
||||
{
|
||||
#[inline]
|
||||
fn is_terminal_path<'tcx>(
|
||||
tcx: TyCtxt<'tcx>,
|
||||
body: &Body<'tcx>,
|
||||
move_data: &MoveData<'tcx>,
|
||||
path: MovePathIndex,
|
||||
) -> bool {
|
||||
let place = move_data.move_paths[path].place;
|
||||
|
||||
// When enumerating the child fragments of a path, don't recurse into
|
||||
// paths (1.) past arrays, slices, and pointers, nor (2.) into a type
|
||||
// that implements `Drop`.
|
||||
//
|
||||
// Places behind references or arrays are not tracked by elaboration
|
||||
// and are always assumed to be initialized when accessible. As
|
||||
// references and indexes can be reseated, trying to track them can
|
||||
// only lead to trouble.
|
||||
//
|
||||
// Places behind ADT's with a Drop impl are not tracked by
|
||||
// elaboration since they can never have a drop-flag state that
|
||||
// differs from that of the parent with the Drop impl.
|
||||
//
|
||||
// In both cases, the contents can only be accessed if and only if
|
||||
// their parents are initialized. This implies for example that there
|
||||
// is no need to maintain separate drop flags to track such state.
|
||||
//
|
||||
// FIXME: we have to do something for moving slice patterns.
|
||||
let ty = place.ty(body, tcx).ty;
|
||||
match ty.kind() {
|
||||
ty::Adt(def, _) if (def.has_dtor(tcx) && !def.is_box()) || def.is_union() => {
|
||||
debug!(
|
||||
"place_contents_drop_state_cannot_differ place: {:?} ty: {:?} Drop => true",
|
||||
place, ty
|
||||
);
|
||||
true
|
||||
}
|
||||
ty::Array(..) => {
|
||||
debug!(
|
||||
"place_contents_drop_state_cannot_differ place: {:?} ty: {:?} => false",
|
||||
place, ty
|
||||
);
|
||||
false
|
||||
}
|
||||
ty::Slice(..) | ty::Ref(..) | ty::RawPtr(..) => {
|
||||
debug!(
|
||||
"place_contents_drop_state_cannot_differ place: {:?} ty: {:?} refd => true",
|
||||
place, ty
|
||||
);
|
||||
true
|
||||
}
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
fn on_all_children_bits<'tcx, F>(
|
||||
tcx: TyCtxt<'tcx>,
|
||||
body: &Body<'tcx>,
|
||||
@ -120,10 +66,6 @@ pub fn on_all_children_bits<'tcx, F>(
|
||||
{
|
||||
each_child(move_path_index);
|
||||
|
||||
if is_terminal_path(tcx, body, move_data, move_path_index) {
|
||||
return;
|
||||
}
|
||||
|
||||
let mut next_child_index = move_data.move_paths[move_path_index].first_child;
|
||||
while let Some(child_index) = next_child_index {
|
||||
on_all_children_bits(tcx, body, move_data, child_index, each_child);
|
||||
@ -133,29 +75,6 @@ pub fn on_all_children_bits<'tcx, F>(
|
||||
on_all_children_bits(tcx, body, move_data, move_path_index, &mut each_child);
|
||||
}
|
||||
|
||||
pub fn on_all_drop_children_bits<'tcx, F>(
|
||||
tcx: TyCtxt<'tcx>,
|
||||
body: &Body<'tcx>,
|
||||
ctxt: &MoveDataParamEnv<'tcx>,
|
||||
path: MovePathIndex,
|
||||
mut each_child: F,
|
||||
) where
|
||||
F: FnMut(MovePathIndex),
|
||||
{
|
||||
on_all_children_bits(tcx, body, &ctxt.move_data, path, |child| {
|
||||
let place = &ctxt.move_data.move_paths[path].place;
|
||||
let ty = place.ty(body, tcx).ty;
|
||||
debug!("on_all_drop_children_bits({:?}, {:?} : {:?})", path, place, ty);
|
||||
|
||||
let erased_ty = tcx.erase_regions(ty);
|
||||
if erased_ty.needs_drop(tcx, ctxt.param_env) {
|
||||
each_child(child);
|
||||
} else {
|
||||
debug!("on_all_drop_children_bits - skipping")
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
pub fn drop_flag_effects_for_function_entry<'tcx, F>(
|
||||
tcx: TyCtxt<'tcx>,
|
||||
body: &Body<'tcx>,
|
||||
|
@ -10,7 +10,7 @@ use crate::framework::SwitchIntEdgeEffects;
|
||||
use crate::move_paths::{HasMoveData, InitIndex, InitKind, LookupResult, MoveData, MovePathIndex};
|
||||
use crate::on_lookup_result_bits;
|
||||
use crate::MoveDataParamEnv;
|
||||
use crate::{drop_flag_effects, on_all_children_bits, on_all_drop_children_bits};
|
||||
use crate::{drop_flag_effects, on_all_children_bits};
|
||||
use crate::{lattice, AnalysisDomain, GenKill, GenKillAnalysis, MaybeReachable};
|
||||
|
||||
/// `MaybeInitializedPlaces` tracks all places that might be
|
||||
@ -72,7 +72,7 @@ impl<'a, 'tcx> MaybeInitializedPlaces<'a, 'tcx> {
|
||||
) -> bool {
|
||||
if let LookupResult::Exact(path) = self.move_data().rev_lookup.find(place.as_ref()) {
|
||||
let mut maybe_live = false;
|
||||
on_all_drop_children_bits(self.tcx, self.body, self.mdpe, path, |child| {
|
||||
on_all_children_bits(self.tcx, self.body, self.move_data(), path, |child| {
|
||||
maybe_live |= state.contains(child);
|
||||
});
|
||||
!maybe_live
|
||||
@ -690,9 +690,13 @@ impl<'tcx> GenKillAnalysis<'tcx> for EverInitializedPlaces<'_, 'tcx> {
|
||||
if let mir::StatementKind::StorageDead(local) = stmt.kind {
|
||||
// End inits for StorageDead, so that an immutable variable can
|
||||
// be reinitialized on the next iteration of the loop.
|
||||
let move_path_index = rev_lookup.find_local(local);
|
||||
debug!("clears the ever initialized status of {:?}", init_path_map[move_path_index]);
|
||||
trans.kill_all(init_path_map[move_path_index].iter().copied());
|
||||
if let Some(move_path_index) = rev_lookup.find_local(local) {
|
||||
debug!(
|
||||
"clears the ever initialized status of {:?}",
|
||||
init_path_map[move_path_index]
|
||||
);
|
||||
trans.kill_all(init_path_map[move_path_index].iter().copied());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -23,8 +23,7 @@ use rustc_span::symbol::{sym, Symbol};
|
||||
|
||||
pub use self::drop_flag_effects::{
|
||||
drop_flag_effects_for_function_entry, drop_flag_effects_for_location,
|
||||
move_path_children_matching, on_all_children_bits, on_all_drop_children_bits,
|
||||
on_lookup_result_bits,
|
||||
move_path_children_matching, on_all_children_bits, on_lookup_result_bits,
|
||||
};
|
||||
pub use self::framework::{
|
||||
fmt, graphviz, lattice, visit_results, Analysis, AnalysisDomain, AnalysisResults, Backward,
|
||||
|
@ -1,58 +1,66 @@
|
||||
use rustc_index::IndexVec;
|
||||
use rustc_middle::mir::tcx::RvalueInitializationState;
|
||||
use rustc_middle::mir::tcx::{PlaceTy, RvalueInitializationState};
|
||||
use rustc_middle::mir::*;
|
||||
use rustc_middle::ty::{self, TyCtxt};
|
||||
use rustc_middle::ty::{self, Ty, TyCtxt};
|
||||
use smallvec::{smallvec, SmallVec};
|
||||
|
||||
use std::mem;
|
||||
|
||||
use super::abs_domain::Lift;
|
||||
use super::IllegalMoveOriginKind::*;
|
||||
use super::{Init, InitIndex, InitKind, InitLocation, LookupResult, MoveError};
|
||||
use super::{Init, InitIndex, InitKind, InitLocation, LookupResult};
|
||||
use super::{
|
||||
LocationMap, MoveData, MoveOut, MoveOutIndex, MovePath, MovePathIndex, MovePathLookup,
|
||||
};
|
||||
|
||||
struct MoveDataBuilder<'a, 'tcx> {
|
||||
struct MoveDataBuilder<'a, 'tcx, F> {
|
||||
body: &'a Body<'tcx>,
|
||||
tcx: TyCtxt<'tcx>,
|
||||
param_env: ty::ParamEnv<'tcx>,
|
||||
data: MoveData<'tcx>,
|
||||
errors: Vec<(Place<'tcx>, MoveError<'tcx>)>,
|
||||
filter: F,
|
||||
}
|
||||
|
||||
impl<'a, 'tcx> MoveDataBuilder<'a, 'tcx> {
|
||||
fn new(body: &'a Body<'tcx>, tcx: TyCtxt<'tcx>, param_env: ty::ParamEnv<'tcx>) -> Self {
|
||||
impl<'a, 'tcx, F: Fn(Ty<'tcx>) -> bool> MoveDataBuilder<'a, 'tcx, F> {
|
||||
fn new(
|
||||
body: &'a Body<'tcx>,
|
||||
tcx: TyCtxt<'tcx>,
|
||||
param_env: ty::ParamEnv<'tcx>,
|
||||
filter: F,
|
||||
) -> Self {
|
||||
let mut move_paths = IndexVec::new();
|
||||
let mut path_map = IndexVec::new();
|
||||
let mut init_path_map = IndexVec::new();
|
||||
|
||||
let locals = body
|
||||
.local_decls
|
||||
.iter_enumerated()
|
||||
.map(|(i, l)| {
|
||||
if l.is_deref_temp() {
|
||||
return None;
|
||||
}
|
||||
if filter(l.ty) {
|
||||
Some(new_move_path(
|
||||
&mut move_paths,
|
||||
&mut path_map,
|
||||
&mut init_path_map,
|
||||
None,
|
||||
Place::from(i),
|
||||
))
|
||||
} else {
|
||||
None
|
||||
}
|
||||
})
|
||||
.collect();
|
||||
|
||||
MoveDataBuilder {
|
||||
body,
|
||||
tcx,
|
||||
param_env,
|
||||
errors: Vec::new(),
|
||||
data: MoveData {
|
||||
moves: IndexVec::new(),
|
||||
loc_map: LocationMap::new(body),
|
||||
rev_lookup: MovePathLookup {
|
||||
locals: body
|
||||
.local_decls
|
||||
.iter_enumerated()
|
||||
.map(|(i, l)| {
|
||||
if l.is_deref_temp() {
|
||||
MovePathIndex::MAX
|
||||
} else {
|
||||
Self::new_move_path(
|
||||
&mut move_paths,
|
||||
&mut path_map,
|
||||
&mut init_path_map,
|
||||
None,
|
||||
Place::from(i),
|
||||
)
|
||||
}
|
||||
})
|
||||
.collect(),
|
||||
locals,
|
||||
projections: Default::default(),
|
||||
un_derefer: Default::default(),
|
||||
},
|
||||
@ -62,35 +70,42 @@ impl<'a, 'tcx> MoveDataBuilder<'a, 'tcx> {
|
||||
init_loc_map: LocationMap::new(body),
|
||||
init_path_map,
|
||||
},
|
||||
filter,
|
||||
}
|
||||
}
|
||||
|
||||
fn new_move_path(
|
||||
move_paths: &mut IndexVec<MovePathIndex, MovePath<'tcx>>,
|
||||
path_map: &mut IndexVec<MovePathIndex, SmallVec<[MoveOutIndex; 4]>>,
|
||||
init_path_map: &mut IndexVec<MovePathIndex, SmallVec<[InitIndex; 4]>>,
|
||||
parent: Option<MovePathIndex>,
|
||||
place: Place<'tcx>,
|
||||
) -> MovePathIndex {
|
||||
let move_path =
|
||||
move_paths.push(MovePath { next_sibling: None, first_child: None, parent, place });
|
||||
|
||||
if let Some(parent) = parent {
|
||||
let next_sibling = mem::replace(&mut move_paths[parent].first_child, Some(move_path));
|
||||
move_paths[move_path].next_sibling = next_sibling;
|
||||
}
|
||||
|
||||
let path_map_ent = path_map.push(smallvec![]);
|
||||
assert_eq!(path_map_ent, move_path);
|
||||
|
||||
let init_path_map_ent = init_path_map.push(smallvec![]);
|
||||
assert_eq!(init_path_map_ent, move_path);
|
||||
|
||||
move_path
|
||||
}
|
||||
}
|
||||
|
||||
impl<'b, 'a, 'tcx> Gatherer<'b, 'a, 'tcx> {
|
||||
fn new_move_path<'tcx>(
|
||||
move_paths: &mut IndexVec<MovePathIndex, MovePath<'tcx>>,
|
||||
path_map: &mut IndexVec<MovePathIndex, SmallVec<[MoveOutIndex; 4]>>,
|
||||
init_path_map: &mut IndexVec<MovePathIndex, SmallVec<[InitIndex; 4]>>,
|
||||
parent: Option<MovePathIndex>,
|
||||
place: Place<'tcx>,
|
||||
) -> MovePathIndex {
|
||||
let move_path =
|
||||
move_paths.push(MovePath { next_sibling: None, first_child: None, parent, place });
|
||||
|
||||
if let Some(parent) = parent {
|
||||
let next_sibling = mem::replace(&mut move_paths[parent].first_child, Some(move_path));
|
||||
move_paths[move_path].next_sibling = next_sibling;
|
||||
}
|
||||
|
||||
let path_map_ent = path_map.push(smallvec![]);
|
||||
assert_eq!(path_map_ent, move_path);
|
||||
|
||||
let init_path_map_ent = init_path_map.push(smallvec![]);
|
||||
assert_eq!(init_path_map_ent, move_path);
|
||||
|
||||
move_path
|
||||
}
|
||||
|
||||
enum MovePathResult {
|
||||
Path(MovePathIndex),
|
||||
Union(MovePathIndex),
|
||||
Error,
|
||||
}
|
||||
|
||||
impl<'b, 'a, 'tcx, F: Fn(Ty<'tcx>) -> bool> Gatherer<'b, 'a, 'tcx, F> {
|
||||
/// This creates a MovePath for a given place, returning an `MovePathError`
|
||||
/// if that place can't be moved from.
|
||||
///
|
||||
@ -98,11 +113,13 @@ impl<'b, 'a, 'tcx> Gatherer<'b, 'a, 'tcx> {
|
||||
/// problematic for borrowck.
|
||||
///
|
||||
/// Maybe we should have separate "borrowck" and "moveck" modes.
|
||||
fn move_path_for(&mut self, place: Place<'tcx>) -> Result<MovePathIndex, MoveError<'tcx>> {
|
||||
fn move_path_for(&mut self, place: Place<'tcx>) -> MovePathResult {
|
||||
let data = &mut self.builder.data;
|
||||
|
||||
debug!("lookup({:?})", place);
|
||||
let mut base = data.rev_lookup.find_local(place.local);
|
||||
let Some(mut base) = data.rev_lookup.find_local(place.local) else {
|
||||
return MovePathResult::Error;
|
||||
};
|
||||
|
||||
// The move path index of the first union that we find. Once this is
|
||||
// some we stop creating child move paths, since moves from unions
|
||||
@ -118,12 +135,7 @@ impl<'b, 'a, 'tcx> Gatherer<'b, 'a, 'tcx> {
|
||||
match elem {
|
||||
ProjectionElem::Deref => match place_ty.kind() {
|
||||
ty::Ref(..) | ty::RawPtr(..) => {
|
||||
return Err(MoveError::cannot_move_out_of(
|
||||
self.loc,
|
||||
BorrowedContent {
|
||||
target_place: place_ref.project_deeper(&[elem], tcx),
|
||||
},
|
||||
));
|
||||
return MovePathResult::Error;
|
||||
}
|
||||
ty::Adt(adt, _) => {
|
||||
if !adt.is_box() {
|
||||
@ -159,10 +171,7 @@ impl<'b, 'a, 'tcx> Gatherer<'b, 'a, 'tcx> {
|
||||
ProjectionElem::Field(_, _) => match place_ty.kind() {
|
||||
ty::Adt(adt, _) => {
|
||||
if adt.has_dtor(tcx) {
|
||||
return Err(MoveError::cannot_move_out_of(
|
||||
self.loc,
|
||||
InteriorOfTypeWithDestructor { container_ty: place_ty },
|
||||
));
|
||||
return MovePathResult::Error;
|
||||
}
|
||||
if adt.is_union() {
|
||||
union_path.get_or_insert(base);
|
||||
@ -197,33 +206,15 @@ impl<'b, 'a, 'tcx> Gatherer<'b, 'a, 'tcx> {
|
||||
ProjectionElem::ConstantIndex { .. } | ProjectionElem::Subslice { .. } => {
|
||||
match place_ty.kind() {
|
||||
ty::Slice(_) => {
|
||||
return Err(MoveError::cannot_move_out_of(
|
||||
self.loc,
|
||||
InteriorOfSliceOrArray {
|
||||
ty: place_ty,
|
||||
is_index: matches!(elem, ProjectionElem::Index(..)),
|
||||
},
|
||||
));
|
||||
return MovePathResult::Error;
|
||||
}
|
||||
ty::Array(_, _) => (),
|
||||
_ => bug!("Unexpected type {:#?}", place_ty.is_array()),
|
||||
}
|
||||
}
|
||||
ProjectionElem::Index(_) => match place_ty.kind() {
|
||||
ty::Array(..) => {
|
||||
return Err(MoveError::cannot_move_out_of(
|
||||
self.loc,
|
||||
InteriorOfSliceOrArray { ty: place_ty, is_index: true },
|
||||
));
|
||||
}
|
||||
ty::Slice(_) => {
|
||||
return Err(MoveError::cannot_move_out_of(
|
||||
self.loc,
|
||||
InteriorOfSliceOrArray {
|
||||
ty: place_ty,
|
||||
is_index: matches!(elem, ProjectionElem::Index(..)),
|
||||
},
|
||||
));
|
||||
ty::Array(..) | ty::Slice(_) => {
|
||||
return MovePathResult::Error;
|
||||
}
|
||||
_ => bug!("Unexpected type {place_ty:#?}"),
|
||||
},
|
||||
@ -235,11 +226,15 @@ impl<'b, 'a, 'tcx> Gatherer<'b, 'a, 'tcx> {
|
||||
| ProjectionElem::Subtype(_)
|
||||
| ProjectionElem::Downcast(_, _) => (),
|
||||
}
|
||||
let elem_ty = PlaceTy::from_ty(place_ty).projection_ty(tcx, elem).ty;
|
||||
if !(self.builder.filter)(elem_ty) {
|
||||
return MovePathResult::Error;
|
||||
}
|
||||
if union_path.is_none() {
|
||||
// inlined from add_move_path because of a borrowck conflict with the iterator
|
||||
base =
|
||||
*data.rev_lookup.projections.entry((base, elem.lift())).or_insert_with(|| {
|
||||
MoveDataBuilder::new_move_path(
|
||||
new_move_path(
|
||||
&mut data.move_paths,
|
||||
&mut data.path_map,
|
||||
&mut data.init_path_map,
|
||||
@ -252,9 +247,9 @@ impl<'b, 'a, 'tcx> Gatherer<'b, 'a, 'tcx> {
|
||||
|
||||
if let Some(base) = union_path {
|
||||
// Move out of union - always move the entire union.
|
||||
Err(MoveError::UnionMove { path: base })
|
||||
MovePathResult::Union(base)
|
||||
} else {
|
||||
Ok(base)
|
||||
MovePathResult::Path(base)
|
||||
}
|
||||
}
|
||||
|
||||
@ -270,13 +265,7 @@ impl<'b, 'a, 'tcx> Gatherer<'b, 'a, 'tcx> {
|
||||
..
|
||||
} = self.builder;
|
||||
*rev_lookup.projections.entry((base, elem.lift())).or_insert_with(move || {
|
||||
MoveDataBuilder::new_move_path(
|
||||
move_paths,
|
||||
path_map,
|
||||
init_path_map,
|
||||
Some(base),
|
||||
mk_place(*tcx),
|
||||
)
|
||||
new_move_path(move_paths, path_map, init_path_map, Some(base), mk_place(*tcx))
|
||||
})
|
||||
}
|
||||
|
||||
@ -287,11 +276,8 @@ impl<'b, 'a, 'tcx> Gatherer<'b, 'a, 'tcx> {
|
||||
}
|
||||
}
|
||||
|
||||
pub type MoveDat<'tcx> =
|
||||
Result<MoveData<'tcx>, (MoveData<'tcx>, Vec<(Place<'tcx>, MoveError<'tcx>)>)>;
|
||||
|
||||
impl<'a, 'tcx> MoveDataBuilder<'a, 'tcx> {
|
||||
fn finalize(self) -> MoveDat<'tcx> {
|
||||
impl<'a, 'tcx, F> MoveDataBuilder<'a, 'tcx, F> {
|
||||
fn finalize(self) -> MoveData<'tcx> {
|
||||
debug!("{}", {
|
||||
debug!("moves for {:?}:", self.body.span);
|
||||
for (j, mo) in self.data.moves.iter_enumerated() {
|
||||
@ -304,7 +290,7 @@ impl<'a, 'tcx> MoveDataBuilder<'a, 'tcx> {
|
||||
"done dumping moves"
|
||||
});
|
||||
|
||||
if self.errors.is_empty() { Ok(self.data) } else { Err((self.data, self.errors)) }
|
||||
self.data
|
||||
}
|
||||
}
|
||||
|
||||
@ -312,8 +298,9 @@ pub(super) fn gather_moves<'tcx>(
|
||||
body: &Body<'tcx>,
|
||||
tcx: TyCtxt<'tcx>,
|
||||
param_env: ty::ParamEnv<'tcx>,
|
||||
) -> MoveDat<'tcx> {
|
||||
let mut builder = MoveDataBuilder::new(body, tcx, param_env);
|
||||
filter: impl Fn(Ty<'tcx>) -> bool,
|
||||
) -> MoveData<'tcx> {
|
||||
let mut builder = MoveDataBuilder::new(body, tcx, param_env, filter);
|
||||
|
||||
builder.gather_args();
|
||||
|
||||
@ -330,20 +317,20 @@ pub(super) fn gather_moves<'tcx>(
|
||||
builder.finalize()
|
||||
}
|
||||
|
||||
impl<'a, 'tcx> MoveDataBuilder<'a, 'tcx> {
|
||||
impl<'a, 'tcx, F: Fn(Ty<'tcx>) -> bool> MoveDataBuilder<'a, 'tcx, F> {
|
||||
fn gather_args(&mut self) {
|
||||
for arg in self.body.args_iter() {
|
||||
let path = self.data.rev_lookup.find_local(arg);
|
||||
if let Some(path) = self.data.rev_lookup.find_local(arg) {
|
||||
let init = self.data.inits.push(Init {
|
||||
path,
|
||||
kind: InitKind::Deep,
|
||||
location: InitLocation::Argument(arg),
|
||||
});
|
||||
|
||||
let init = self.data.inits.push(Init {
|
||||
path,
|
||||
kind: InitKind::Deep,
|
||||
location: InitLocation::Argument(arg),
|
||||
});
|
||||
debug!("gather_args: adding init {:?} of {:?} for argument {:?}", init, path, arg);
|
||||
|
||||
debug!("gather_args: adding init {:?} of {:?} for argument {:?}", init, path, arg);
|
||||
|
||||
self.data.init_path_map[path].push(init);
|
||||
self.data.init_path_map[path].push(init);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -358,12 +345,12 @@ impl<'a, 'tcx> MoveDataBuilder<'a, 'tcx> {
|
||||
}
|
||||
}
|
||||
|
||||
struct Gatherer<'b, 'a, 'tcx> {
|
||||
builder: &'b mut MoveDataBuilder<'a, 'tcx>,
|
||||
struct Gatherer<'b, 'a, 'tcx, F> {
|
||||
builder: &'b mut MoveDataBuilder<'a, 'tcx, F>,
|
||||
loc: Location,
|
||||
}
|
||||
|
||||
impl<'b, 'a, 'tcx> Gatherer<'b, 'a, 'tcx> {
|
||||
impl<'b, 'a, 'tcx, F: Fn(Ty<'tcx>) -> bool> Gatherer<'b, 'a, 'tcx, F> {
|
||||
fn gather_statement(&mut self, stmt: &Statement<'tcx>) {
|
||||
match &stmt.kind {
|
||||
StatementKind::Assign(box (place, Rvalue::CopyForDeref(reffed))) => {
|
||||
@ -546,13 +533,12 @@ impl<'b, 'a, 'tcx> Gatherer<'b, 'a, 'tcx> {
|
||||
let base_place =
|
||||
Place { local: place.local, projection: self.builder.tcx.mk_place_elems(base) };
|
||||
let base_path = match self.move_path_for(base_place) {
|
||||
Ok(path) => path,
|
||||
Err(MoveError::UnionMove { path }) => {
|
||||
MovePathResult::Path(path) => path,
|
||||
MovePathResult::Union(path) => {
|
||||
self.record_move(place, path);
|
||||
return;
|
||||
}
|
||||
Err(error @ MoveError::IllegalMove { .. }) => {
|
||||
self.builder.errors.push((base_place, error));
|
||||
MovePathResult::Error => {
|
||||
return;
|
||||
}
|
||||
};
|
||||
@ -572,10 +558,10 @@ impl<'b, 'a, 'tcx> Gatherer<'b, 'a, 'tcx> {
|
||||
}
|
||||
} else {
|
||||
match self.move_path_for(place) {
|
||||
Ok(path) | Err(MoveError::UnionMove { path }) => self.record_move(place, path),
|
||||
Err(error @ MoveError::IllegalMove { .. }) => {
|
||||
self.builder.errors.push((place, error));
|
||||
MovePathResult::Path(path) | MovePathResult::Union(path) => {
|
||||
self.record_move(place, path)
|
||||
}
|
||||
MovePathResult::Error => {}
|
||||
};
|
||||
}
|
||||
}
|
||||
|
@ -1,4 +1,3 @@
|
||||
use crate::move_paths::builder::MoveDat;
|
||||
use crate::un_derefer::UnDerefer;
|
||||
use rustc_data_structures::fx::FxHashMap;
|
||||
use rustc_index::{IndexSlice, IndexVec};
|
||||
@ -291,7 +290,7 @@ impl Init {
|
||||
/// Tables mapping from a place to its MovePathIndex.
|
||||
#[derive(Debug)]
|
||||
pub struct MovePathLookup<'tcx> {
|
||||
locals: IndexVec<Local, MovePathIndex>,
|
||||
locals: IndexVec<Local, Option<MovePathIndex>>,
|
||||
|
||||
/// projections are made from a base-place and a projection
|
||||
/// elem. The base-place will have a unique MovePathIndex; we use
|
||||
@ -318,7 +317,9 @@ impl<'tcx> MovePathLookup<'tcx> {
|
||||
// unknown place, but will rather return the nearest available
|
||||
// parent.
|
||||
pub fn find(&self, place: PlaceRef<'tcx>) -> LookupResult {
|
||||
let mut result = self.find_local(place.local);
|
||||
let Some(mut result) = self.find_local(place.local) else {
|
||||
return LookupResult::Parent(None);
|
||||
};
|
||||
|
||||
for (_, elem) in self.un_derefer.iter_projections(place) {
|
||||
if let Some(&subpath) = self.projections.get(&(result, elem.lift())) {
|
||||
@ -332,7 +333,7 @@ impl<'tcx> MovePathLookup<'tcx> {
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn find_local(&self, local: Local) -> MovePathIndex {
|
||||
pub fn find_local(&self, local: Local) -> Option<MovePathIndex> {
|
||||
self.locals[local]
|
||||
}
|
||||
|
||||
@ -340,46 +341,8 @@ impl<'tcx> MovePathLookup<'tcx> {
|
||||
/// `MovePathIndex`es.
|
||||
pub fn iter_locals_enumerated(
|
||||
&self,
|
||||
) -> impl DoubleEndedIterator<Item = (Local, MovePathIndex)> + ExactSizeIterator + '_ {
|
||||
self.locals.iter_enumerated().map(|(l, &idx)| (l, idx))
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct IllegalMoveOrigin<'tcx> {
|
||||
pub location: Location,
|
||||
pub kind: IllegalMoveOriginKind<'tcx>,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum IllegalMoveOriginKind<'tcx> {
|
||||
/// Illegal move due to attempt to move from behind a reference.
|
||||
BorrowedContent {
|
||||
/// The place the reference refers to: if erroneous code was trying to
|
||||
/// move from `(*x).f` this will be `*x`.
|
||||
target_place: Place<'tcx>,
|
||||
},
|
||||
|
||||
/// Illegal move due to attempt to move from field of an ADT that
|
||||
/// implements `Drop`. Rust maintains invariant that all `Drop`
|
||||
/// ADT's remain fully-initialized so that user-defined destructor
|
||||
/// can safely read from all of the ADT's fields.
|
||||
InteriorOfTypeWithDestructor { container_ty: Ty<'tcx> },
|
||||
|
||||
/// Illegal move due to attempt to move out of a slice or array.
|
||||
InteriorOfSliceOrArray { ty: Ty<'tcx>, is_index: bool },
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum MoveError<'tcx> {
|
||||
IllegalMove { cannot_move_out_of: IllegalMoveOrigin<'tcx> },
|
||||
UnionMove { path: MovePathIndex },
|
||||
}
|
||||
|
||||
impl<'tcx> MoveError<'tcx> {
|
||||
fn cannot_move_out_of(location: Location, kind: IllegalMoveOriginKind<'tcx>) -> Self {
|
||||
let origin = IllegalMoveOrigin { location, kind };
|
||||
MoveError::IllegalMove { cannot_move_out_of: origin }
|
||||
) -> impl DoubleEndedIterator<Item = (Local, MovePathIndex)> + '_ {
|
||||
self.locals.iter_enumerated().filter_map(|(l, &idx)| Some((l, idx?)))
|
||||
}
|
||||
}
|
||||
|
||||
@ -388,8 +351,9 @@ impl<'tcx> MoveData<'tcx> {
|
||||
body: &Body<'tcx>,
|
||||
tcx: TyCtxt<'tcx>,
|
||||
param_env: ParamEnv<'tcx>,
|
||||
) -> MoveDat<'tcx> {
|
||||
builder::gather_moves(body, tcx, param_env)
|
||||
filter: impl Fn(Ty<'tcx>) -> bool,
|
||||
) -> MoveData<'tcx> {
|
||||
builder::gather_moves(body, tcx, param_env, filter)
|
||||
}
|
||||
|
||||
/// For the move path `mpi`, returns the root local variable (if any) that starts the path.
|
||||
|
@ -34,7 +34,7 @@ impl<'tcx> MirPass<'tcx> for SanityCheck {
|
||||
}
|
||||
|
||||
let param_env = tcx.param_env(def_id);
|
||||
let move_data = MoveData::gather_moves(body, tcx, param_env).unwrap();
|
||||
let move_data = MoveData::gather_moves(&body, tcx, param_env, |_| true);
|
||||
let mdpe = MoveDataParamEnv { move_data, param_env };
|
||||
|
||||
if has_rustc_mir_with(tcx, def_id, sym::rustc_peek_maybe_init).is_some() {
|
||||
|
@ -9,9 +9,9 @@ use rustc_mir_dataflow::elaborate_drops::{elaborate_drop, DropFlagState, Unwind}
|
||||
use rustc_mir_dataflow::elaborate_drops::{DropElaborator, DropFlagMode, DropStyle};
|
||||
use rustc_mir_dataflow::impls::{MaybeInitializedPlaces, MaybeUninitializedPlaces};
|
||||
use rustc_mir_dataflow::move_paths::{LookupResult, MoveData, MovePathIndex};
|
||||
use rustc_mir_dataflow::on_all_children_bits;
|
||||
use rustc_mir_dataflow::on_lookup_result_bits;
|
||||
use rustc_mir_dataflow::MoveDataParamEnv;
|
||||
use rustc_mir_dataflow::{on_all_children_bits, on_all_drop_children_bits};
|
||||
use rustc_mir_dataflow::{Analysis, ResultsCursor};
|
||||
use rustc_span::Span;
|
||||
use rustc_target::abi::{FieldIdx, VariantIdx};
|
||||
@ -54,16 +54,10 @@ impl<'tcx> MirPass<'tcx> for ElaborateDrops {
|
||||
|
||||
let def_id = body.source.def_id();
|
||||
let param_env = tcx.param_env_reveal_all_normalized(def_id);
|
||||
let move_data = match MoveData::gather_moves(body, tcx, param_env) {
|
||||
Ok(move_data) => move_data,
|
||||
Err((move_data, _)) => {
|
||||
tcx.sess.delay_span_bug(
|
||||
body.span,
|
||||
"No `move_errors` should be allowed in MIR borrowck",
|
||||
);
|
||||
move_data
|
||||
}
|
||||
};
|
||||
// For types that do not need dropping, the behaviour is trivial. So we only need to track
|
||||
// init/uninit for types that do need dropping.
|
||||
let move_data =
|
||||
MoveData::gather_moves(&body, tcx, param_env, |ty| ty.needs_drop(tcx, param_env));
|
||||
let elaborate_patch = {
|
||||
let env = MoveDataParamEnv { move_data, param_env };
|
||||
|
||||
@ -178,13 +172,19 @@ impl<'a, 'tcx> DropElaborator<'a, 'tcx> for Elaborator<'a, '_, 'tcx> {
|
||||
let mut some_live = false;
|
||||
let mut some_dead = false;
|
||||
let mut children_count = 0;
|
||||
on_all_drop_children_bits(self.tcx(), self.body(), self.ctxt.env, path, |child| {
|
||||
let (live, dead) = self.ctxt.init_data.maybe_live_dead(child);
|
||||
debug!("elaborate_drop: state({:?}) = {:?}", child, (live, dead));
|
||||
some_live |= live;
|
||||
some_dead |= dead;
|
||||
children_count += 1;
|
||||
});
|
||||
on_all_children_bits(
|
||||
self.tcx(),
|
||||
self.body(),
|
||||
self.ctxt.move_data(),
|
||||
path,
|
||||
|child| {
|
||||
let (live, dead) = self.ctxt.init_data.maybe_live_dead(child);
|
||||
debug!("elaborate_drop: state({:?}) = {:?}", child, (live, dead));
|
||||
some_live |= live;
|
||||
some_dead |= dead;
|
||||
children_count += 1;
|
||||
},
|
||||
);
|
||||
((some_live, some_dead), children_count != 1)
|
||||
}
|
||||
};
|
||||
@ -296,26 +296,36 @@ impl<'b, 'tcx> ElaborateDropsCtxt<'b, 'tcx> {
|
||||
fn collect_drop_flags(&mut self) {
|
||||
for (bb, data) in self.body.basic_blocks.iter_enumerated() {
|
||||
let terminator = data.terminator();
|
||||
let place = match terminator.kind {
|
||||
TerminatorKind::Drop { ref place, .. } => place,
|
||||
_ => continue,
|
||||
};
|
||||
|
||||
self.init_data.seek_before(self.body.terminator_loc(bb));
|
||||
let TerminatorKind::Drop { ref place, .. } = terminator.kind else { continue };
|
||||
|
||||
let path = self.move_data().rev_lookup.find(place.as_ref());
|
||||
debug!("collect_drop_flags: {:?}, place {:?} ({:?})", bb, place, path);
|
||||
|
||||
let path = match path {
|
||||
LookupResult::Exact(e) => e,
|
||||
LookupResult::Parent(None) => continue,
|
||||
match path {
|
||||
LookupResult::Exact(path) => {
|
||||
self.init_data.seek_before(self.body.terminator_loc(bb));
|
||||
on_all_children_bits(self.tcx, self.body, self.move_data(), path, |child| {
|
||||
let (maybe_live, maybe_dead) = self.init_data.maybe_live_dead(child);
|
||||
debug!(
|
||||
"collect_drop_flags: collecting {:?} from {:?}@{:?} - {:?}",
|
||||
child,
|
||||
place,
|
||||
path,
|
||||
(maybe_live, maybe_dead)
|
||||
);
|
||||
if maybe_live && maybe_dead {
|
||||
self.create_drop_flag(child, terminator.source_info.span)
|
||||
}
|
||||
});
|
||||
}
|
||||
LookupResult::Parent(None) => {}
|
||||
LookupResult::Parent(Some(parent)) => {
|
||||
let (_maybe_live, maybe_dead) = self.init_data.maybe_live_dead(parent);
|
||||
|
||||
if self.body.local_decls[place.local].is_deref_temp() {
|
||||
continue;
|
||||
}
|
||||
|
||||
self.init_data.seek_before(self.body.terminator_loc(bb));
|
||||
let (_maybe_live, maybe_dead) = self.init_data.maybe_live_dead(parent);
|
||||
if maybe_dead {
|
||||
self.tcx.sess.delay_span_bug(
|
||||
terminator.source_info.span,
|
||||
@ -324,80 +334,74 @@ impl<'b, 'tcx> ElaborateDropsCtxt<'b, 'tcx> {
|
||||
),
|
||||
);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
};
|
||||
|
||||
on_all_drop_children_bits(self.tcx, self.body, self.env, path, |child| {
|
||||
let (maybe_live, maybe_dead) = self.init_data.maybe_live_dead(child);
|
||||
debug!(
|
||||
"collect_drop_flags: collecting {:?} from {:?}@{:?} - {:?}",
|
||||
child,
|
||||
place,
|
||||
path,
|
||||
(maybe_live, maybe_dead)
|
||||
);
|
||||
if maybe_live && maybe_dead {
|
||||
self.create_drop_flag(child, terminator.source_info.span)
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
fn elaborate_drops(&mut self) {
|
||||
// This function should mirror what `collect_drop_flags` does.
|
||||
for (bb, data) in self.body.basic_blocks.iter_enumerated() {
|
||||
let loc = Location { block: bb, statement_index: data.statements.len() };
|
||||
let terminator = data.terminator();
|
||||
let TerminatorKind::Drop { place, target, unwind, replace } = terminator.kind else {
|
||||
continue;
|
||||
};
|
||||
|
||||
match terminator.kind {
|
||||
TerminatorKind::Drop { place, target, unwind, replace } => {
|
||||
self.init_data.seek_before(loc);
|
||||
match self.move_data().rev_lookup.find(place.as_ref()) {
|
||||
LookupResult::Exact(path) => {
|
||||
let unwind = if data.is_cleanup {
|
||||
Unwind::InCleanup
|
||||
} else {
|
||||
match unwind {
|
||||
UnwindAction::Cleanup(cleanup) => Unwind::To(cleanup),
|
||||
UnwindAction::Continue => Unwind::To(self.patch.resume_block()),
|
||||
UnwindAction::Unreachable => {
|
||||
Unwind::To(self.patch.unreachable_cleanup_block())
|
||||
}
|
||||
UnwindAction::Terminate(reason) => {
|
||||
debug_assert_ne!(
|
||||
reason,
|
||||
UnwindTerminateReason::InCleanup,
|
||||
"we are not in a cleanup block, InCleanup reason should be impossible"
|
||||
);
|
||||
Unwind::To(self.patch.terminate_block(reason))
|
||||
}
|
||||
}
|
||||
};
|
||||
elaborate_drop(
|
||||
&mut Elaborator { ctxt: self },
|
||||
terminator.source_info,
|
||||
place,
|
||||
path,
|
||||
target,
|
||||
unwind,
|
||||
bb,
|
||||
)
|
||||
// This place does not need dropping. It does not have an associated move-path, so the
|
||||
// match below will conservatively keep an unconditional drop. As that drop is useless,
|
||||
// just remove it here and now.
|
||||
if !place
|
||||
.ty(&self.body.local_decls, self.tcx)
|
||||
.ty
|
||||
.needs_drop(self.tcx, self.env.param_env)
|
||||
{
|
||||
self.patch.patch_terminator(bb, TerminatorKind::Goto { target });
|
||||
continue;
|
||||
}
|
||||
|
||||
let path = self.move_data().rev_lookup.find(place.as_ref());
|
||||
match path {
|
||||
LookupResult::Exact(path) => {
|
||||
let unwind = match unwind {
|
||||
_ if data.is_cleanup => Unwind::InCleanup,
|
||||
UnwindAction::Cleanup(cleanup) => Unwind::To(cleanup),
|
||||
UnwindAction::Continue => Unwind::To(self.patch.resume_block()),
|
||||
UnwindAction::Unreachable => {
|
||||
Unwind::To(self.patch.unreachable_cleanup_block())
|
||||
}
|
||||
LookupResult::Parent(..) => {
|
||||
if !replace {
|
||||
self.tcx.sess.delay_span_bug(
|
||||
terminator.source_info.span,
|
||||
format!("drop of untracked value {bb:?}"),
|
||||
);
|
||||
}
|
||||
// A drop and replace behind a pointer/array/whatever.
|
||||
// The borrow checker requires that these locations are initialized before the assignment,
|
||||
// so we just leave an unconditional drop.
|
||||
assert!(!data.is_cleanup);
|
||||
UnwindAction::Terminate(reason) => {
|
||||
debug_assert_ne!(
|
||||
reason,
|
||||
UnwindTerminateReason::InCleanup,
|
||||
"we are not in a cleanup block, InCleanup reason should be impossible"
|
||||
);
|
||||
Unwind::To(self.patch.terminate_block(reason))
|
||||
}
|
||||
}
|
||||
};
|
||||
self.init_data.seek_before(self.body.terminator_loc(bb));
|
||||
elaborate_drop(
|
||||
&mut Elaborator { ctxt: self },
|
||||
terminator.source_info,
|
||||
place,
|
||||
path,
|
||||
target,
|
||||
unwind,
|
||||
bb,
|
||||
)
|
||||
}
|
||||
LookupResult::Parent(None) => {}
|
||||
LookupResult::Parent(Some(_)) => {
|
||||
if !replace {
|
||||
self.tcx.sess.delay_span_bug(
|
||||
terminator.source_info.span,
|
||||
format!("drop of untracked value {bb:?}"),
|
||||
);
|
||||
}
|
||||
// A drop and replace behind a pointer/array/whatever.
|
||||
// The borrow checker requires that these locations are initialized before the assignment,
|
||||
// so we just leave an unconditional drop.
|
||||
assert!(!data.is_cleanup);
|
||||
}
|
||||
_ => continue,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -24,11 +24,8 @@ pub struct RemoveUninitDrops;
|
||||
impl<'tcx> MirPass<'tcx> for RemoveUninitDrops {
|
||||
fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
|
||||
let param_env = tcx.param_env(body.source.def_id());
|
||||
let Ok(move_data) = MoveData::gather_moves(body, tcx, param_env) else {
|
||||
// We could continue if there are move errors, but there's not much point since our
|
||||
// init data isn't complete.
|
||||
return;
|
||||
};
|
||||
let move_data =
|
||||
MoveData::gather_moves(&body, tcx, param_env, |ty| ty.needs_drop(tcx, param_env));
|
||||
|
||||
let mdpe = MoveDataParamEnv { move_data, param_env };
|
||||
let mut maybe_inits = MaybeInitializedPlaces::new(tcx, body, &mdpe)
|
||||
|
@ -6,24 +6,18 @@
|
||||
let mut _0: ();
|
||||
let _2: ();
|
||||
let mut _3: std::boxed::Box<[i32]>;
|
||||
let mut _4: &mut std::boxed::Box<[i32]>;
|
||||
let mut _5: ();
|
||||
let mut _6: &mut std::boxed::Box<[i32]>;
|
||||
let mut _7: ();
|
||||
let mut _8: &mut std::boxed::Box<[i32]>;
|
||||
let mut _9: ();
|
||||
let mut _10: *const [i32];
|
||||
let mut _4: *const [i32];
|
||||
|
||||
bb0: {
|
||||
StorageLive(_2);
|
||||
StorageLive(_3);
|
||||
_3 = move _1;
|
||||
_10 = (((_3.0: std::ptr::Unique<[i32]>).0: std::ptr::NonNull<[i32]>).0: *const [i32]);
|
||||
_2 = callee(move (*_10)) -> [return: bb3, unwind: bb4];
|
||||
_4 = (((_3.0: std::ptr::Unique<[i32]>).0: std::ptr::NonNull<[i32]>).0: *const [i32]);
|
||||
_2 = callee(move (*_4)) -> [return: bb1, unwind: bb3];
|
||||
}
|
||||
|
||||
bb1 (cleanup): {
|
||||
resume;
|
||||
bb1: {
|
||||
drop(_3) -> [return: bb2, unwind: bb4];
|
||||
}
|
||||
|
||||
bb2: {
|
||||
@ -33,14 +27,12 @@
|
||||
return;
|
||||
}
|
||||
|
||||
bb3: {
|
||||
_4 = &mut _3;
|
||||
_5 = <Box<[i32]> as Drop>::drop(move _4) -> [return: bb2, unwind: bb1];
|
||||
bb3 (cleanup): {
|
||||
drop(_3) -> [return: bb4, unwind terminate(cleanup)];
|
||||
}
|
||||
|
||||
bb4 (cleanup): {
|
||||
_8 = &mut _3;
|
||||
_9 = <Box<[i32]> as Drop>::drop(move _8) -> [return: bb1, unwind terminate(cleanup)];
|
||||
resume;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -10,9 +10,8 @@
|
||||
let mut _5: isize;
|
||||
+ let mut _7: bool;
|
||||
+ let mut _8: bool;
|
||||
+ let mut _9: bool;
|
||||
+ let mut _9: isize;
|
||||
+ let mut _10: isize;
|
||||
+ let mut _11: isize;
|
||||
scope 1 {
|
||||
debug e => _1;
|
||||
scope 2 {
|
||||
@ -24,7 +23,6 @@
|
||||
bb0: {
|
||||
+ _7 = const false;
|
||||
+ _8 = const false;
|
||||
+ _9 = const false;
|
||||
StorageLive(_1);
|
||||
StorageLive(_2);
|
||||
_2 = cond() -> [return: bb1, unwind: bb11];
|
||||
@ -47,7 +45,6 @@
|
||||
bb3: {
|
||||
+ _7 = const true;
|
||||
+ _8 = const true;
|
||||
+ _9 = const true;
|
||||
_1 = move _3;
|
||||
- drop(_3) -> [return: bb5, unwind: bb11];
|
||||
+ goto -> bb5;
|
||||
@ -56,7 +53,6 @@
|
||||
bb4 (cleanup): {
|
||||
+ _7 = const true;
|
||||
+ _8 = const true;
|
||||
+ _9 = const true;
|
||||
_1 = move _3;
|
||||
- drop(_3) -> [return: bb11, unwind terminate(cleanup)];
|
||||
+ goto -> bb11;
|
||||
@ -70,7 +66,6 @@
|
||||
|
||||
bb6: {
|
||||
StorageLive(_6);
|
||||
+ _9 = const false;
|
||||
_6 = move ((_1 as F).0: K);
|
||||
_0 = const ();
|
||||
StorageDead(_6);
|
||||
@ -90,13 +85,12 @@
|
||||
bb9: {
|
||||
StorageDead(_2);
|
||||
- drop(_1) -> [return: bb10, unwind: bb12];
|
||||
+ goto -> bb18;
|
||||
+ goto -> bb19;
|
||||
}
|
||||
|
||||
bb10: {
|
||||
+ _7 = const false;
|
||||
+ _8 = const false;
|
||||
+ _9 = const false;
|
||||
StorageDead(_1);
|
||||
return;
|
||||
}
|
||||
@ -116,33 +110,37 @@
|
||||
+ }
|
||||
+
|
||||
+ bb14 (cleanup): {
|
||||
+ goto -> bb12;
|
||||
+ drop(((_1 as F).0: K)) -> [return: bb12, unwind terminate(cleanup)];
|
||||
+ }
|
||||
+
|
||||
+ bb15: {
|
||||
+ bb15 (cleanup): {
|
||||
+ switchInt(_7) -> [0: bb12, otherwise: bb14];
|
||||
+ }
|
||||
+
|
||||
+ bb16: {
|
||||
+ drop(_1) -> [return: bb13, unwind: bb12];
|
||||
+ }
|
||||
+
|
||||
+ bb16 (cleanup): {
|
||||
+ bb17 (cleanup): {
|
||||
+ drop(_1) -> [return: bb12, unwind terminate(cleanup)];
|
||||
+ }
|
||||
+
|
||||
+ bb17: {
|
||||
+ _10 = discriminant(_1);
|
||||
+ switchInt(move _10) -> [0: bb13, otherwise: bb15];
|
||||
+ }
|
||||
+
|
||||
+ bb18: {
|
||||
+ switchInt(_7) -> [0: bb13, otherwise: bb17];
|
||||
+ _9 = discriminant(_1);
|
||||
+ switchInt(move _9) -> [0: bb13, otherwise: bb16];
|
||||
+ }
|
||||
+
|
||||
+ bb19 (cleanup): {
|
||||
+ _11 = discriminant(_1);
|
||||
+ switchInt(move _11) -> [0: bb14, otherwise: bb16];
|
||||
+ bb19: {
|
||||
+ switchInt(_7) -> [0: bb13, otherwise: bb18];
|
||||
+ }
|
||||
+
|
||||
+ bb20 (cleanup): {
|
||||
+ switchInt(_7) -> [0: bb12, otherwise: bb19];
|
||||
+ _10 = discriminant(_1);
|
||||
+ switchInt(move _10) -> [0: bb15, otherwise: bb17];
|
||||
+ }
|
||||
+
|
||||
+ bb21 (cleanup): {
|
||||
+ switchInt(_7) -> [0: bb12, otherwise: bb20];
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -10,9 +10,8 @@
|
||||
let mut _5: isize;
|
||||
+ let mut _7: bool;
|
||||
+ let mut _8: bool;
|
||||
+ let mut _9: bool;
|
||||
+ let mut _9: isize;
|
||||
+ let mut _10: isize;
|
||||
+ let mut _11: isize;
|
||||
scope 1 {
|
||||
debug e => _1;
|
||||
scope 2 {
|
||||
@ -24,7 +23,6 @@
|
||||
bb0: {
|
||||
+ _7 = const false;
|
||||
+ _8 = const false;
|
||||
+ _9 = const false;
|
||||
StorageLive(_1);
|
||||
StorageLive(_2);
|
||||
_2 = cond() -> [return: bb1, unwind: bb11];
|
||||
@ -47,7 +45,6 @@
|
||||
bb3: {
|
||||
+ _7 = const true;
|
||||
+ _8 = const true;
|
||||
+ _9 = const true;
|
||||
_1 = move _3;
|
||||
- drop(_3) -> [return: bb5, unwind: bb11];
|
||||
+ goto -> bb5;
|
||||
@ -56,7 +53,6 @@
|
||||
bb4 (cleanup): {
|
||||
+ _7 = const true;
|
||||
+ _8 = const true;
|
||||
+ _9 = const true;
|
||||
_1 = move _3;
|
||||
- drop(_3) -> [return: bb11, unwind terminate(cleanup)];
|
||||
+ goto -> bb11;
|
||||
@ -70,7 +66,6 @@
|
||||
|
||||
bb6: {
|
||||
StorageLive(_6);
|
||||
+ _9 = const false;
|
||||
_6 = move ((_1 as F).0: K);
|
||||
_0 = const ();
|
||||
StorageDead(_6);
|
||||
@ -90,13 +85,12 @@
|
||||
bb9: {
|
||||
StorageDead(_2);
|
||||
- drop(_1) -> [return: bb10, unwind continue];
|
||||
+ goto -> bb18;
|
||||
+ goto -> bb19;
|
||||
}
|
||||
|
||||
bb10: {
|
||||
+ _7 = const false;
|
||||
+ _8 = const false;
|
||||
+ _9 = const false;
|
||||
StorageDead(_1);
|
||||
return;
|
||||
}
|
||||
@ -116,33 +110,37 @@
|
||||
+ }
|
||||
+
|
||||
+ bb14 (cleanup): {
|
||||
+ goto -> bb12;
|
||||
+ drop(((_1 as F).0: K)) -> [return: bb12, unwind terminate(cleanup)];
|
||||
+ }
|
||||
+
|
||||
+ bb15: {
|
||||
+ bb15 (cleanup): {
|
||||
+ switchInt(_7) -> [0: bb12, otherwise: bb14];
|
||||
+ }
|
||||
+
|
||||
+ bb16: {
|
||||
+ drop(_1) -> [return: bb13, unwind: bb12];
|
||||
+ }
|
||||
+
|
||||
+ bb16 (cleanup): {
|
||||
+ bb17 (cleanup): {
|
||||
+ drop(_1) -> [return: bb12, unwind terminate(cleanup)];
|
||||
+ }
|
||||
+
|
||||
+ bb17: {
|
||||
+ _10 = discriminant(_1);
|
||||
+ switchInt(move _10) -> [0: bb13, otherwise: bb15];
|
||||
+ }
|
||||
+
|
||||
+ bb18: {
|
||||
+ switchInt(_7) -> [0: bb13, otherwise: bb17];
|
||||
+ _9 = discriminant(_1);
|
||||
+ switchInt(move _9) -> [0: bb13, otherwise: bb16];
|
||||
+ }
|
||||
+
|
||||
+ bb19 (cleanup): {
|
||||
+ _11 = discriminant(_1);
|
||||
+ switchInt(move _11) -> [0: bb14, otherwise: bb16];
|
||||
+ bb19: {
|
||||
+ switchInt(_7) -> [0: bb13, otherwise: bb18];
|
||||
+ }
|
||||
+
|
||||
+ bb20 (cleanup): {
|
||||
+ switchInt(_7) -> [0: bb12, otherwise: bb19];
|
||||
+ _10 = discriminant(_1);
|
||||
+ switchInt(move _10) -> [0: bb15, otherwise: bb17];
|
||||
+ }
|
||||
+
|
||||
+ bb21 (cleanup): {
|
||||
+ switchInt(_7) -> [0: bb12, otherwise: bb20];
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1,25 +1,3 @@
|
||||
error[E0508]: cannot move out of type `[T]`, a non-copy slice
|
||||
--> $DIR/issue-12567.rs:2:11
|
||||
|
|
||||
LL | match (l1, l2) {
|
||||
| ^^^^^^^^ cannot move out of here
|
||||
...
|
||||
LL | (&[], &[hd, ..]) | (&[hd, ..], &[])
|
||||
| -- data moved here
|
||||
LL | => println!("one empty"),
|
||||
LL | (&[hd1, ..], &[hd2, ..])
|
||||
| --- ...and here
|
||||
|
|
||||
= note: move occurs because these variables have types that don't implement the `Copy` trait
|
||||
help: consider borrowing the pattern binding
|
||||
|
|
||||
LL | (&[], &[ref hd, ..]) | (&[hd, ..], &[])
|
||||
| +++
|
||||
help: consider borrowing the pattern binding
|
||||
|
|
||||
LL | (&[ref hd1, ..], &[hd2, ..])
|
||||
| +++
|
||||
|
||||
error[E0508]: cannot move out of type `[T]`, a non-copy slice
|
||||
--> $DIR/issue-12567.rs:2:11
|
||||
|
|
||||
@ -42,6 +20,28 @@ help: consider borrowing the pattern binding
|
||||
LL | (&[hd1, ..], &[ref hd2, ..])
|
||||
| +++
|
||||
|
||||
error[E0508]: cannot move out of type `[T]`, a non-copy slice
|
||||
--> $DIR/issue-12567.rs:2:11
|
||||
|
|
||||
LL | match (l1, l2) {
|
||||
| ^^^^^^^^ cannot move out of here
|
||||
...
|
||||
LL | (&[], &[hd, ..]) | (&[hd, ..], &[])
|
||||
| -- data moved here
|
||||
LL | => println!("one empty"),
|
||||
LL | (&[hd1, ..], &[hd2, ..])
|
||||
| --- ...and here
|
||||
|
|
||||
= note: move occurs because these variables have types that don't implement the `Copy` trait
|
||||
help: consider borrowing the pattern binding
|
||||
|
|
||||
LL | (&[], &[ref hd, ..]) | (&[hd, ..], &[])
|
||||
| +++
|
||||
help: consider borrowing the pattern binding
|
||||
|
|
||||
LL | (&[ref hd1, ..], &[hd2, ..])
|
||||
| +++
|
||||
|
||||
error: aborting due to 2 previous errors
|
||||
|
||||
For more information about this error, try `rustc --explain E0508`.
|
||||
|
@ -186,7 +186,7 @@ help: consider borrowing the pattern binding
|
||||
LL | F(s, ref mut t) => (),
|
||||
| +++
|
||||
|
||||
error[E0507]: cannot move out of `x` as enum variant `Err` which is behind a shared reference
|
||||
error[E0507]: cannot move out of `x` as enum variant `Ok` which is behind a shared reference
|
||||
--> $DIR/move-errors.rs:110:11
|
||||
|
|
||||
LL | match *x {
|
||||
|
@ -43,7 +43,7 @@ LL - while let Either::One(_t) = *r { }
|
||||
LL + while let Either::One(_t) = r { }
|
||||
|
|
||||
|
||||
error[E0507]: cannot move out of `r` as enum variant `Two` which is behind a shared reference
|
||||
error[E0507]: cannot move out of `r` as enum variant `One` which is behind a shared reference
|
||||
--> $DIR/simple.rs:47:11
|
||||
|
|
||||
LL | match *r {
|
||||
@ -124,7 +124,7 @@ LL - while let Either::One(_t) = *rm { }
|
||||
LL + while let Either::One(_t) = rm { }
|
||||
|
|
||||
|
||||
error[E0507]: cannot move out of `rm` as enum variant `Two` which is behind a mutable reference
|
||||
error[E0507]: cannot move out of `rm` as enum variant `One` which is behind a mutable reference
|
||||
--> $DIR/simple.rs:70:11
|
||||
|
|
||||
LL | match *rm {
|
||||
@ -392,7 +392,7 @@ LL - while let &Either::One(_t) = r { }
|
||||
LL + while let Either::One(_t) = r { }
|
||||
|
|
||||
|
||||
error[E0507]: cannot move out of `r` as enum variant `Two` which is behind a shared reference
|
||||
error[E0507]: cannot move out of `r` as enum variant `One` which is behind a shared reference
|
||||
--> $DIR/simple.rs:155:11
|
||||
|
|
||||
LL | match r {
|
||||
@ -491,7 +491,7 @@ LL - while let &mut Either::One(_t) = rm { }
|
||||
LL + while let Either::One(_t) = rm { }
|
||||
|
|
||||
|
||||
error[E0507]: cannot move out of `rm` as enum variant `Two` which is behind a mutable reference
|
||||
error[E0507]: cannot move out of `rm` as enum variant `One` which is behind a mutable reference
|
||||
--> $DIR/simple.rs:187:11
|
||||
|
|
||||
LL | match rm {
|
||||
|
Loading…
Reference in New Issue
Block a user