compiler/rustc_mir_build/src/build/expr/as_place.rs

   1 //! See docs in build/expr/mod.rs
   2
   3 use crate::build::expr::category::Category;
   4 use crate::build::ForGuard::{OutsideGuard, RefWithinGuard};
   5 use crate::build::{BlockAnd, BlockAndExtension, Builder};
   6 use rustc_hir::def_id::LocalDefId;
   7 use rustc_middle::hir::place::Projection as HirProjection;
   8 use rustc_middle::hir::place::ProjectionKind as HirProjectionKind;
   9 use rustc_middle::middle::region;
  10 use rustc_middle::mir::AssertKind::BoundsCheck;
  11 use rustc_middle::mir::*;
  12 use rustc_middle::thir::*;
  13 use rustc_middle::ty::AdtDef;
  14 use rustc_middle::ty::{self, CanonicalUserTypeAnnotation, Ty, TyCtxt, Variance};
  15 use rustc_span::Span;
  16 use rustc_target::abi::VariantIdx;
  17
  18 use rustc_index::vec::Idx;
  19
  20 use std::iter;
  21
  22 /// The "outermost" place that holds this value.
  23 #[derive(Copy, Clone, Debug, PartialEq)]
  24 pub(crate) enum PlaceBase {
  25     /// Denotes the start of a `Place`.
  26     Local(Local),
  27
  28     /// When building place for an expression within a closure, the place might start off a
  29     /// captured path. When `capture_disjoint_fields` is enabled, we might not know the capture
  30     /// index (within the desugared closure) of the captured path until most of the projections
  31     /// are applied. We use `PlaceBase::Upvar` to keep track of the root variable off of which the
  32     /// captured path starts, the closure the capture belongs to and the trait the closure
  33     /// implements.
  34     ///
  35     /// Once we have figured out the capture index, we can convert the place builder to start from
  36     /// `PlaceBase::Local`.
  37     ///
  38     /// Consider the following example
  39     /// ```rust
  40     /// let t = (((10, 10), 10), 10);
  41     ///
  42     /// let c = || {
  43     ///     println!("{}", t.0.0.0);
  44     /// };
  45     /// ```
  46     /// Here the THIR expression for `t.0.0.0` will be something like
  47     ///
  48     /// ```ignore (illustrative)
  49     /// * Field(0)
  50     ///     * Field(0)
  51     ///         * Field(0)
  52     ///             * UpvarRef(t)
  53     /// ```
  54     ///
  55     /// When `capture_disjoint_fields` is enabled, `t.0.0.0` is captured and we won't be able to
  56     /// figure out that it is captured until all the `Field` projections are applied.
  57     Upvar {
  58         /// HirId of the upvar
  59         var_hir_id: LocalVarId,
  60         /// DefId of the closure
  61         closure_def_id: LocalDefId,
  62         /// The trait closure implements, `Fn`, `FnMut`, `FnOnce`
  63         closure_kind: ty::ClosureKind,
  64     },
  65 }
  66
  67 /// `PlaceBuilder` is used to create places during MIR construction. It allows you to "build up" a
  68 /// place by pushing more and more projections onto the end, and then convert the final set into a
  69 /// place using the `into_place` method.
  70 ///
  71 /// This is used internally when building a place for an expression like `a.b.c`. The fields `b`
  72 /// and `c` can be progressively pushed onto the place builder that is created when converting `a`.
  73 #[derive(Clone, Debug, PartialEq)]
  74 pub(crate) struct PlaceBuilder<'tcx> {
  75     base: PlaceBase,
  76     projection: Vec<PlaceElem<'tcx>>,
  77 }
  78
  79 /// Given a list of MIR projections, convert them to list of HIR ProjectionKind.
  80 /// The projections are truncated to represent a path that might be captured by a
  81 /// closure/generator. This implies the vector returned from this function doesn't contain
  82 /// ProjectionElems `Downcast`, `ConstantIndex`, `Index`, or `Subslice` because those will never be
  83 /// part of a path that is captured by a closure. We stop applying projections once we see the first
  84 /// projection that isn't captured by a closure.
  85 fn convert_to_hir_projections_and_truncate_for_capture<'tcx>(
  86     mir_projections: &[PlaceElem<'tcx>],
  87 ) -> Vec<HirProjectionKind> {
  88     let mut hir_projections = Vec::new();
  89     let mut variant = None;
  90
  91     for mir_projection in mir_projections {
  92         let hir_projection = match mir_projection {
  93             ProjectionElem::Deref => HirProjectionKind::Deref,
  94             ProjectionElem::Field(field, _) => {
  95                 let variant = variant.unwrap_or(VariantIdx::new(0));
  96                 HirProjectionKind::Field(field.index() as u32, variant)
  97             }
  98             ProjectionElem::Downcast(.., idx) => {
  99                 // We don't expect to see multi-variant enums here, as earlier
 100                 // phases will have truncated them already. However, there can
 101                 // still be downcasts, thanks to single-variant enums.
 102                 // We keep track of VariantIdx so we can use this information
 103                 // if the next ProjectionElem is a Field.
 104                 variant = Some(*idx);
 105                 continue;
 106             }
 107             ProjectionElem::Index(..)
 108             | ProjectionElem::ConstantIndex { .. }
 109             | ProjectionElem::Subslice { .. } => {
 110                 // We don't capture array-access projections.
 111                 // We can stop here as arrays are captured completely.
 112                 break;
 113             }
 114         };
 115         variant = None;
 116         hir_projections.push(hir_projection);
 117     }
 118
 119     hir_projections
 120 }
 121
 122 /// Return true if the `proj_possible_ancestor` represents an ancestor path
 123 /// to `proj_capture` or `proj_possible_ancestor` is same as `proj_capture`,
 124 /// assuming they both start off of the same root variable.
 125 ///
 126 /// **Note:** It's the caller's responsibility to ensure that both lists of projections
 127 ///           start off of the same root variable.
 128 ///
 129 /// Eg: 1. `foo.x` which is represented using `projections=[Field(x)]` is an ancestor of
 130 ///        `foo.x.y` which is represented using `projections=[Field(x), Field(y)]`.
 131 ///        Note both `foo.x` and `foo.x.y` start off of the same root variable `foo`.
 132 ///     2. Since we only look at the projections here function will return `bar.x` as an a valid
 133 ///        ancestor of `foo.x.y`. It's the caller's responsibility to ensure that both projections
 134 ///        list are being applied to the same root variable.
 135 fn is_ancestor_or_same_capture(
 136     proj_possible_ancestor: &[HirProjectionKind],
 137     proj_capture: &[HirProjectionKind],
 138 ) -> bool {
 139     // We want to make sure `is_ancestor_or_same_capture("x.0.0", "x.0")` to return false.
 140     // Therefore we can't just check if all projections are same in the zipped iterator below.
 141     if proj_possible_ancestor.len() > proj_capture.len() {
 142         return false;
 143     }
 144
 145     iter::zip(proj_possible_ancestor, proj_capture).all(|(a, b)| a == b)
 146 }
 147
 148 /// Computes the index of a capture within the desugared closure provided the closure's
 149 /// `closure_min_captures` and the capture's index of the capture in the
 150 /// `ty::MinCaptureList` of the root variable `var_hir_id`.
 151 fn compute_capture_idx<'tcx>(
 152     closure_min_captures: &ty::RootVariableMinCaptureList<'tcx>,
 153     var_hir_id: LocalVarId,
 154     root_var_idx: usize,
 155 ) -> usize {
 156     let mut res = 0;
 157     for (var_id, capture_list) in closure_min_captures {
 158         if *var_id == var_hir_id.0 {
 159             res += root_var_idx;
 160             break;
 161         } else {
 162             res += capture_list.len();
 163         }
 164     }
 165
 166     res
 167 }
 168
 169 /// Given a closure, returns the index of a capture within the desugared closure struct and the
 170 /// `ty::CapturedPlace` which is the ancestor of the Place represented using the `var_hir_id`
 171 /// and `projection`.
 172 ///
 173 /// Note there will be at most one ancestor for any given Place.
 174 ///
 175 /// Returns None, when the ancestor is not found.
 176 fn find_capture_matching_projections<'a, 'tcx>(
 177     typeck_results: &'a ty::TypeckResults<'tcx>,
 178     var_hir_id: LocalVarId,
 179     closure_def_id: LocalDefId,
 180     projections: &[PlaceElem<'tcx>],
 181 ) -> Option<(usize, &'a ty::CapturedPlace<'tcx>)> {
 182     let closure_min_captures = typeck_results.closure_min_captures.get(&closure_def_id)?;
 183     let root_variable_min_captures = closure_min_captures.get(&var_hir_id.0)?;
 184
 185     let hir_projections = convert_to_hir_projections_and_truncate_for_capture(projections);
 186
 187     // If an ancestor is found, `idx` is the index within the list of captured places
 188     // for root variable `var_hir_id` and `capture` is the `ty::CapturedPlace` itself.
 189     let (idx, capture) = root_variable_min_captures.iter().enumerate().find(|(_, capture)| {
 190         let possible_ancestor_proj_kinds: Vec<_> =
 191             capture.place.projections.iter().map(|proj| proj.kind).collect();
 192         is_ancestor_or_same_capture(&possible_ancestor_proj_kinds, &hir_projections)
 193     })?;
 194
 195     // Convert index to be from the perspective of the entire closure_min_captures map
 196     // instead of just the root variable capture list
 197     Some((compute_capture_idx(closure_min_captures, var_hir_id, idx), capture))
 198 }
 199
 200 /// Takes a PlaceBuilder and resolves the upvar (if any) within it, so that the
 201 /// `PlaceBuilder` now starts from `PlaceBase::Local`.
 202 ///
 203 /// Returns a Result with the error being the PlaceBuilder (`from_builder`) that was not found.
 204 fn to_upvars_resolved_place_builder<'a, 'tcx>(
 205     from_builder: PlaceBuilder<'tcx>,
 206     tcx: TyCtxt<'tcx>,
 207     typeck_results: &'a ty::TypeckResults<'tcx>,
 208 ) -> Result<PlaceBuilder<'tcx>, PlaceBuilder<'tcx>> {
 209     match from_builder.base {
 210         PlaceBase::Local(_) => Ok(from_builder),
 211         PlaceBase::Upvar { var_hir_id, closure_def_id, closure_kind } => {
 212             let mut upvar_resolved_place_builder = PlaceBuilder::from(ty::CAPTURE_STRUCT_LOCAL);
 213             match closure_kind {
 214                 ty::ClosureKind::Fn | ty::ClosureKind::FnMut => {
 215                     upvar_resolved_place_builder = upvar_resolved_place_builder.deref();
 216                 }
 217                 ty::ClosureKind::FnOnce => {}
 218             }
 219
 220             let Some((capture_index, capture)) =
 221                 find_capture_matching_projections(
 222                     typeck_results,
 223                     var_hir_id,
 224                     closure_def_id,
 225                     &from_builder.projection,
 226                 ) else {
 227                 let closure_span = tcx.def_span(closure_def_id);
 228                 if !enable_precise_capture(tcx, closure_span) {
 229                     bug!(
 230                         "No associated capture found for {:?}[{:#?}] even though \
 231                             capture_disjoint_fields isn't enabled",
 232                         var_hir_id,
 233                         from_builder.projection
 234                     )
 235                 } else {
 236                     debug!(
 237                         "No associated capture found for {:?}[{:#?}]",
 238                         var_hir_id, from_builder.projection,
 239                     );
 240                 }
 241                 return Err(from_builder);
 242             };
 243
 244             // We won't be building MIR if the closure wasn't local
 245             let closure_hir_id = tcx.hir().local_def_id_to_hir_id(closure_def_id);
 246             let closure_ty = typeck_results.node_type(closure_hir_id);
 247
 248             let substs = match closure_ty.kind() {
 249                 ty::Closure(_, substs) => ty::UpvarSubsts::Closure(substs),
 250                 ty::Generator(_, substs, _) => ty::UpvarSubsts::Generator(substs),
 251                 _ => bug!("Lowering capture for non-closure type {:?}", closure_ty),
 252             };
 253
 254             // Access the capture by accessing the field within the Closure struct.
 255             //
 256             // We must have inferred the capture types since we are building MIR, therefore
 257             // it's safe to call `tuple_element_ty` and we can unwrap here because
 258             // we know that the capture exists and is the `capture_index`-th capture.
 259             let var_ty = substs.tupled_upvars_ty().tuple_fields()[capture_index];
 260
 261             upvar_resolved_place_builder =
 262                 upvar_resolved_place_builder.field(Field::new(capture_index), var_ty);
 263
 264             // If the variable is captured via ByRef(Immutable/Mutable) Borrow,
 265             // we need to deref it
 266             upvar_resolved_place_builder = match capture.info.capture_kind {
 267                 ty::UpvarCapture::ByRef(_) => upvar_resolved_place_builder.deref(),
 268                 ty::UpvarCapture::ByValue => upvar_resolved_place_builder,
 269             };
 270
 271             // We used some of the projections to build the capture itself,
 272             // now we apply the remaining to the upvar resolved place.
 273             let remaining_projections = strip_prefix(
 274                 capture.place.base_ty,
 275                 from_builder.projection,
 276                 &capture.place.projections,
 277             );
 278             upvar_resolved_place_builder.projection.extend(remaining_projections);
 279
 280             Ok(upvar_resolved_place_builder)
 281         }
 282     }
 283 }
 284
 285 /// Returns projections remaining after stripping an initial prefix of HIR
 286 /// projections.
 287 ///
 288 /// Supports only HIR projection kinds that represent a path that might be
 289 /// captured by a closure or a generator, i.e., an `Index` or a `Subslice`
 290 /// projection kinds are unsupported.
 291 fn strip_prefix<'tcx>(
 292     mut base_ty: Ty<'tcx>,
 293     projections: Vec<PlaceElem<'tcx>>,
 294     prefix_projections: &[HirProjection<'tcx>],
 295 ) -> impl Iterator<Item = PlaceElem<'tcx>> {
 296     let mut iter = projections.into_iter();
 297     for projection in prefix_projections {
 298         match projection.kind {
 299             HirProjectionKind::Deref => {
 300                 assert!(matches!(iter.next(), Some(ProjectionElem::Deref)));
 301             }
 302             HirProjectionKind::Field(..) => {
 303                 if base_ty.is_enum() {
 304                     assert!(matches!(iter.next(), Some(ProjectionElem::Downcast(..))));
 305                 }
 306                 assert!(matches!(iter.next(), Some(ProjectionElem::Field(..))));
 307             }
 308             HirProjectionKind::Index | HirProjectionKind::Subslice => {
 309                 bug!("unexpected projection kind: {:?}", projection);
 310             }
 311         }
 312         base_ty = projection.ty;
 313     }
 314     iter
 315 }
 316
 317 impl<'tcx> PlaceBuilder<'tcx> {
 318     pub(crate) fn into_place<'a>(
 319         self,
 320         tcx: TyCtxt<'tcx>,
 321         typeck_results: &'a ty::TypeckResults<'tcx>,
 322     ) -> Place<'tcx> {
 323         if let PlaceBase::Local(local) = self.base {
 324             Place { local, projection: tcx.intern_place_elems(&self.projection) }
 325         } else {
 326             self.expect_upvars_resolved(tcx, typeck_results).into_place(tcx, typeck_results)
 327         }
 328     }
 329
 330     fn expect_upvars_resolved<'a>(
 331         self,
 332         tcx: TyCtxt<'tcx>,
 333         typeck_results: &'a ty::TypeckResults<'tcx>,
 334     ) -> PlaceBuilder<'tcx> {
 335         to_upvars_resolved_place_builder(self, tcx, typeck_results).unwrap()
 336     }
 337
 338     /// Attempts to resolve the `PlaceBuilder`.
 339     /// On success, it will return the resolved `PlaceBuilder`.
 340     /// On failure, it will return itself.
 341     ///
 342     /// Upvars resolve may fail for a `PlaceBuilder` when attempting to
 343     /// resolve a disjoint field whose root variable is not captured
 344     /// (destructured assignments) or when attempting to resolve a root
 345     /// variable (discriminant matching with only wildcard arm) that is
 346     /// not captured. This can happen because the final mir that will be
 347     /// generated doesn't require a read for this place. Failures will only
 348     /// happen inside closures.
 349     pub(crate) fn try_upvars_resolved<'a>(
 350         self,
 351         tcx: TyCtxt<'tcx>,
 352         typeck_results: &'a ty::TypeckResults<'tcx>,
 353     ) -> Result<PlaceBuilder<'tcx>, PlaceBuilder<'tcx>> {
 354         to_upvars_resolved_place_builder(self, tcx, typeck_results)
 355     }
 356
 357     pub(crate) fn base(&self) -> PlaceBase {
 358         self.base
 359     }
 360
 361     pub(crate) fn field(self, f: Field, ty: Ty<'tcx>) -> Self {
 362         self.project(PlaceElem::Field(f, ty))
 363     }
 364
 365     pub(crate) fn deref(self) -> Self {
 366         self.project(PlaceElem::Deref)
 367     }
 368
 369     pub(crate) fn downcast(self, adt_def: AdtDef<'tcx>, variant_index: VariantIdx) -> Self {
 370         self.project(PlaceElem::Downcast(Some(adt_def.variant(variant_index).name), variant_index))
 371     }
 372
 373     fn index(self, index: Local) -> Self {
 374         self.project(PlaceElem::Index(index))
 375     }
 376
 377     pub(crate) fn project(mut self, elem: PlaceElem<'tcx>) -> Self {
 378         self.projection.push(elem);
 379         self
 380     }
 381 }
 382
 383 impl<'tcx> From<Local> for PlaceBuilder<'tcx> {
 384     fn from(local: Local) -> Self {
 385         Self { base: PlaceBase::Local(local), projection: Vec::new() }
 386     }
 387 }
 388
 389 impl<'tcx> From<PlaceBase> for PlaceBuilder<'tcx> {
 390     fn from(base: PlaceBase) -> Self {
 391         Self { base, projection: Vec::new() }
 392     }
 393 }
 394
 395 impl<'a, 'tcx> Builder<'a, 'tcx> {
 396     /// Compile `expr`, yielding a place that we can move from etc.
 397     ///
 398     /// WARNING: Any user code might:
 399     /// * Invalidate any slice bounds checks performed.
 400     /// * Change the address that this `Place` refers to.
 401     /// * Modify the memory that this place refers to.
 402     /// * Invalidate the memory that this place refers to, this will be caught
 403     ///   by borrow checking.
 404     ///
 405     /// Extra care is needed if any user code is allowed to run between calling
 406     /// this method and using it, as is the case for `match` and index
 407     /// expressions.
 408     pub(crate) fn as_place(
 409         &mut self,
 410         mut block: BasicBlock,
 411         expr: &Expr<'tcx>,
 412     ) -> BlockAnd<Place<'tcx>> {
 413         let place_builder = unpack!(block = self.as_place_builder(block, expr));
 414         block.and(place_builder.into_place(self.tcx, self.typeck_results))
 415     }
 416
 417     /// This is used when constructing a compound `Place`, so that we can avoid creating
 418     /// intermediate `Place` values until we know the full set of projections.
 419     pub(crate) fn as_place_builder(
 420         &mut self,
 421         block: BasicBlock,
 422         expr: &Expr<'tcx>,
 423     ) -> BlockAnd<PlaceBuilder<'tcx>> {
 424         self.expr_as_place(block, expr, Mutability::Mut, None)
 425     }
 426
 427     /// Compile `expr`, yielding a place that we can move from etc.
 428     /// Mutability note: The caller of this method promises only to read from the resulting
 429     /// place. The place itself may or may not be mutable:
 430     /// * If this expr is a place expr like a.b, then we will return that place.
 431     /// * Otherwise, a temporary is created: in that event, it will be an immutable temporary.
 432     pub(crate) fn as_read_only_place(
 433         &mut self,
 434         mut block: BasicBlock,
 435         expr: &Expr<'tcx>,
 436     ) -> BlockAnd<Place<'tcx>> {
 437         let place_builder = unpack!(block = self.as_read_only_place_builder(block, expr));
 438         block.and(place_builder.into_place(self.tcx, self.typeck_results))
 439     }
 440
 441     /// This is used when constructing a compound `Place`, so that we can avoid creating
 442     /// intermediate `Place` values until we know the full set of projections.
 443     /// Mutability note: The caller of this method promises only to read from the resulting
 444     /// place. The place itself may or may not be mutable:
 445     /// * If this expr is a place expr like a.b, then we will return that place.
 446     /// * Otherwise, a temporary is created: in that event, it will be an immutable temporary.
 447     fn as_read_only_place_builder(
 448         &mut self,
 449         block: BasicBlock,
 450         expr: &Expr<'tcx>,
 451     ) -> BlockAnd<PlaceBuilder<'tcx>> {
 452         self.expr_as_place(block, expr, Mutability::Not, None)
 453     }
 454
 455     fn expr_as_place(
 456         &mut self,
 457         mut block: BasicBlock,
 458         expr: &Expr<'tcx>,
 459         mutability: Mutability,
 460         fake_borrow_temps: Option<&mut Vec<Local>>,
 461     ) -> BlockAnd<PlaceBuilder<'tcx>> {
 462         debug!("expr_as_place(block={:?}, expr={:?}, mutability={:?})", block, expr, mutability);
 463
 464         let this = self;
 465         let expr_span = expr.span;
 466         let source_info = this.source_info(expr_span);
 467         match expr.kind {
 468             ExprKind::Scope { region_scope, lint_level, value } => {
 469                 this.in_scope((region_scope, source_info), lint_level, |this| {
 470                     this.expr_as_place(block, &this.thir[value], mutability, fake_borrow_temps)
 471                 })
 472             }
 473             ExprKind::Field { lhs, variant_index, name } => {
 474                 let lhs = &this.thir[lhs];
 475                 let mut place_builder =
 476                     unpack!(block = this.expr_as_place(block, lhs, mutability, fake_borrow_temps,));
 477                 if let ty::Adt(adt_def, _) = lhs.ty.kind() {
 478                     if adt_def.is_enum() {
 479                         place_builder = place_builder.downcast(*adt_def, variant_index);
 480                     }
 481                 }
 482                 block.and(place_builder.field(name, expr.ty))
 483             }
 484             ExprKind::Deref { arg } => {
 485                 let place_builder = unpack!(
 486                     block =
 487                         this.expr_as_place(block, &this.thir[arg], mutability, fake_borrow_temps,)
 488                 );
 489                 block.and(place_builder.deref())
 490             }
 491             ExprKind::Index { lhs, index } => this.lower_index_expression(
 492                 block,
 493                 &this.thir[lhs],
 494                 &this.thir[index],
 495                 mutability,
 496                 fake_borrow_temps,
 497                 expr.temp_lifetime,
 498                 expr_span,
 499                 source_info,
 500             ),
 501             ExprKind::UpvarRef { closure_def_id, var_hir_id } => {
 502                 this.lower_captured_upvar(block, closure_def_id.expect_local(), var_hir_id)
 503             }
 504
 505             ExprKind::VarRef { id } => {
 506                 let place_builder = if this.is_bound_var_in_guard(id) {
 507                     let index = this.var_local_id(id, RefWithinGuard);
 508                     PlaceBuilder::from(index).deref()
 509                 } else {
 510                     let index = this.var_local_id(id, OutsideGuard);
 511                     PlaceBuilder::from(index)
 512                 };
 513                 block.and(place_builder)
 514             }
 515
 516             ExprKind::PlaceTypeAscription { source, ref user_ty } => {
 517                 let place_builder = unpack!(
 518                     block = this.expr_as_place(
 519                         block,
 520                         &this.thir[source],
 521                         mutability,
 522                         fake_borrow_temps,
 523                     )
 524                 );
 525                 if let Some(user_ty) = user_ty {
 526                     let annotation_index =
 527                         this.canonical_user_type_annotations.push(CanonicalUserTypeAnnotation {
 528                             span: source_info.span,
 529                             user_ty: user_ty.clone(),
 530                             inferred_ty: expr.ty,
 531                         });
 532
 533                     let place = place_builder.clone().into_place(this.tcx, this.typeck_results);
 534                     this.cfg.push(
 535                         block,
 536                         Statement {
 537                             source_info,
 538                             kind: StatementKind::AscribeUserType(
 539                                 Box::new((
 540                                     place,
 541                                     UserTypeProjection { base: annotation_index, projs: vec![] },
 542                                 )),
 543                                 Variance::Invariant,
 544                             ),
 545                         },
 546                     );
 547                 }
 548                 block.and(place_builder)
 549             }
 550             ExprKind::ValueTypeAscription { source, ref user_ty } => {
 551                 let source = &this.thir[source];
 552                 let temp =
 553                     unpack!(block = this.as_temp(block, source.temp_lifetime, source, mutability));
 554                 if let Some(user_ty) = user_ty {
 555                     let annotation_index =
 556                         this.canonical_user_type_annotations.push(CanonicalUserTypeAnnotation {
 557                             span: source_info.span,
 558                             user_ty: user_ty.clone(),
 559                             inferred_ty: expr.ty,
 560                         });
 561                     this.cfg.push(
 562                         block,
 563                         Statement {
 564                             source_info,
 565                             kind: StatementKind::AscribeUserType(
 566                                 Box::new((
 567                                     Place::from(temp),
 568                                     UserTypeProjection { base: annotation_index, projs: vec![] },
 569                                 )),
 570                                 Variance::Invariant,
 571                             ),
 572                         },
 573                     );
 574                 }
 575                 block.and(PlaceBuilder::from(temp))
 576             }
 577
 578             ExprKind::Array { .. }
 579             | ExprKind::Tuple { .. }
 580             | ExprKind::Adt { .. }
 581             | ExprKind::Closure { .. }
 582             | ExprKind::Unary { .. }
 583             | ExprKind::Binary { .. }
 584             | ExprKind::LogicalOp { .. }
 585             | ExprKind::Box { .. }
 586             | ExprKind::Cast { .. }
 587             | ExprKind::Use { .. }
 588             | ExprKind::NeverToAny { .. }
 589             | ExprKind::Pointer { .. }
 590             | ExprKind::Repeat { .. }
 591             | ExprKind::Borrow { .. }
 592             | ExprKind::AddressOf { .. }
 593             | ExprKind::Match { .. }
 594             | ExprKind::If { .. }
 595             | ExprKind::Loop { .. }
 596             | ExprKind::Block { .. }
 597             | ExprKind::Let { .. }
 598             | ExprKind::Assign { .. }
 599             | ExprKind::AssignOp { .. }
 600             | ExprKind::Break { .. }
 601             | ExprKind::Continue { .. }
 602             | ExprKind::Return { .. }
 603             | ExprKind::Literal { .. }
 604             | ExprKind::NamedConst { .. }
 605             | ExprKind::NonHirLiteral { .. }
 606             | ExprKind::ZstLiteral { .. }
 607             | ExprKind::ConstParam { .. }
 608             | ExprKind::ConstBlock { .. }
 609             | ExprKind::StaticRef { .. }
 610             | ExprKind::InlineAsm { .. }
 611             | ExprKind::Yield { .. }
 612             | ExprKind::ThreadLocalRef(_)
 613             | ExprKind::Call { .. } => {
 614                 // these are not places, so we need to make a temporary.
 615                 debug_assert!(!matches!(Category::of(&expr.kind), Some(Category::Place)));
 616                 let temp =
 617                     unpack!(block = this.as_temp(block, expr.temp_lifetime, expr, mutability));
 618                 block.and(PlaceBuilder::from(temp))
 619             }
 620         }
 621     }
 622
 623     /// Lower a captured upvar. Note we might not know the actual capture index,
 624     /// so we create a place starting from `PlaceBase::Upvar`, which will be resolved
 625     /// once all projections that allow us to identify a capture have been applied.
 626     fn lower_captured_upvar(
 627         &mut self,
 628         block: BasicBlock,
 629         closure_def_id: LocalDefId,
 630         var_hir_id: LocalVarId,
 631     ) -> BlockAnd<PlaceBuilder<'tcx>> {
 632         let closure_ty =
 633             self.typeck_results.node_type(self.tcx.hir().local_def_id_to_hir_id(closure_def_id));
 634
 635         let closure_kind = if let ty::Closure(_, closure_substs) = closure_ty.kind() {
 636             self.infcx.closure_kind(closure_substs).unwrap()
 637         } else {
 638             // Generators are considered FnOnce.
 639             ty::ClosureKind::FnOnce
 640         };
 641
 642         block.and(PlaceBuilder::from(PlaceBase::Upvar { var_hir_id, closure_def_id, closure_kind }))
 643     }
 644
 645     /// Lower an index expression
 646     ///
 647     /// This has two complications;
 648     ///
 649     /// * We need to do a bounds check.
 650     /// * We need to ensure that the bounds check can't be invalidated using an
 651     ///   expression like `x[1][{x = y; 2}]`. We use fake borrows here to ensure
 652     ///   that this is the case.
 653     fn lower_index_expression(
 654         &mut self,
 655         mut block: BasicBlock,
 656         base: &Expr<'tcx>,
 657         index: &Expr<'tcx>,
 658         mutability: Mutability,
 659         fake_borrow_temps: Option<&mut Vec<Local>>,
 660         temp_lifetime: Option<region::Scope>,
 661         expr_span: Span,
 662         source_info: SourceInfo,
 663     ) -> BlockAnd<PlaceBuilder<'tcx>> {
 664         let base_fake_borrow_temps = &mut Vec::new();
 665         let is_outermost_index = fake_borrow_temps.is_none();
 666         let fake_borrow_temps = fake_borrow_temps.unwrap_or(base_fake_borrow_temps);
 667
 668         let mut base_place =
 669             unpack!(block = self.expr_as_place(block, base, mutability, Some(fake_borrow_temps),));
 670
 671         // Making this a *fresh* temporary means we do not have to worry about
 672         // the index changing later: Nothing will ever change this temporary.
 673         // The "retagging" transformation (for Stacked Borrows) relies on this.
 674         let idx = unpack!(block = self.as_temp(block, temp_lifetime, index, Mutability::Not,));
 675
 676         block = self.bounds_check(block, base_place.clone(), idx, expr_span, source_info);
 677
 678         if is_outermost_index {
 679             self.read_fake_borrows(block, fake_borrow_temps, source_info)
 680         } else {
 681             base_place = base_place.expect_upvars_resolved(self.tcx, self.typeck_results);
 682             self.add_fake_borrows_of_base(
 683                 &base_place,
 684                 block,
 685                 fake_borrow_temps,
 686                 expr_span,
 687                 source_info,
 688             );
 689         }
 690
 691         block.and(base_place.index(idx))
 692     }
 693
 694     fn bounds_check(
 695         &mut self,
 696         block: BasicBlock,
 697         slice: PlaceBuilder<'tcx>,
 698         index: Local,
 699         expr_span: Span,
 700         source_info: SourceInfo,
 701     ) -> BasicBlock {
 702         let usize_ty = self.tcx.types.usize;
 703         let bool_ty = self.tcx.types.bool;
 704         // bounds check:
 705         let len = self.temp(usize_ty, expr_span);
 706         let lt = self.temp(bool_ty, expr_span);
 707
 708         // len = len(slice)
 709         self.cfg.push_assign(
 710             block,
 711             source_info,
 712             len,
 713             Rvalue::Len(slice.into_place(self.tcx, self.typeck_results)),
 714         );
 715         // lt = idx < len
 716         self.cfg.push_assign(
 717             block,
 718             source_info,
 719             lt,
 720             Rvalue::BinaryOp(
 721                 BinOp::Lt,
 722                 Box::new((Operand::Copy(Place::from(index)), Operand::Copy(len))),
 723             ),
 724         );
 725         let msg = BoundsCheck { len: Operand::Move(len), index: Operand::Copy(Place::from(index)) };
 726         // assert!(lt, "...")
 727         self.assert(block, Operand::Move(lt), true, msg, expr_span)
 728     }
 729
 730     fn add_fake_borrows_of_base(
 731         &mut self,
 732         base_place: &PlaceBuilder<'tcx>,
 733         block: BasicBlock,
 734         fake_borrow_temps: &mut Vec<Local>,
 735         expr_span: Span,
 736         source_info: SourceInfo,
 737     ) {
 738         let tcx = self.tcx;
 739         let local = match base_place.base {
 740             PlaceBase::Local(local) => local,
 741             PlaceBase::Upvar { .. } => bug!("Expected PlacseBase::Local found Upvar"),
 742         };
 743
 744         let place_ty = Place::ty_from(local, &base_place.projection, &self.local_decls, tcx);
 745         if let ty::Slice(_) = place_ty.ty.kind() {
 746             // We need to create fake borrows to ensure that the bounds
 747             // check that we just did stays valid. Since we can't assign to
 748             // unsized values, we only need to ensure that none of the
 749             // pointers in the base place are modified.
 750             for (idx, elem) in base_place.projection.iter().enumerate().rev() {
 751                 match elem {
 752                     ProjectionElem::Deref => {
 753                         let fake_borrow_deref_ty = Place::ty_from(
 754                             local,
 755                             &base_place.projection[..idx],
 756                             &self.local_decls,
 757                             tcx,
 758                         )
 759                         .ty;
 760                         let fake_borrow_ty =
 761                             tcx.mk_imm_ref(tcx.lifetimes.re_erased, fake_borrow_deref_ty);
 762                         let fake_borrow_temp =
 763                             self.local_decls.push(LocalDecl::new(fake_borrow_ty, expr_span));
 764                         let projection = tcx.intern_place_elems(&base_place.projection[..idx]);
 765                         self.cfg.push_assign(
 766                             block,
 767                             source_info,
 768                             fake_borrow_temp.into(),
 769                             Rvalue::Ref(
 770                                 tcx.lifetimes.re_erased,
 771                                 BorrowKind::Shallow,
 772                                 Place { local, projection },
 773                             ),
 774                         );
 775                         fake_borrow_temps.push(fake_borrow_temp);
 776                     }
 777                     ProjectionElem::Index(_) => {
 778                         let index_ty = Place::ty_from(
 779                             local,
 780                             &base_place.projection[..idx],
 781                             &self.local_decls,
 782                             tcx,
 783                         );
 784                         match index_ty.ty.kind() {
 785                             // The previous index expression has already
 786                             // done any index expressions needed here.
 787                             ty::Slice(_) => break,
 788                             ty::Array(..) => (),
 789                             _ => bug!("unexpected index base"),
 790                         }
 791                     }
 792                     ProjectionElem::Field(..)
 793                     | ProjectionElem::Downcast(..)
 794                     | ProjectionElem::ConstantIndex { .. }
 795                     | ProjectionElem::Subslice { .. } => (),
 796                 }
 797             }
 798         }
 799     }
 800
 801     fn read_fake_borrows(
 802         &mut self,
 803         bb: BasicBlock,
 804         fake_borrow_temps: &mut Vec<Local>,
 805         source_info: SourceInfo,
 806     ) {
 807         // All indexes have been evaluated now, read all of the
 808         // fake borrows so that they are live across those index
 809         // expressions.
 810         for temp in fake_borrow_temps {
 811             self.cfg.push_fake_read(bb, source_info, FakeReadCause::ForIndex, Place::from(*temp));
 812         }
 813     }
 814 }
 815
 816 /// Precise capture is enabled if the feature gate `capture_disjoint_fields` is enabled or if
 817 /// user is using Rust Edition 2021 or higher.
 818 fn enable_precise_capture(tcx: TyCtxt<'_>, closure_span: Span) -> bool {
 819     tcx.features().capture_disjoint_fields || closure_span.rust_2021()
 820 }