1//! This crate implemens MIR typeck and MIR borrowck.23// tidy-alphabetical-start4#![allow(internal_features)]5#![feature(default_field_values)]6#![feature(deref_patterns)]7#![feature(file_buffered)]8#![feature(negative_impls)]9#![feature(never_type)]10#![feature(rustc_attrs)]11#![feature(stmt_expr_attributes)]12#![feature(try_blocks)]13// tidy-alphabetical-end1415use std::borrow::Cow;16use std::cell::{OnceCell, RefCell};17use std::marker::PhantomData;18use std::ops::{ControlFlow, Deref};19use std::rc::Rc;2021use borrow_set::LocalsStateAtExit;22use polonius_engine::AllFacts;23use root_cx::BorrowCheckRootCtxt;24use rustc_abi::FieldIdx;25use rustc_data_structures::frozen::Frozen;26use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};27use rustc_data_structures::graph::dominators::Dominators;28use rustc_hir as hir;29use rustc_hir::CRATE_HIR_ID;30use rustc_hir::def_id::LocalDefId;31use rustc_index::bit_set::MixedBitSet;32use rustc_index::{IndexSlice, IndexVec};33use rustc_infer::infer::outlives::env::RegionBoundPairs;34use rustc_infer::infer::{35    InferCtxt, NllRegionVariableOrigin, RegionVariableOrigin, TyCtxtInferExt,36};37use rustc_middle::mir::*;38use rustc_middle::query::Providers;39use rustc_middle::ty::{40    self, ParamEnv, RegionVid, Ty, TyCtxt, TypeFoldable, TypeVisitable, TypingMode, fold_regions,41};42use rustc_middle::{bug, span_bug};43use rustc_mir_dataflow::impls::{EverInitializedPlaces, MaybeUninitializedPlaces};44use rustc_mir_dataflow::move_paths::{45    InitIndex, InitLocation, LookupResult, MoveData, MovePathIndex,46};47use rustc_mir_dataflow::points::DenseLocationMap;48use rustc_mir_dataflow::{Analysis, EntryStates, Results, ResultsVisitor, visit_results};49use rustc_session::lint::builtin::{TAIL_EXPR_DROP_ORDER, UNUSED_MUT};50use rustc_span::{ErrorGuaranteed, Span, Symbol};51use smallvec::SmallVec;52use tracing::{debug, instrument};5354use crate::borrow_set::{BorrowData, BorrowSet};55use crate::consumers::{BodyWithBorrowckFacts, RustcFacts};56use crate::dataflow::{BorrowIndex, Borrowck, BorrowckDomain, Borrows};57use crate::diagnostics::{58    AccessKind, BorrowckDiagnosticsBuffer, IllegalMoveOriginKind, MoveError, RegionName,59};60use crate::path_utils::*;61use crate::place_ext::PlaceExt;62use crate::places_conflict::{PlaceConflictBias, places_conflict};63use crate::polonius::PoloniusContext;64use crate::polonius::legacy::{65    PoloniusFacts, PoloniusFactsExt, PoloniusLocationTable, PoloniusOutput,66};67use crate::prefixes::PrefixSet;68use crate::region_infer::RegionInferenceContext;69use crate::region_infer::opaque_types::DeferredOpaqueTypeError;70use crate::renumber::RegionCtxt;71use crate::session_diagnostics::VarNeedNotMut;72use crate::type_check::free_region_relations::UniversalRegionRelations;73use crate::type_check::{Locations, MirTypeckRegionConstraints, MirTypeckResults};7475mod borrow_set;76mod borrowck_errors;77mod constraints;78mod dataflow;79mod def_use;80mod diagnostics;81mod handle_placeholders;82mod nll;83mod path_utils;84mod place_ext;85mod places_conflict;86mod polonius;87mod prefixes;88mod region_infer;89mod renumber;90mod root_cx;91mod session_diagnostics;92mod type_check;93mod universal_regions;94mod used_muts;9596/// A public API provided for the Rust compiler consumers.97pub mod consumers;9899/// Associate some local constants with the `'tcx` lifetime100struct TyCtxtConsts<'tcx>(PhantomData<&'tcx ()>);101102impl<'tcx> TyCtxtConsts<'tcx> {103    const DEREF_PROJECTION: &'tcx [PlaceElem<'tcx>; 1] = &[ProjectionElem::Deref];104}105106pub fn provide(providers: &mut Providers) {107    *providers = Providers { mir_borrowck, ..*providers };108}109110/// Provider for `query mir_borrowck`. Unlike `typeck`, this must111/// only be called for typeck roots which *similar* to `typeck` will112/// then borrowck all nested bodies as well.113fn mir_borrowck(114    tcx: TyCtxt<'_>,115    def: LocalDefId,116) -> Result<&FxIndexMap<LocalDefId, ty::DefinitionSiteHiddenType<'_>>, ErrorGuaranteed> {117    assert!(!tcx.is_typeck_child(def.to_def_id()));118    if tcx.is_trivial_const(def) {119        debug!("Skipping borrowck because of trivial const");120        let opaque_types = Default::default();121        return Ok(tcx.arena.alloc(opaque_types));122    }123    let (input_body, _) = tcx.mir_promoted(def);124    debug!("run query mir_borrowck: {}", tcx.def_path_str(def));125126    // We should eagerly check stalled coroutine obligations from HIR typeck.127    // Not doing so leads to silent normalization failures later, which will128    // fail to register opaque types in the next solver.129    tcx.ensure_result().check_coroutine_obligations(def)?;130131    let input_body: &Body<'_> = &input_body.borrow();132    if let Some(guar) = input_body.tainted_by_errors {133        debug!("Skipping borrowck because of tainted body");134        Err(guar)135    } else if input_body.should_skip() {136        debug!("Skipping borrowck because of injected body");137        let opaque_types = Default::default();138        Ok(tcx.arena.alloc(opaque_types))139    } else {140        let mut root_cx = BorrowCheckRootCtxt::new(tcx, def, None);141        root_cx.do_mir_borrowck();142        root_cx.finalize()143    }144}145146/// Data propagated to the typeck parent by nested items.147/// This should always be empty for the typeck root.148#[derive(Debug)]149struct PropagatedBorrowCheckResults<'tcx> {150    closure_requirements: Option<ClosureRegionRequirements<'tcx>>,151    used_mut_upvars: SmallVec<[FieldIdx; 8]>,152}153154type DeferredClosureRequirements<'tcx> = Vec<(LocalDefId, ty::GenericArgsRef<'tcx>, Locations)>;155156/// After we borrow check a closure, we are left with various157/// requirements that we have inferred between the free regions that158/// appear in the closure's signature or on its field types. These159/// requirements are then verified and proved by the closure's160/// creating function. This struct encodes those requirements.161///162/// The requirements are listed as being between various `RegionVid`. The 0th163/// region refers to `'static`; subsequent region vids refer to the free164/// regions that appear in the closure (or coroutine's) type, in order of165/// appearance. (This numbering is actually defined by the `UniversalRegions`166/// struct in the NLL region checker. See for example167/// `UniversalRegions::closure_mapping`.) Note the free regions in the168/// closure's signature and captures are erased.169///170/// Example: If type check produces a closure with the closure args:171///172/// ```text173/// ClosureArgs = [174///     'a,                                         // From the parent.175///     'b,176///     i8,                                         // the "closure kind"177///     for<'x> fn(&'<erased> &'x u32) -> &'x u32,  // the "closure signature"178///     &'<erased> String,                          // some upvar179/// ]180/// ```181///182/// We would "renumber" each free region to a unique vid, as follows:183///184/// ```text185/// ClosureArgs = [186///     '1,                                         // From the parent.187///     '2,188///     i8,                                         // the "closure kind"189///     for<'x> fn(&'3 &'x u32) -> &'x u32,         // the "closure signature"190///     &'4 String,                                 // some upvar191/// ]192/// ```193///194/// Now the code might impose a requirement like `'1: '2`. When an195/// instance of the closure is created, the corresponding free regions196/// can be extracted from its type and constrained to have the given197/// outlives relationship.198#[derive(Clone, Debug)]199pub struct ClosureRegionRequirements<'tcx> {200    /// The number of external regions defined on the closure. In our201    /// example above, it would be 3 -- one for `'static`, then `'1`202    /// and `'2`. This is just used for a sanity check later on, to203    /// make sure that the number of regions we see at the callsite204    /// matches.205    pub num_external_vids: usize,206207    /// Requirements between the various free regions defined in208    /// indices.209    pub outlives_requirements: Vec<ClosureOutlivesRequirement<'tcx>>,210}211212/// Indicates an outlives-constraint between a type or between two213/// free regions declared on the closure.214#[derive(Copy, Clone, Debug)]215pub struct ClosureOutlivesRequirement<'tcx> {216    // This region or type ...217    pub subject: ClosureOutlivesSubject<'tcx>,218219    // ... must outlive this one.220    pub outlived_free_region: ty::RegionVid,221222    // If not, report an error here ...223    pub blame_span: Span,224225    // ... due to this reason.226    pub category: ConstraintCategory<'tcx>,227}228229// Make sure this enum doesn't unintentionally grow230#[cfg(target_pointer_width = "64")]231rustc_data_structures::static_assert_size!(ConstraintCategory<'_>, 16);232233/// The subject of a `ClosureOutlivesRequirement` -- that is, the thing234/// that must outlive some region.235#[derive(Copy, Clone, Debug)]236pub enum ClosureOutlivesSubject<'tcx> {237    /// Subject is a type, typically a type parameter, but could also238    /// be a projection. Indicates a requirement like `T: 'a` being239    /// passed to the caller, where the type here is `T`.240    Ty(ClosureOutlivesSubjectTy<'tcx>),241242    /// Subject is a free region from the closure. Indicates a requirement243    /// like `'a: 'b` being passed to the caller; the region here is `'a`.244    Region(ty::RegionVid),245}246247/// Represents a `ty::Ty` for use in [`ClosureOutlivesSubject`].248///249/// This abstraction is necessary because the type may include `ReVar` regions,250/// which is what we use internally within NLL code, and they can't be used in251/// a query response.252#[derive(Copy, Clone, Debug)]253pub struct ClosureOutlivesSubjectTy<'tcx> {254    inner: Ty<'tcx>,255}256// DO NOT implement `TypeVisitable` or `TypeFoldable` traits, because this257// type is not recognized as a binder for late-bound region.258impl<'tcx, I> !TypeVisitable<I> for ClosureOutlivesSubjectTy<'tcx> {}259impl<'tcx, I> !TypeFoldable<I> for ClosureOutlivesSubjectTy<'tcx> {}260261impl<'tcx> ClosureOutlivesSubjectTy<'tcx> {262    /// All regions of `ty` must be of kind `ReVar` and must represent263    /// universal regions *external* to the closure.264    pub fn bind(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Self {265        let inner = fold_regions(tcx, ty, |r, depth| match r.kind() {266            ty::ReVar(vid) => {267                let br = ty::BoundRegion {268                    var: ty::BoundVar::from_usize(vid.index()),269                    kind: ty::BoundRegionKind::Anon,270                };271                ty::Region::new_bound(tcx, depth, br)272            }273            _ => bug!("unexpected region in ClosureOutlivesSubjectTy: {r:?}"),274        });275276        Self { inner }277    }278279    pub fn instantiate(280        self,281        tcx: TyCtxt<'tcx>,282        mut map: impl FnMut(ty::RegionVid) -> ty::Region<'tcx>,283    ) -> Ty<'tcx> {284        fold_regions(tcx, self.inner, |r, depth| match r.kind() {285            ty::ReBound(ty::BoundVarIndexKind::Bound(debruijn), br) => {286                debug_assert_eq!(debruijn, depth);287                map(ty::RegionVid::from_usize(br.var.index()))288            }289            _ => bug!("unexpected region {r:?}"),290        })291    }292}293294struct CollectRegionConstraintsResult<'tcx> {295    infcx: BorrowckInferCtxt<'tcx>,296    body_owned: Body<'tcx>,297    promoted: IndexVec<Promoted, Body<'tcx>>,298    move_data: MoveData<'tcx>,299    borrow_set: BorrowSet<'tcx>,300    location_table: PoloniusLocationTable,301    location_map: Rc<DenseLocationMap>,302    universal_region_relations: Frozen<UniversalRegionRelations<'tcx>>,303    region_bound_pairs: Frozen<RegionBoundPairs<'tcx>>,304    known_type_outlives_obligations: Frozen<Vec<ty::PolyTypeOutlivesPredicate<'tcx>>>,305    constraints: MirTypeckRegionConstraints<'tcx>,306    deferred_closure_requirements: DeferredClosureRequirements<'tcx>,307    deferred_opaque_type_errors: Vec<DeferredOpaqueTypeError<'tcx>>,308    polonius_facts: Option<AllFacts<RustcFacts>>,309    polonius_context: Option<PoloniusContext>,310}311312/// Start borrow checking by collecting the region constraints for313/// the current body. This initializes the relevant data structures314/// and then type checks the MIR body.315fn borrowck_collect_region_constraints<'tcx>(316    root_cx: &mut BorrowCheckRootCtxt<'tcx>,317    def: LocalDefId,318) -> CollectRegionConstraintsResult<'tcx> {319    let tcx = root_cx.tcx;320    let infcx = BorrowckInferCtxt::new(tcx, def, root_cx.root_def_id());321    let (input_body, promoted) = tcx.mir_promoted(def);322    let input_body: &Body<'_> = &input_body.borrow();323    let input_promoted: &IndexSlice<_, _> = &promoted.borrow();324    if let Some(e) = input_body.tainted_by_errors {325        infcx.set_tainted_by_errors(e);326        root_cx.set_tainted_by_errors(e);327    }328329    // Replace all regions with fresh inference variables. This330    // requires first making our own copy of the MIR. This copy will331    // be modified (in place) to contain non-lexical lifetimes. It332    // will have a lifetime tied to the inference context.333    let mut body_owned = input_body.clone();334    let mut promoted = input_promoted.to_owned();335    let universal_regions = nll::replace_regions_in_mir(&infcx, &mut body_owned, &mut promoted);336    let body = &body_owned; // no further changes337338    let location_table = PoloniusLocationTable::new(body);339340    let move_data = MoveData::gather_moves(body, tcx, |_| true);341342    let locals_are_invalidated_at_exit = tcx.hir_body_owner_kind(def).is_fn_or_closure();343    let borrow_set = BorrowSet::build(tcx, body, locals_are_invalidated_at_exit, &move_data);344345    let location_map = Rc::new(DenseLocationMap::new(body));346347    let polonius_input = root_cx.consumer.as_ref().map_or(false, |c| c.polonius_input())348        || infcx.tcx.sess.opts.unstable_opts.polonius.is_legacy_enabled();349    let mut polonius_facts =350        (polonius_input || PoloniusFacts::enabled(infcx.tcx)).then_some(PoloniusFacts::default());351352    // Run the MIR type-checker.353    let MirTypeckResults {354        constraints,355        universal_region_relations,356        region_bound_pairs,357        known_type_outlives_obligations,358        deferred_closure_requirements,359        polonius_context,360    } = type_check::type_check(361        root_cx,362        &infcx,363        body,364        &promoted,365        universal_regions,366        &location_table,367        &borrow_set,368        &mut polonius_facts,369        &move_data,370        Rc::clone(&location_map),371    );372373    CollectRegionConstraintsResult {374        infcx,375        body_owned,376        promoted,377        move_data,378        borrow_set,379        location_table,380        location_map,381        universal_region_relations,382        region_bound_pairs,383        known_type_outlives_obligations,384        constraints,385        deferred_closure_requirements,386        deferred_opaque_type_errors: Default::default(),387        polonius_facts,388        polonius_context,389    }390}391392/// Using the region constraints computed by [borrowck_collect_region_constraints]393/// and the additional constraints from [BorrowCheckRootCtxt::handle_opaque_type_uses],394/// compute the region graph and actually check for any borrowck errors.395fn borrowck_check_region_constraints<'tcx>(396    root_cx: &mut BorrowCheckRootCtxt<'tcx>,397    CollectRegionConstraintsResult {398        infcx,399        body_owned,400        promoted,401        move_data,402        borrow_set,403        location_table,404        location_map,405        universal_region_relations,406        region_bound_pairs: _,407        known_type_outlives_obligations: _,408        constraints,409        deferred_closure_requirements,410        deferred_opaque_type_errors,411        polonius_facts,412        polonius_context,413    }: CollectRegionConstraintsResult<'tcx>,414) -> PropagatedBorrowCheckResults<'tcx> {415    assert!(!infcx.has_opaque_types_in_storage());416    assert!(deferred_closure_requirements.is_empty());417    let tcx = root_cx.tcx;418    let body = &body_owned;419    let def = body.source.def_id().expect_local();420421    // Compute non-lexical lifetimes using the constraints computed422    // by typechecking the MIR body.423    let nll::NllOutput {424        regioncx,425        polonius_input,426        polonius_output,427        opt_closure_req,428        nll_errors,429        polonius_context,430    } = nll::compute_regions(431        root_cx,432        &infcx,433        body,434        &location_table,435        &move_data,436        &borrow_set,437        location_map,438        universal_region_relations,439        constraints,440        polonius_facts,441        polonius_context,442    );443444    // Dump MIR results into a file, if that is enabled. This lets us445    // write unit-tests, as well as helping with debugging.446    nll::dump_nll_mir(&infcx, body, &regioncx, &opt_closure_req, &borrow_set);447    polonius::dump_polonius_mir(448        &infcx,449        body,450        &regioncx,451        &opt_closure_req,452        &borrow_set,453        polonius_context.as_ref(),454    );455456    // We also have a `#[rustc_regions]` annotation that causes us to dump457    // information.458    nll::dump_annotation(&infcx, body, &regioncx, &opt_closure_req);459460    let movable_coroutine = body.coroutine.is_some()461        && tcx.coroutine_movability(def.to_def_id()) == hir::Movability::Movable;462463    let diags_buffer = &mut BorrowckDiagnosticsBuffer::default();464    // While promoteds should mostly be correct by construction, we need to check them for465    // invalid moves to detect moving out of arrays:`struct S; fn main() { &([S][0]); }`.466    for promoted_body in &promoted {467        use rustc_middle::mir::visit::Visitor;468        // This assumes that we won't use some of the fields of the `promoted_mbcx`469        // when detecting and reporting move errors. While it would be nice to move470        // this check out of `MirBorrowckCtxt`, actually doing so is far from trivial.471        let move_data = MoveData::gather_moves(promoted_body, tcx, |_| true);472        let mut promoted_mbcx = MirBorrowckCtxt {473            root_cx,474            infcx: &infcx,475            body: promoted_body,476            move_data: &move_data,477            // no need to create a real location table for the promoted, it is not used478            location_table: &location_table,479            movable_coroutine,480            fn_self_span_reported: Default::default(),481            access_place_error_reported: Default::default(),482            reservation_error_reported: Default::default(),483            uninitialized_error_reported: Default::default(),484            regioncx: &regioncx,485            used_mut: Default::default(),486            used_mut_upvars: SmallVec::new(),487            borrow_set: &borrow_set,488            upvars: &[],489            local_names: OnceCell::from(IndexVec::from_elem(None, &promoted_body.local_decls)),490            region_names: RefCell::default(),491            next_region_name: RefCell::new(1),492            polonius_output: None,493            move_errors: Vec::new(),494            diags_buffer,495            polonius_context: polonius_context.as_ref(),496        };497        struct MoveVisitor<'a, 'b, 'infcx, 'tcx> {498            ctxt: &'a mut MirBorrowckCtxt<'b, 'infcx, 'tcx>,499        }500501        impl<'tcx> Visitor<'tcx> for MoveVisitor<'_, '_, '_, 'tcx> {502            fn visit_operand(&mut self, operand: &Operand<'tcx>, location: Location) {503                if let Operand::Move(place) = operand {504                    self.ctxt.check_movable_place(location, *place);505                }506            }507        }508        MoveVisitor { ctxt: &mut promoted_mbcx }.visit_body(promoted_body);509        promoted_mbcx.report_move_errors();510    }511512    let mut mbcx = MirBorrowckCtxt {513        root_cx,514        infcx: &infcx,515        body,516        move_data: &move_data,517        location_table: &location_table,518        movable_coroutine,519        fn_self_span_reported: Default::default(),520        access_place_error_reported: Default::default(),521        reservation_error_reported: Default::default(),522        uninitialized_error_reported: Default::default(),523        regioncx: &regioncx,524        used_mut: Default::default(),525        used_mut_upvars: SmallVec::new(),526        borrow_set: &borrow_set,527        upvars: tcx.closure_captures(def),528        local_names: OnceCell::new(),529        region_names: RefCell::default(),530        next_region_name: RefCell::new(1),531        move_errors: Vec::new(),532        diags_buffer,533        polonius_output: polonius_output.as_deref(),534        polonius_context: polonius_context.as_ref(),535    };536537    // Compute and report region errors, if any.538    if nll_errors.is_empty() {539        mbcx.report_opaque_type_errors(deferred_opaque_type_errors);540    } else {541        mbcx.report_region_errors(nll_errors);542    }543544    let flow_results = get_flow_results(tcx, body, &move_data, &borrow_set, &regioncx);545    visit_results(546        body,547        traversal::reverse_postorder(body).map(|(bb, _)| bb),548        &flow_results,549        &mut mbcx,550    );551552    mbcx.report_move_errors();553554    // For each non-user used mutable variable, check if it's been assigned from555    // a user-declared local. If so, then put that local into the used_mut set.556    // Note that this set is expected to be small - only upvars from closures557    // would have a chance of erroneously adding non-user-defined mutable vars558    // to the set.559    let temporary_used_locals: FxIndexSet<Local> = mbcx560        .used_mut561        .iter()562        .filter(|&local| !mbcx.body.local_decls[*local].is_user_variable())563        .cloned()564        .collect();565    // For the remaining unused locals that are marked as mutable, we avoid linting any that566    // were never initialized. These locals may have been removed as unreachable code; or will be567    // linted as unused variables.568    let unused_mut_locals =569        mbcx.body.mut_vars_iter().filter(|local| !mbcx.used_mut.contains(local)).collect();570    mbcx.gather_used_muts(temporary_used_locals, unused_mut_locals);571572    debug!("mbcx.used_mut: {:?}", mbcx.used_mut);573    mbcx.lint_unused_mut();574    if let Some(guar) = mbcx.emit_errors() {575        mbcx.root_cx.set_tainted_by_errors(guar);576    }577578    let result = PropagatedBorrowCheckResults {579        closure_requirements: opt_closure_req,580        used_mut_upvars: mbcx.used_mut_upvars,581    };582583    if let Some(consumer) = &mut root_cx.consumer {584        consumer.insert_body(585            def,586            BodyWithBorrowckFacts {587                body: body_owned,588                promoted,589                borrow_set,590                region_inference_context: regioncx,591                location_table: polonius_input.as_ref().map(|_| location_table),592                input_facts: polonius_input,593                output_facts: polonius_output,594            },595        );596    }597598    debug!("do_mir_borrowck: result = {:#?}", result);599600    result601}602603fn get_flow_results<'a, 'tcx>(604    tcx: TyCtxt<'tcx>,605    body: &'a Body<'tcx>,606    move_data: &'a MoveData<'tcx>,607    borrow_set: &'a BorrowSet<'tcx>,608    regioncx: &RegionInferenceContext<'tcx>,609) -> Results<'tcx, Borrowck<'a, 'tcx>> {610    // We compute these three analyses individually, but them combine them into611    // a single results so that `mbcx` can visit them all together.612    let borrows = Borrows::new(tcx, body, regioncx, borrow_set).iterate_to_fixpoint(613        tcx,614        body,615        Some("borrowck"),616    );617    let uninits = MaybeUninitializedPlaces::new(tcx, body, move_data).iterate_to_fixpoint(618        tcx,619        body,620        Some("borrowck"),621    );622    let ever_inits = EverInitializedPlaces::new(body, move_data).iterate_to_fixpoint(623        tcx,624        body,625        Some("borrowck"),626    );627628    let analysis = Borrowck {629        borrows: borrows.analysis,630        uninits: uninits.analysis,631        ever_inits: ever_inits.analysis,632    };633634    assert_eq!(borrows.entry_states.len(), uninits.entry_states.len());635    assert_eq!(borrows.entry_states.len(), ever_inits.entry_states.len());636    let entry_states: EntryStates<_> =637        itertools::izip!(borrows.entry_states, uninits.entry_states, ever_inits.entry_states)638            .map(|(borrows, uninits, ever_inits)| BorrowckDomain { borrows, uninits, ever_inits })639            .collect();640641    Results { analysis, entry_states }642}643644pub(crate) struct BorrowckInferCtxt<'tcx> {645    pub(crate) infcx: InferCtxt<'tcx>,646    pub(crate) root_def_id: LocalDefId,647    pub(crate) param_env: ParamEnv<'tcx>,648    pub(crate) reg_var_to_origin: RefCell<FxIndexMap<ty::RegionVid, RegionCtxt>>,649}650651impl<'tcx> BorrowckInferCtxt<'tcx> {652    pub(crate) fn new(tcx: TyCtxt<'tcx>, def_id: LocalDefId, root_def_id: LocalDefId) -> Self {653        let typing_mode = if tcx.use_typing_mode_post_typeck_until_borrowck() {654            TypingMode::borrowck(tcx, def_id)655        } else {656            TypingMode::analysis_in_body(tcx, def_id)657        };658        let infcx = tcx.infer_ctxt().build(typing_mode);659        let param_env = tcx.param_env(def_id);660        BorrowckInferCtxt {661            infcx,662            root_def_id,663            reg_var_to_origin: RefCell::new(Default::default()),664            param_env,665        }666    }667668    pub(crate) fn next_region_var<F>(669        &self,670        origin: RegionVariableOrigin<'tcx>,671        get_ctxt_fn: F,672    ) -> ty::Region<'tcx>673    where674        F: Fn() -> RegionCtxt,675    {676        let next_region = self.infcx.next_region_var(origin);677        let vid = next_region.as_var();678679        if cfg!(debug_assertions) {680            debug!("inserting vid {:?} with origin {:?} into var_to_origin", vid, origin);681            let ctxt = get_ctxt_fn();682            let mut var_to_origin = self.reg_var_to_origin.borrow_mut();683            assert_eq!(var_to_origin.insert(vid, ctxt), None);684        }685686        next_region687    }688689    #[instrument(skip(self, get_ctxt_fn), level = "debug")]690    pub(crate) fn next_nll_region_var<F>(691        &self,692        origin: NllRegionVariableOrigin<'tcx>,693        get_ctxt_fn: F,694    ) -> ty::Region<'tcx>695    where696        F: Fn() -> RegionCtxt,697    {698        let next_region = self.infcx.next_nll_region_var(origin);699        let vid = next_region.as_var();700701        if cfg!(debug_assertions) {702            debug!("inserting vid {:?} with origin {:?} into var_to_origin", vid, origin);703            let ctxt = get_ctxt_fn();704            let mut var_to_origin = self.reg_var_to_origin.borrow_mut();705            assert_eq!(var_to_origin.insert(vid, ctxt), None);706        }707708        next_region709    }710}711712impl<'tcx> Deref for BorrowckInferCtxt<'tcx> {713    type Target = InferCtxt<'tcx>;714715    fn deref(&self) -> &Self::Target {716        &self.infcx717    }718}719720pub(crate) struct MirBorrowckCtxt<'a, 'infcx, 'tcx> {721    root_cx: &'a mut BorrowCheckRootCtxt<'tcx>,722    infcx: &'infcx BorrowckInferCtxt<'tcx>,723    body: &'a Body<'tcx>,724    move_data: &'a MoveData<'tcx>,725726    /// Map from MIR `Location` to `LocationIndex`; created727    /// when MIR borrowck begins.728    location_table: &'a PoloniusLocationTable,729730    movable_coroutine: bool,731    /// This field keeps track of when borrow errors are reported in the access_place function732    /// so that there is no duplicate reporting. This field cannot also be used for the conflicting733    /// borrow errors that is handled by the `reservation_error_reported` field as the inclusion734    /// of the `Span` type (while required to mute some errors) stops the muting of the reservation735    /// errors.736    access_place_error_reported: FxIndexSet<(Place<'tcx>, Span)>,737    /// This field keeps track of when borrow conflict errors are reported738    /// for reservations, so that we don't report seemingly duplicate739    /// errors for corresponding activations.740    //741    // FIXME: ideally this would be a set of `BorrowIndex`, not `Place`s,742    // but it is currently inconvenient to track down the `BorrowIndex`743    // at the time we detect and report a reservation error.744    reservation_error_reported: FxIndexSet<Place<'tcx>>,745    /// This fields keeps track of the `Span`s that we have746    /// used to report extra information for `FnSelfUse`, to avoid747    /// unnecessarily verbose errors.748    fn_self_span_reported: FxIndexSet<Span>,749    /// This field keeps track of errors reported in the checking of uninitialized variables,750    /// so that we don't report seemingly duplicate errors.751    uninitialized_error_reported: FxIndexSet<Local>,752    /// This field keeps track of all the local variables that are declared mut and are mutated.753    /// Used for the warning issued by an unused mutable local variable.754    used_mut: FxIndexSet<Local>,755    /// If the function we're checking is a closure, then we'll need to report back the list of756    /// mutable upvars that have been used. This field keeps track of them.757    used_mut_upvars: SmallVec<[FieldIdx; 8]>,758    /// Region inference context. This contains the results from region inference and lets us e.g.759    /// find out which CFG points are contained in each borrow region.760    regioncx: &'a RegionInferenceContext<'tcx>,761762    /// The set of borrows extracted from the MIR763    borrow_set: &'a BorrowSet<'tcx>,764765    /// Information about upvars not necessarily preserved in types or MIR766    upvars: &'tcx [&'tcx ty::CapturedPlace<'tcx>],767768    /// Names of local (user) variables (extracted from `var_debug_info`).769    local_names: OnceCell<IndexVec<Local, Option<Symbol>>>,770771    /// Record the region names generated for each region in the given772    /// MIR def so that we can reuse them later in help/error messages.773    region_names: RefCell<FxIndexMap<RegionVid, RegionName>>,774775    /// The counter for generating new region names.776    next_region_name: RefCell<usize>,777778    diags_buffer: &'a mut BorrowckDiagnosticsBuffer<'infcx, 'tcx>,779    move_errors: Vec<MoveError<'tcx>>,780781    /// Results of Polonius analysis.782    polonius_output: Option<&'a PoloniusOutput>,783    /// When using `-Zpolonius=next`: the data used to compute errors and diagnostics.784    polonius_context: Option<&'a PoloniusContext>,785}786787// Check that:788// 1. assignments are always made to mutable locations (FIXME: does that still really go here?)789// 2. loans made in overlapping scopes do not conflict790// 3. assignments do not affect things loaned out as immutable791// 4. moves do not affect things loaned out in any way792impl<'a, 'tcx> ResultsVisitor<'tcx, Borrowck<'a, 'tcx>> for MirBorrowckCtxt<'a, '_, 'tcx> {793    fn visit_after_early_statement_effect(794        &mut self,795        _analysis: &Borrowck<'a, 'tcx>,796        state: &BorrowckDomain,797        stmt: &Statement<'tcx>,798        location: Location,799    ) {800        debug!("MirBorrowckCtxt::process_statement({:?}, {:?}): {:?}", location, stmt, state);801        let span = stmt.source_info.span;802803        self.check_activations(location, span, state);804805        match &stmt.kind {806            StatementKind::Assign((lhs, rhs)) => {807                self.consume_rvalue(location, (rhs, span), state);808809                self.mutate_place(location, (*lhs, span), Shallow(None), state);810            }811            StatementKind::FakeRead((_, place)) => {812                // Read for match doesn't access any memory and is used to813                // assert that a place is safe and live. So we don't have to814                // do any checks here.815                //816                // FIXME: Remove check that the place is initialized. This is817                // needed for now because matches don't have never patterns yet.818                // So this is the only place we prevent819                //      let x: !;820                //      match x {};821                // from compiling.822                self.check_if_path_or_subpath_is_moved(823                    location,824                    InitializationRequiringAction::Use,825                    (place.as_ref(), span),826                    state,827                );828            }829            StatementKind::Intrinsic(kind) => match kind {830                NonDivergingIntrinsic::Assume(op) => {831                    self.consume_operand(location, (op, span), state);832                }833                NonDivergingIntrinsic::CopyNonOverlapping(..) => span_bug!(834                    span,835                    "Unexpected CopyNonOverlapping, should only appear after lower_intrinsics",836                ),837            },838            // Only relevant for mir typeck839            StatementKind::AscribeUserType(..) => {}840            // Only relevant for liveness and unsafeck841            StatementKind::PlaceMention(..) => {}842            // Doesn't have any language semantics843            StatementKind::Coverage(..) => {}844            // These do not actually affect borrowck845            StatementKind::ConstEvalCounter | StatementKind::StorageLive(..) => {}846            // This does not affect borrowck847            StatementKind::BackwardIncompatibleDropHint {848                place,849                reason: BackwardIncompatibleDropReason::Edition2024,850            } => {851                self.check_backward_incompatible_drop(location, **place, state);852            }853            StatementKind::StorageDead(local) => {854                self.access_place(855                    location,856                    (Place::from(*local), span),857                    (Shallow(None), Write(WriteKind::StorageDeadOrDrop)),858                    LocalMutationIsAllowed::Yes,859                    state,860                );861            }862            StatementKind::Nop | StatementKind::SetDiscriminant { .. } => {863                bug!("Statement not allowed in this MIR phase")864            }865        }866    }867868    fn visit_after_early_terminator_effect(869        &mut self,870        _analysis: &Borrowck<'a, 'tcx>,871        state: &BorrowckDomain,872        term: &Terminator<'tcx>,873        loc: Location,874    ) {875        debug!("MirBorrowckCtxt::process_terminator({:?}, {:?}): {:?}", loc, term, state);876        let span = term.source_info.span;877878        self.check_activations(loc, span, state);879880        match &term.kind {881            TerminatorKind::SwitchInt { discr, targets: _ } => {882                self.consume_operand(loc, (discr, span), state);883            }884            TerminatorKind::Drop { place, target: _, unwind: _, replace, drop: _ } => {885                debug!(886                    "visit_terminator_drop \887                     loc: {:?} term: {:?} place: {:?} span: {:?}",888                    loc, term, place, span889                );890891                let write_kind =892                    if *replace { WriteKind::Replace } else { WriteKind::StorageDeadOrDrop };893                self.access_place(894                    loc,895                    (*place, span),896                    (AccessDepth::Drop, Write(write_kind)),897                    LocalMutationIsAllowed::Yes,898                    state,899                );900            }901            TerminatorKind::Call {902                func,903                args,904                destination,905                target: _,906                unwind: _,907                call_source: _,908                fn_span: _,909            } => {910                self.consume_operand(loc, (func, span), state);911                for arg in args {912                    self.consume_operand(loc, (&arg.node, arg.span), state);913                }914                self.mutate_place(loc, (*destination, span), Deep, state);915            }916            TerminatorKind::TailCall { func, args, fn_span: _ } => {917                self.consume_operand(loc, (func, span), state);918                for arg in args {919                    self.consume_operand(loc, (&arg.node, arg.span), state);920                }921            }922            TerminatorKind::Assert { cond, expected: _, msg, target: _, unwind: _ } => {923                self.consume_operand(loc, (cond, span), state);924                if let AssertKind::BoundsCheck { len, index } = &**msg {925                    self.consume_operand(loc, (len, span), state);926                    self.consume_operand(loc, (index, span), state);927                }928            }929930            TerminatorKind::Yield { value, resume: _, resume_arg, drop: _ } => {931                self.consume_operand(loc, (value, span), state);932                self.mutate_place(loc, (*resume_arg, span), Deep, state);933            }934935            TerminatorKind::InlineAsm {936                asm_macro: _,937                template: _,938                operands,939                options: _,940                line_spans: _,941                targets: _,942                unwind: _,943            } => {944                for op in operands {945                    match op {946                        InlineAsmOperand::In { reg: _, value } => {947                            self.consume_operand(loc, (value, span), state);948                        }949                        InlineAsmOperand::Out { reg: _, late: _, place, .. } => {950                            if let Some(place) = place {951                                self.mutate_place(loc, (*place, span), Shallow(None), state);952                            }953                        }954                        InlineAsmOperand::InOut { reg: _, late: _, in_value, out_place } => {955                            self.consume_operand(loc, (in_value, span), state);956                            if let &Some(out_place) = out_place {957                                self.mutate_place(loc, (out_place, span), Shallow(None), state);958                            }959                        }960                        InlineAsmOperand::Const { value: _ }961                        | InlineAsmOperand::SymFn { value: _ }962                        | InlineAsmOperand::SymStatic { def_id: _ }963                        | InlineAsmOperand::Label { target_index: _ } => {}964                    }965                }966            }967968            TerminatorKind::Goto { target: _ }969            | TerminatorKind::UnwindTerminate(_)970            | TerminatorKind::Unreachable971            | TerminatorKind::UnwindResume972            | TerminatorKind::Return973            | TerminatorKind::CoroutineDrop974            | TerminatorKind::FalseEdge { real_target: _, imaginary_target: _ }975            | TerminatorKind::FalseUnwind { real_target: _, unwind: _ } => {976                // no data used, thus irrelevant to borrowck977            }978        }979    }980981    fn visit_after_primary_terminator_effect(982        &mut self,983        _analysis: &Borrowck<'a, 'tcx>,984        state: &BorrowckDomain,985        term: &Terminator<'tcx>,986        loc: Location,987    ) {988        let span = term.source_info.span;989990        match term.kind {991            TerminatorKind::Yield { value: _, resume: _, resume_arg: _, drop: _ } => {992                if self.movable_coroutine {993                    // Look for any active borrows to locals994                    for i in state.borrows.iter() {995                        let borrow = &self.borrow_set[i];996                        self.check_for_local_borrow(borrow, span);997                    }998                }999            }10001001            TerminatorKind::UnwindResume1002            | TerminatorKind::Return1003            | TerminatorKind::TailCall { .. }1004            | TerminatorKind::CoroutineDrop => {1005                match self.borrow_set.locals_state_at_exit() {1006                    LocalsStateAtExit::AllAreInvalidated => {1007                        // Returning from the function implicitly kills storage for all locals and statics.1008                        // Often, the storage will already have been killed by an explicit1009                        // StorageDead, but we don't always emit those (notably on unwind paths),1010                        // so this "extra check" serves as a kind of backup.1011                        for i in state.borrows.iter() {1012                            let borrow = &self.borrow_set[i];1013                            self.check_for_invalidation_at_exit(loc, borrow, span);1014                        }1015                    }1016                    // If we do not implicitly invalidate all locals on exit,1017                    // we check for conflicts when dropping or moving this local.1018                    LocalsStateAtExit::SomeAreInvalidated { has_storage_dead_or_moved: _ } => {}1019                }1020            }10211022            TerminatorKind::UnwindTerminate(_)1023            | TerminatorKind::Assert { .. }1024            | TerminatorKind::Call { .. }1025            | TerminatorKind::Drop { .. }1026            | TerminatorKind::FalseEdge { real_target: _, imaginary_target: _ }1027            | TerminatorKind::FalseUnwind { real_target: _, unwind: _ }1028            | TerminatorKind::Goto { .. }1029            | TerminatorKind::SwitchInt { .. }1030            | TerminatorKind::Unreachable1031            | TerminatorKind::InlineAsm { .. } => {}1032        }1033    }1034}10351036use self::AccessDepth::{Deep, Shallow};1037use self::ReadOrWrite::{Activation, Read, Reservation, Write};10381039#[derive(Copy, Clone, PartialEq, Eq, Debug)]1040enum ArtificialField {1041    ArrayLength,1042    FakeBorrow,1043}10441045#[derive(Copy, Clone, PartialEq, Eq, Debug)]1046enum AccessDepth {1047    /// From the RFC: "A *shallow* access means that the immediate1048    /// fields reached at P are accessed, but references or pointers1049    /// found within are not dereferenced. Right now, the only access1050    /// that is shallow is an assignment like `x = ...;`, which would1051    /// be a *shallow write* of `x`."1052    Shallow(Option<ArtificialField>),10531054    /// From the RFC: "A *deep* access means that all data reachable1055    /// through the given place may be invalidated or accesses by1056    /// this action."1057    Deep,10581059    /// Access is Deep only when there is a Drop implementation that1060    /// can reach the data behind the reference.1061    Drop,1062}10631064/// Kind of access to a value: read or write1065/// (For informational purposes only)1066#[derive(Copy, Clone, PartialEq, Eq, Debug)]1067enum ReadOrWrite {1068    /// From the RFC: "A *read* means that the existing data may be1069    /// read, but will not be changed."1070    Read(ReadKind),10711072    /// From the RFC: "A *write* means that the data may be mutated to1073    /// new values or otherwise invalidated (for example, it could be1074    /// de-initialized, as in a move operation).1075    Write(WriteKind),10761077    /// For two-phase borrows, we distinguish a reservation (which is treated1078    /// like a Read) from an activation (which is treated like a write), and1079    /// each of those is furthermore distinguished from Reads/Writes above.1080    Reservation(WriteKind),1081    Activation(WriteKind, BorrowIndex),1082}10831084/// Kind of read access to a value1085/// (For informational purposes only)1086#[derive(Copy, Clone, PartialEq, Eq, Debug)]1087enum ReadKind {1088    Borrow(BorrowKind),1089    Copy,1090}10911092/// Kind of write access to a value1093/// (For informational purposes only)1094#[derive(Copy, Clone, PartialEq, Eq, Debug)]1095enum WriteKind {1096    StorageDeadOrDrop,1097    Replace,1098    MutableBorrow(BorrowKind),1099    Mutate,1100    Move,1101}11021103/// When checking permissions for a place access, this flag is used to indicate that an immutable1104/// local place can be mutated.1105//1106// FIXME: @nikomatsakis suggested that this flag could be removed with the following modifications:1107// - Split `is_mutable()` into `is_assignable()` (can be directly assigned) and1108//   `is_declared_mutable()`.1109// - Take flow state into consideration in `is_assignable()` for local variables.1110#[derive(Copy, Clone, PartialEq, Eq, Debug)]1111enum LocalMutationIsAllowed {1112    Yes,1113    /// We want use of immutable upvars to cause a "write to immutable upvar"1114    /// error, not an "reassignment" error.1115    ExceptUpvars,1116    No,1117}11181119#[derive(Copy, Clone, Debug)]1120enum InitializationRequiringAction {1121    Borrow,1122    MatchOn,1123    Use,1124    Assignment,1125    PartialAssignment,1126}11271128#[derive(Debug)]1129struct RootPlace<'tcx> {1130    place_local: Local,1131    place_projection: &'tcx [PlaceElem<'tcx>],1132    is_local_mutation_allowed: LocalMutationIsAllowed,1133}11341135impl InitializationRequiringAction {1136    fn as_noun(self) -> &'static str {1137        match self {1138            InitializationRequiringAction::Borrow => "borrow",1139            InitializationRequiringAction::MatchOn => "use", // no good noun1140            InitializationRequiringAction::Use => "use",1141            InitializationRequiringAction::Assignment => "assign",1142            InitializationRequiringAction::PartialAssignment => "assign to part",1143        }1144    }11451146    fn as_verb_in_past_tense(self) -> &'static str {1147        match self {1148            InitializationRequiringAction::Borrow => "borrowed",1149            InitializationRequiringAction::MatchOn => "matched on",1150            InitializationRequiringAction::Use => "used",1151            InitializationRequiringAction::Assignment => "assigned",1152            InitializationRequiringAction::PartialAssignment => "partially assigned",1153        }1154    }11551156    fn as_general_verb_in_past_tense(self) -> &'static str {1157        match self {1158            InitializationRequiringAction::Borrow1159            | InitializationRequiringAction::MatchOn1160            | InitializationRequiringAction::Use => "used",1161            InitializationRequiringAction::Assignment => "assigned",1162            InitializationRequiringAction::PartialAssignment => "partially assigned",1163        }1164    }1165}11661167impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {1168    fn body(&self) -> &'a Body<'tcx> {1169        self.body1170    }11711172    /// Checks an access to the given place to see if it is allowed. Examines the set of borrows1173    /// that are in scope, as well as which paths have been initialized, to ensure that (a) the1174    /// place is initialized and (b) it is not borrowed in some way that would prevent this1175    /// access.1176    ///1177    /// Returns `true` if an error is reported.1178    fn access_place(1179        &mut self,1180        location: Location,1181        place_span: (Place<'tcx>, Span),1182        kind: (AccessDepth, ReadOrWrite),1183        is_local_mutation_allowed: LocalMutationIsAllowed,1184        state: &BorrowckDomain,1185    ) {1186        let (sd, rw) = kind;11871188        if let Activation(_, borrow_index) = rw {1189            if self.reservation_error_reported.contains(&place_span.0) {1190                debug!(1191                    "skipping access_place for activation of invalid reservation \1192                     place: {:?} borrow_index: {:?}",1193                    place_span.0, borrow_index1194                );1195                return;1196            }1197        }11981199        // Check is_empty() first because it's the common case, and doing that1200        // way we avoid the clone() call.1201        if !self.access_place_error_reported.is_empty()1202            && self.access_place_error_reported.contains(&(place_span.0, place_span.1))1203        {1204            debug!(1205                "access_place: suppressing error place_span=`{:?}` kind=`{:?}`",1206                place_span, kind1207            );12081209            // If the place is being mutated, then mark it as such anyway in order to suppress the1210            // `unused_mut` lint, which is likely incorrect once the access place error has been1211            // resolved.1212            if rw == ReadOrWrite::Write(WriteKind::Mutate)1213                && let Ok(root_place) =1214                    self.is_mutable(place_span.0.as_ref(), is_local_mutation_allowed)1215            {1216                self.add_used_mut(root_place, state);1217            }12181219            return;1220        }12211222        let mutability_error = self.check_access_permissions(1223            place_span,1224            rw,1225            is_local_mutation_allowed,1226            state,1227            location,1228        );1229        let conflict_error = self.check_access_for_conflict(location, place_span, sd, rw, state);12301231        if conflict_error || mutability_error {1232            debug!("access_place: logging error place_span=`{:?}` kind=`{:?}`", place_span, kind);1233            self.access_place_error_reported.insert((place_span.0, place_span.1));1234        }1235    }12361237    fn borrows_in_scope<'s>(1238        &self,1239        location: Location,1240        state: &'s BorrowckDomain,1241    ) -> Cow<'s, MixedBitSet<BorrowIndex>> {1242        if let Some(polonius) = &self.polonius_output {1243            // Use polonius output if it has been enabled.1244            let location = self.location_table.start_index(location);1245            let mut polonius_output = MixedBitSet::new_empty(self.borrow_set.len());1246            for &idx in polonius.errors_at(location) {1247                polonius_output.insert(idx);1248            }1249            Cow::Owned(polonius_output)1250        } else {1251            Cow::Borrowed(&state.borrows)1252        }1253    }12541255    #[instrument(level = "debug", skip(self, state))]1256    fn check_access_for_conflict(1257        &mut self,1258        location: Location,1259        place_span: (Place<'tcx>, Span),1260        sd: AccessDepth,1261        rw: ReadOrWrite,1262        state: &BorrowckDomain,1263    ) -> bool {1264        let mut error_reported = false;12651266        let borrows_in_scope = self.borrows_in_scope(location, state);1267        debug!(?borrows_in_scope, ?location);12681269        each_borrow_involving_path(1270            self,1271            self.infcx.tcx,1272            self.body,1273            (sd, place_span.0),1274            self.borrow_set,1275            |borrow_index| borrows_in_scope.contains(borrow_index),1276            |this, borrow_index, borrow| match (rw, borrow.kind) {1277                // Obviously an activation is compatible with its own1278                // reservation (or even prior activating uses of same1279                // borrow); so don't check if they interfere.1280                //1281                // NOTE: *reservations* do conflict with themselves;1282                // thus aren't injecting unsoundness w/ this check.)1283                (Activation(_, activating), _) if activating == borrow_index => {1284                    debug!(1285                        "check_access_for_conflict place_span: {:?} sd: {:?} rw: {:?} \1286                         skipping {:?} b/c activation of same borrow_index",1287                        place_span,1288                        sd,1289                        rw,1290                        (borrow_index, borrow),1291                    );1292                    ControlFlow::Continue(())1293                }12941295                (Read(_), BorrowKind::Shared | BorrowKind::Fake(_))1296                | (1297                    Read(ReadKind::Borrow(BorrowKind::Fake(FakeBorrowKind::Shallow))),1298                    BorrowKind::Mut { .. },1299                ) => ControlFlow::Continue(()),13001301                (Reservation(_), BorrowKind::Fake(_) | BorrowKind::Shared) => {1302                    // This used to be a future compatibility warning (to be1303                    // disallowed on NLL). See rust-lang/rust#562541304                    ControlFlow::Continue(())1305                }13061307                (Write(WriteKind::Move), BorrowKind::Fake(FakeBorrowKind::Shallow)) => {1308                    // Handled by initialization checks.1309                    ControlFlow::Continue(())1310                }13111312                (Read(kind), BorrowKind::Mut { .. }) => {1313                    // Reading from mere reservations of mutable-borrows is OK.1314                    if !is_active(this.dominators(), borrow, location) {1315                        assert!(borrow.kind.is_two_phase_borrow());1316                        return ControlFlow::Continue(());1317                    }13181319                    error_reported = true;1320                    match kind {1321                        ReadKind::Copy => {1322                            let err = this1323                                .report_use_while_mutably_borrowed(location, place_span, borrow);1324                            this.buffer_error(err);1325                        }1326                        ReadKind::Borrow(bk) => {1327                            let err =1328                                this.report_conflicting_borrow(location, place_span, bk, borrow);1329                            this.buffer_error(err);1330                        }1331                    }1332                    ControlFlow::Break(())1333                }13341335                (Reservation(kind) | Activation(kind, _) | Write(kind), _) => {1336                    match rw {1337                        Reservation(..) => {1338                            debug!(1339                                "recording invalid reservation of \1340                                 place: {:?}",1341                                place_span.01342                            );1343                            this.reservation_error_reported.insert(place_span.0);1344                        }1345                        Activation(_, activating) => {1346                            debug!(1347                                "observing check_place for activation of \1348                                 borrow_index: {:?}",1349                                activating1350                            );1351                        }1352                        Read(..) | Write(..) => {}1353                    }13541355                    error_reported = true;1356                    match kind {1357                        WriteKind::MutableBorrow(bk) => {1358                            let err =1359                                this.report_conflicting_borrow(location, place_span, bk, borrow);1360                            this.buffer_error(err);1361                        }1362                        WriteKind::StorageDeadOrDrop => this1363                            .report_borrowed_value_does_not_live_long_enough(1364                                location,1365                                borrow,1366                                place_span,1367                                Some(WriteKind::StorageDeadOrDrop),1368                            ),1369                        WriteKind::Mutate => {1370                            this.report_illegal_mutation_of_borrowed(location, place_span, borrow)1371                        }1372                        WriteKind::Move => {1373                            this.report_move_out_while_borrowed(location, place_span, borrow)1374                        }1375                        WriteKind::Replace => {1376                            this.report_illegal_mutation_of_borrowed(location, place_span, borrow)1377                        }1378                    }1379                    ControlFlow::Break(())1380                }1381            },1382        );13831384        error_reported1385    }13861387    /// Through #123739, `BackwardIncompatibleDropHint`s (BIDs) are introduced.1388    /// We would like to emit lints whether borrow checking fails at these future drop locations.1389    #[instrument(level = "debug", skip(self, state))]1390    fn check_backward_incompatible_drop(1391        &mut self,1392        location: Location,1393        place: Place<'tcx>,1394        state: &BorrowckDomain,1395    ) {1396        let tcx = self.infcx.tcx;1397        // If this type does not need `Drop`, then treat it like a `StorageDead`.1398        // This is needed because we track the borrows of refs to thread locals,1399        // and we'll ICE because we don't track borrows behind shared references.1400        let sd = if place.ty(self.body, tcx).ty.needs_drop(tcx, self.body.typing_env(tcx)) {1401            AccessDepth::Drop1402        } else {1403            AccessDepth::Shallow(None)1404        };14051406        let borrows_in_scope = self.borrows_in_scope(location, state);14071408        // This is a very simplified version of `Self::check_access_for_conflict`.1409        // We are here checking on BIDs and specifically still-live borrows of data involving the BIDs.1410        each_borrow_involving_path(1411            self,1412            self.infcx.tcx,1413            self.body,1414            (sd, place),1415            self.borrow_set,1416            |borrow_index| borrows_in_scope.contains(borrow_index),1417            |this, _borrow_index, borrow| {1418                if matches!(borrow.kind, BorrowKind::Fake(_)) {1419                    return ControlFlow::Continue(());1420                }1421                let borrowed = this.retrieve_borrow_spans(borrow).var_or_use_path_span();1422                let explain = this.explain_why_borrow_contains_point(1423                    location,1424                    borrow,1425                    Some((WriteKind::StorageDeadOrDrop, place)),1426                );1427                this.infcx.tcx.emit_node_span_lint(1428                    TAIL_EXPR_DROP_ORDER,1429                    CRATE_HIR_ID,1430                    borrowed,1431                    session_diagnostics::TailExprDropOrder {1432                        borrowed,1433                        callback: |diag| {1434                            explain.add_explanation_to_diagnostic(&this, diag, "", None, None);1435                        },1436                    },1437                );1438                // We may stop at the first case1439                ControlFlow::Break(())1440            },1441        );1442    }14431444    fn mutate_place(1445        &mut self,1446        location: Location,1447        place_span: (Place<'tcx>, Span),1448        kind: AccessDepth,1449        state: &BorrowckDomain,1450    ) {1451        // Write of P[i] or *P requires P init'd.1452        self.check_if_assigned_path_is_moved(location, place_span, state);14531454        self.access_place(1455            location,1456            place_span,1457            (kind, Write(WriteKind::Mutate)),1458            LocalMutationIsAllowed::No,1459            state,1460        );1461    }14621463    fn consume_rvalue(1464        &mut self,1465        location: Location,1466        (rvalue, span): (&Rvalue<'tcx>, Span),1467        state: &BorrowckDomain,1468    ) {1469        match rvalue {1470            &Rvalue::Ref(_ /*rgn*/, bk, place) => {1471                let access_kind = match bk {1472                    BorrowKind::Fake(FakeBorrowKind::Shallow) => {1473                        (Shallow(Some(ArtificialField::FakeBorrow)), Read(ReadKind::Borrow(bk)))1474                    }1475                    BorrowKind::Shared | BorrowKind::Fake(FakeBorrowKind::Deep) => {1476                        (Deep, Read(ReadKind::Borrow(bk)))1477                    }1478                    BorrowKind::Mut { .. } => {1479                        let wk = WriteKind::MutableBorrow(bk);1480                        if bk.is_two_phase_borrow() {1481                            (Deep, Reservation(wk))1482                        } else {1483                            (Deep, Write(wk))1484                        }1485                    }1486                };14871488                self.access_place(1489                    location,1490                    (place, span),1491                    access_kind,1492                    LocalMutationIsAllowed::No,1493                    state,1494                );14951496                let action = if bk == BorrowKind::Fake(FakeBorrowKind::Shallow) {1497                    InitializationRequiringAction::MatchOn1498                } else {1499                    InitializationRequiringAction::Borrow1500                };15011502                self.check_if_path_or_subpath_is_moved(1503                    location,1504                    action,1505                    (place.as_ref(), span),1506                    state,1507                );1508            }15091510            &Rvalue::Reborrow(_target, mutability, place) => {1511                let access_kind = (1512                    Deep,1513                    if mutability == Mutability::Mut {1514                        Write(WriteKind::MutableBorrow(BorrowKind::Mut {1515                            kind: MutBorrowKind::Default,1516                        }))1517                    } else {1518                        Read(ReadKind::Borrow(BorrowKind::Shared))1519                    },1520                );15211522                self.access_place(1523                    location,1524                    (place, span),1525                    access_kind,1526                    LocalMutationIsAllowed::Yes,1527                    state,1528                );15291530                let action = InitializationRequiringAction::Borrow;15311532                self.check_if_path_or_subpath_is_moved(1533                    location,1534                    action,1535                    (place.as_ref(), span),1536                    state,1537                );1538            }15391540            &Rvalue::RawPtr(kind, place) => {1541                let access_kind = match kind {1542                    RawPtrKind::Mut => (1543                        Deep,1544                        Write(WriteKind::MutableBorrow(BorrowKind::Mut {1545                            kind: MutBorrowKind::Default,1546                        })),1547                    ),1548                    RawPtrKind::Const => (Deep, Read(ReadKind::Borrow(BorrowKind::Shared))),1549                    RawPtrKind::FakeForPtrMetadata => {1550                        (Shallow(Some(ArtificialField::ArrayLength)), Read(ReadKind::Copy))1551                    }1552                };15531554                self.access_place(1555                    location,1556                    (place, span),1557                    access_kind,1558                    LocalMutationIsAllowed::No,1559                    state,1560                );15611562                self.check_if_path_or_subpath_is_moved(1563                    location,1564                    InitializationRequiringAction::Borrow,1565                    (place.as_ref(), span),1566                    state,1567                );1568            }15691570            Rvalue::ThreadLocalRef(_) => {}15711572            Rvalue::Use(operand, _)1573            | Rvalue::Repeat(operand, _)1574            | Rvalue::UnaryOp(_ /*un_op*/, operand)1575            | Rvalue::Cast(_ /*cast_kind*/, operand, _ /*ty*/) => {1576                self.consume_operand(location, (operand, span), state)1577            }15781579            &Rvalue::Discriminant(place) => {1580                let af = match *rvalue {1581                    Rvalue::Discriminant(..) => None,1582                    _ => unreachable!(),1583                };1584                self.access_place(1585                    location,1586                    (place, span),1587                    (Shallow(af), Read(ReadKind::Copy)),1588                    LocalMutationIsAllowed::No,1589                    state,1590                );1591                self.check_if_path_or_subpath_is_moved(1592                    location,1593                    InitializationRequiringAction::Use,1594                    (place.as_ref(), span),1595                    state,1596                );1597            }15981599            Rvalue::BinaryOp(_bin_op, (operand1, operand2)) => {1600                self.consume_operand(location, (operand1, span), state);1601                self.consume_operand(location, (operand2, span), state);1602            }16031604            Rvalue::Aggregate(aggregate_kind, operands) => {1605                // We need to report back the list of mutable upvars that were1606                // moved into the closure and subsequently used by the closure,1607                // in order to populate our used_mut set.1608                match **aggregate_kind {1609                    AggregateKind::Closure(def_id, _)1610                    | AggregateKind::CoroutineClosure(def_id, _)1611                    | AggregateKind::Coroutine(def_id, _) => {1612                        let def_id = def_id.expect_local();1613                        let used_mut_upvars = self.root_cx.used_mut_upvars(def_id);1614                        debug!("{:?} used_mut_upvars={:?}", def_id, used_mut_upvars);1615                        // FIXME: We're cloning the `SmallVec` here to avoid borrowing `root_cx`1616                        // when calling `propagate_closure_used_mut_upvar`. This should ideally1617                        // be unnecessary.1618                        for field in used_mut_upvars.clone() {1619                            self.propagate_closure_used_mut_upvar(&operands[field]);1620                        }1621                    }1622                    AggregateKind::Adt(..)1623                    | AggregateKind::Array(..)1624                    | AggregateKind::Tuple { .. }1625                    | AggregateKind::RawPtr(..) => (),1626                }16271628                for operand in operands {1629                    self.consume_operand(location, (operand, span), state);1630                }1631            }16321633            Rvalue::WrapUnsafeBinder(op, _) => {1634                self.consume_operand(location, (op, span), state);1635            }16361637            Rvalue::CopyForDeref(_) => bug!("`CopyForDeref` in borrowck"),1638        }1639    }16401641    fn propagate_closure_used_mut_upvar(&mut self, operand: &Operand<'tcx>) {1642        let propagate_closure_used_mut_place = |this: &mut Self, place: Place<'tcx>| {1643            // We have three possibilities here:1644            // a. We are modifying something through a mut-ref1645            // b. We are modifying something that is local to our parent1646            // c. Current body is a nested closure, and we are modifying path starting from1647            //    a Place captured by our parent closure.16481649            // Handle (c), the path being modified is exactly the path captured by our parent1650            if let Some(field) = this.is_upvar_field_projection(place.as_ref()) {1651                this.used_mut_upvars.push(field);1652                return;1653            }16541655            for (place_ref, proj) in place.iter_projections().rev() {1656                // Handle (a)1657                if proj == ProjectionElem::Deref {1658                    match place_ref.ty(this.body(), this.infcx.tcx).ty.kind() {1659                        // We aren't modifying a variable directly1660                        ty::Ref(_, _, hir::Mutability::Mut) => return,16611662                        _ => {}1663                    }1664                }16651666                // Handle (c)1667                if let Some(field) = this.is_upvar_field_projection(place_ref) {1668                    this.used_mut_upvars.push(field);1669                    return;1670                }1671            }16721673            // Handle(b)1674            this.used_mut.insert(place.local);1675        };16761677        // This relies on the current way that by-value1678        // captures of a closure are copied/moved directly1679        // when generating MIR.1680        match *operand {1681            Operand::Move(place) | Operand::Copy(place) => {1682                match place.as_local() {1683                    Some(local) if !self.body.local_decls[local].is_user_variable() => {1684                        if self.body.local_decls[local].ty.is_mutable_ptr() {1685                            // The variable will be marked as mutable by the borrow.1686                            return;1687                        }1688                        // This is an edge case where we have a `move` closure1689                        // inside a non-move closure, and the inner closure1690                        // contains a mutation:1691                        //1692                        // let mut i = 0;1693                        // || { move || { i += 1; }; };1694                        //1695                        // In this case our usual strategy of assuming that the1696                        // variable will be captured by mutable reference is1697                        // wrong, since `i` can be copied into the inner1698                        // closure from a shared reference.1699                        //1700                        // As such we have to search for the local that this1701                        // capture comes from and mark it as being used as mut.17021703                        let Some(temp_mpi) = self.move_data.rev_lookup.find_local(local) else {1704                            bug!("temporary should be tracked");1705                        };1706                        let init = if let [init_index] = *self.move_data.init_path_map[temp_mpi] {1707                            &self.move_data.inits[init_index]1708                        } else {1709                            bug!("temporary should be initialized exactly once")1710                        };17111712                        let InitLocation::Statement(loc) = init.location else {1713                            bug!("temporary initialized in arguments")1714                        };17151716                        let body = self.body;1717                        let bbd = &body[loc.block];1718                        let stmt = &bbd.statements[loc.statement_index];1719                        debug!("temporary assigned in: stmt={:?}", stmt);17201721                        match stmt.kind {1722                            StatementKind::Assign((1723                                _,1724                                Rvalue::Ref(_, _, source)1725                                | Rvalue::Use(Operand::Copy(source) | Operand::Move(source), _),1726                            )) => {1727                                propagate_closure_used_mut_place(self, source);1728                            }1729                            _ => {1730                                bug!(1731                                    "closures should only capture user variables \1732                                 or references to user variables"1733                                );1734                            }1735                        }1736                    }1737                    _ => propagate_closure_used_mut_place(self, place),1738                }1739            }1740            Operand::Constant(..) | Operand::RuntimeChecks(_) => {}1741        }1742    }17431744    fn consume_operand(1745        &mut self,1746        location: Location,1747        (operand, span): (&Operand<'tcx>, Span),1748        state: &BorrowckDomain,1749    ) {1750        match *operand {1751            Operand::Copy(place) => {1752                // copy of place: check if this is "copy of frozen path"1753                // (FIXME: see check_loans.rs)1754                self.access_place(1755                    location,1756                    (place, span),1757                    (Deep, Read(ReadKind::Copy)),1758                    LocalMutationIsAllowed::No,1759                    state,1760                );17611762                // Finally, check if path was already moved.1763                self.check_if_path_or_subpath_is_moved(1764                    location,1765                    InitializationRequiringAction::Use,1766                    (place.as_ref(), span),1767                    state,1768                );1769            }1770            Operand::Move(place) => {1771                // Check if moving from this place makes sense.1772                self.check_movable_place(location, place);17731774                // move of place: check if this is move of already borrowed path1775                self.access_place(1776                    location,1777                    (place, span),1778                    (Deep, Write(WriteKind::Move)),1779                    LocalMutationIsAllowed::Yes,1780                    state,1781                );17821783                // Finally, check if path was already moved.1784                self.check_if_path_or_subpath_is_moved(1785                    location,1786                    InitializationRequiringAction::Use,1787                    (place.as_ref(), span),1788                    state,1789                );1790            }1791            Operand::Constant(_) | Operand::RuntimeChecks(_) => {}1792        }1793    }17941795    /// Checks whether a borrow of this place is invalidated when the function1796    /// exits1797    #[instrument(level = "debug", skip(self))]1798    fn check_for_invalidation_at_exit(1799        &mut self,1800        location: Location,1801        borrow: &BorrowData<'tcx>,1802        span: Span,1803    ) {1804        let place = borrow.borrowed_place;1805        let mut root_place = PlaceRef { local: place.local, projection: &[] };18061807        // FIXME(nll-rfc#40): do more precise destructor tracking here. For now1808        // we just know that all locals are dropped at function exit (otherwise1809        // we'll have a memory leak) and assume that all statics have a destructor.1810        //1811        // FIXME: allow thread-locals to borrow other thread locals?1812        let might_be_alive = if self.body.local_decls[root_place.local].is_ref_to_thread_local() {1813            // Thread-locals might be dropped after the function exits1814            // We have to dereference the outer reference because1815            // borrows don't conflict behind shared references.1816            root_place.projection = TyCtxtConsts::DEREF_PROJECTION;1817            true1818        } else {1819            false1820        };18211822        let sd = if might_be_alive { Deep } else { Shallow(None) };18231824        if places_conflict::borrow_conflicts_with_place(1825            self.infcx.tcx,1826            self.body,1827            place,1828            borrow.kind,1829            root_place,1830            sd,1831            places_conflict::PlaceConflictBias::Overlap,1832        ) {1833            debug!("check_for_invalidation_at_exit({:?}): INVALID", place);1834            // FIXME: should be talking about the region lifetime instead1835            // of just a span here.1836            let span = self.infcx.tcx.sess.source_map().end_point(span);1837            self.report_borrowed_value_does_not_live_long_enough(1838                location,1839                borrow,1840                (place, span),1841                None,1842            )1843        }1844    }18451846    /// Reports an error if this is a borrow of local data.1847    /// This is called for all Yield expressions on movable coroutines1848    fn check_for_local_borrow(&mut self, borrow: &BorrowData<'tcx>, yield_span: Span) {1849        debug!("check_for_local_borrow({:?})", borrow);18501851        if borrow_of_local_data(borrow.borrowed_place) {1852            let err = self.cannot_borrow_across_coroutine_yield(1853                self.retrieve_borrow_spans(borrow).var_or_use(),1854                yield_span,1855            );18561857            self.buffer_error(err);1858        }1859    }18601861    fn check_activations(&mut self, location: Location, span: Span, state: &BorrowckDomain) {1862        // Two-phase borrow support: For each activation that is newly1863        // generated at this statement, check if it interferes with1864        // another borrow.1865        for &borrow_index in self.borrow_set.activations_at_location(location) {1866            let borrow = &self.borrow_set[borrow_index];18671868            // only mutable borrows should be 2-phase1869            assert!(match borrow.kind {1870                BorrowKind::Shared | BorrowKind::Fake(_) => false,1871                BorrowKind::Mut { .. } => true,1872            });18731874            self.access_place(1875                location,1876                (borrow.borrowed_place, span),1877                (Deep, Activation(WriteKind::MutableBorrow(borrow.kind), borrow_index)),1878                LocalMutationIsAllowed::No,1879                state,1880            );1881            // We do not need to call `check_if_path_or_subpath_is_moved`1882            // again, as we already called it when we made the1883            // initial reservation.1884        }1885    }18861887    fn check_movable_place(&mut self, location: Location, place: Place<'tcx>) {1888        use IllegalMoveOriginKind::*;18891890        let body = self.body;1891        let tcx = self.infcx.tcx;1892        let mut place_ty = PlaceTy::from_ty(body.local_decls[place.local].ty);1893        for (place_ref, elem) in place.iter_projections() {1894            match elem {1895                ProjectionElem::Deref => match place_ty.ty.kind() {1896                    ty::Ref(..) | ty::RawPtr(..) => {1897                        self.move_errors.push(MoveError::new(1898                            place,1899                            location,1900                            BorrowedContent {1901                                target_place: place_ref.project_deeper(&[elem], tcx),1902                            },1903                        ));1904                        return;1905                    }1906                    ty::Adt(adt, _) => {1907                        if !adt.is_box() {1908                            bug!("Adt should be a box type when Place is deref");1909                        }1910                    }1911                    ty::Bool1912                    | ty::Char1913                    | ty::Int(_)1914                    | ty::Uint(_)1915                    | ty::Float(_)1916                    | ty::Foreign(_)1917                    | ty::Str1918                    | ty::Array(_, _)1919                    | ty::Pat(_, _)1920                    | ty::Slice(_)1921                    | ty::FnDef(_, _)1922                    | ty::FnPtr(..)1923                    | ty::Dynamic(_, _)1924                    | ty::Closure(_, _)1925                    | ty::CoroutineClosure(_, _)1926                    | ty::Coroutine(_, _)1927                    | ty::CoroutineWitness(..)1928                    | ty::Never1929                    | ty::Tuple(_)1930                    | ty::UnsafeBinder(_)1931                    | ty::Alias(_)1932                    | ty::Param(_)1933                    | ty::Bound(_, _)1934                    | ty::Infer(_)1935                    | ty::Error(_)1936                    | ty::Placeholder(_) => {1937                        bug!("When Place is Deref it's type shouldn't be {place_ty:#?}")1938                    }1939                },1940                ProjectionElem::Field(_, _) => match place_ty.ty.kind() {1941                    ty::Adt(adt, _) => {1942                        if adt.has_dtor(tcx) {1943                            self.move_errors.push(MoveError::new(1944                                place,1945                                location,1946                                InteriorOfTypeWithDestructor { container_ty: place_ty.ty },1947                            ));1948                            return;1949                        }1950                    }1951                    ty::Closure(..)1952                    | ty::CoroutineClosure(..)1953                    | ty::Coroutine(_, _)1954                    | ty::Tuple(_) => (),1955                    ty::Bool1956                    | ty::Char1957                    | ty::Int(_)1958                    | ty::Uint(_)1959                    | ty::Float(_)1960                    | ty::Foreign(_)1961                    | ty::Str1962                    | ty::Array(_, _)1963                    | ty::Pat(_, _)1964                    | ty::Slice(_)1965                    | ty::RawPtr(_, _)1966                    | ty::Ref(_, _, _)1967                    | ty::FnDef(_, _)1968                    | ty::FnPtr(..)1969                    | ty::Dynamic(_, _)1970                    | ty::CoroutineWitness(..)1971                    | ty::Never1972                    | ty::UnsafeBinder(_)1973                    | ty::Alias(_)1974                    | ty::Param(_)1975                    | ty::Bound(_, _)1976                    | ty::Infer(_)1977                    | ty::Error(_)1978                    | ty::Placeholder(_) => bug!(1979                        "When Place contains ProjectionElem::Field it's type shouldn't be {place_ty:#?}"1980                    ),1981                },1982                ProjectionElem::ConstantIndex { .. } | ProjectionElem::Subslice { .. } => {1983                    match place_ty.ty.kind() {1984                        ty::Slice(_) => {1985                            self.move_errors.push(MoveError::new(1986                                place,1987                                location,1988                                InteriorOfSliceOrArray { ty: place_ty.ty, is_index: false },1989                            ));1990                            return;1991                        }1992                        ty::Array(_, _) => (),1993                        _ => bug!("Unexpected type {:#?}", place_ty.ty),1994                    }1995                }1996                ProjectionElem::Index(_) => match place_ty.ty.kind() {1997                    ty::Array(..) | ty::Slice(..) => {1998                        self.move_errors.push(MoveError::new(1999                            place,2000                            location,