compiler/rustc_borrowck/src/type_check/mod.rs

   1 //! This pass type-checks the MIR to ensure it is not broken.
   2
   3 use std::rc::Rc;
   4 use std::{fmt, iter, mem};
   5
   6 use either::Either;
   7
   8 use hir::OpaqueTyOrigin;
   9 use rustc_data_structures::frozen::Frozen;
  10 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
  11 use rustc_data_structures::vec_map::VecMap;
  12 use rustc_errors::struct_span_err;
  13 use rustc_hir as hir;
  14 use rustc_hir::def::DefKind;
  15 use rustc_hir::def_id::LocalDefId;
  16 use rustc_hir::lang_items::LangItem;
  17 use rustc_index::vec::{Idx, IndexVec};
  18 use rustc_infer::infer::canonical::QueryRegionConstraints;
  19 use rustc_infer::infer::outlives::env::RegionBoundPairs;
  20 use rustc_infer::infer::region_constraints::RegionConstraintData;
  21 use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
  22 use rustc_infer::infer::{
  23     InferCtxt, InferOk, LateBoundRegionConversionTime, NllRegionVariableOrigin,
  24 };
  25 use rustc_middle::mir::tcx::PlaceTy;
  26 use rustc_middle::mir::visit::{NonMutatingUseContext, PlaceContext, Visitor};
  27 use rustc_middle::mir::AssertKind;
  28 use rustc_middle::mir::*;
  29 use rustc_middle::ty::adjustment::PointerCast;
  30 use rustc_middle::ty::cast::CastTy;
  31 use rustc_middle::ty::fold::TypeFoldable;
  32 use rustc_middle::ty::subst::{GenericArgKind, SubstsRef, UserSubsts};
  33 use rustc_middle::ty::{
  34     self, CanonicalUserTypeAnnotation, CanonicalUserTypeAnnotations, OpaqueHiddenType,
  35     OpaqueTypeKey, RegionVid, ToPredicate, Ty, TyCtxt, UserType, UserTypeAnnotationIndex,
  36 };
  37 use rustc_span::def_id::CRATE_DEF_ID;
  38 use rustc_span::{Span, DUMMY_SP};
  39 use rustc_target::abi::VariantIdx;
  40 use rustc_trait_selection::traits::query::type_op;
  41 use rustc_trait_selection::traits::query::type_op::custom::scrape_region_constraints;
  42 use rustc_trait_selection::traits::query::type_op::custom::CustomTypeOp;
  43 use rustc_trait_selection::traits::query::type_op::{TypeOp, TypeOpOutput};
  44 use rustc_trait_selection::traits::query::Fallible;
  45 use rustc_trait_selection::traits::PredicateObligation;
  46
  47 use rustc_mir_dataflow::impls::MaybeInitializedPlaces;
  48 use rustc_mir_dataflow::move_paths::MoveData;
  49 use rustc_mir_dataflow::ResultsCursor;
  50
  51 use crate::{
  52     borrow_set::BorrowSet,
  53     constraints::{OutlivesConstraint, OutlivesConstraintSet},
  54     diagnostics::UniverseInfo,
  55     facts::AllFacts,
  56     location::LocationTable,
  57     member_constraints::MemberConstraintSet,
  58     nll::ToRegionVid,
  59     path_utils,
  60     region_infer::values::{
  61         LivenessValues, PlaceholderIndex, PlaceholderIndices, RegionValueElements,
  62     },
  63     region_infer::{ClosureRegionRequirementsExt, TypeTest},
  64     type_check::free_region_relations::{CreateResult, UniversalRegionRelations},
  65     universal_regions::{DefiningTy, UniversalRegions},
  66     Upvar,
  67 };
  68
  69 macro_rules! span_mirbug {
  70     ($context:expr, $elem:expr, $($message:tt)*) => ({
  71         $crate::type_check::mirbug(
  72             $context.tcx(),
  73             $context.last_span,
  74             &format!(
  75                 "broken MIR in {:?} ({:?}): {}",
  76                 $context.body().source.def_id(),
  77                 $elem,
  78                 format_args!($($message)*),
  79             ),
  80         )
  81     })
  82 }
  83
  84 macro_rules! span_mirbug_and_err {
  85     ($context:expr, $elem:expr, $($message:tt)*) => ({
  86         {
  87             span_mirbug!($context, $elem, $($message)*);
  88             $context.error()
  89         }
  90     })
  91 }
  92
  93 mod canonical;
  94 mod constraint_conversion;
  95 pub mod free_region_relations;
  96 mod input_output;
  97 pub(crate) mod liveness;
  98 mod relate_tys;
  99
 100 /// Type checks the given `mir` in the context of the inference
 101 /// context `infcx`. Returns any region constraints that have yet to
 102 /// be proven. This result includes liveness constraints that
 103 /// ensure that regions appearing in the types of all local variables
 104 /// are live at all points where that local variable may later be
 105 /// used.
 106 ///
 107 /// This phase of type-check ought to be infallible -- this is because
 108 /// the original, HIR-based type-check succeeded. So if any errors
 109 /// occur here, we will get a `bug!` reported.
 110 ///
 111 /// # Parameters
 112 ///
 113 /// - `infcx` -- inference context to use
 114 /// - `param_env` -- parameter environment to use for trait solving
 115 /// - `body` -- MIR body to type-check
 116 /// - `promoted` -- map of promoted constants within `body`
 117 /// - `universal_regions` -- the universal regions from `body`s function signature
 118 /// - `location_table` -- MIR location map of `body`
 119 /// - `borrow_set` -- information about borrows occurring in `body`
 120 /// - `all_facts` -- when using Polonius, this is the generated set of Polonius facts
 121 /// - `flow_inits` -- results of a maybe-init dataflow analysis
 122 /// - `move_data` -- move-data constructed when performing the maybe-init dataflow analysis
 123 /// - `elements` -- MIR region map
 124 pub(crate) fn type_check<'mir, 'tcx>(
 125     infcx: &InferCtxt<'_, 'tcx>,
 126     param_env: ty::ParamEnv<'tcx>,
 127     body: &Body<'tcx>,
 128     promoted: &IndexVec<Promoted, Body<'tcx>>,
 129     universal_regions: &Rc<UniversalRegions<'tcx>>,
 130     location_table: &LocationTable,
 131     borrow_set: &BorrowSet<'tcx>,
 132     all_facts: &mut Option<AllFacts>,
 133     flow_inits: &mut ResultsCursor<'mir, 'tcx, MaybeInitializedPlaces<'mir, 'tcx>>,
 134     move_data: &MoveData<'tcx>,
 135     elements: &Rc<RegionValueElements>,
 136     upvars: &[Upvar<'tcx>],
 137     use_polonius: bool,
 138 ) -> MirTypeckResults<'tcx> {
 139     let implicit_region_bound = infcx.tcx.mk_region(ty::ReVar(universal_regions.fr_fn_body));
 140     let mut universe_causes = FxHashMap::default();
 141     universe_causes.insert(ty::UniverseIndex::from_u32(0), UniverseInfo::other());
 142     let mut constraints = MirTypeckRegionConstraints {
 143         placeholder_indices: PlaceholderIndices::default(),
 144         placeholder_index_to_region: IndexVec::default(),
 145         liveness_constraints: LivenessValues::new(elements.clone()),
 146         outlives_constraints: OutlivesConstraintSet::default(),
 147         member_constraints: MemberConstraintSet::default(),
 148         closure_bounds_mapping: Default::default(),
 149         type_tests: Vec::default(),
 150         universe_causes,
 151     };
 152
 153     let CreateResult {
 154         universal_region_relations,
 155         region_bound_pairs,
 156         normalized_inputs_and_output,
 157     } = free_region_relations::create(
 158         infcx,
 159         param_env,
 160         Some(implicit_region_bound),
 161         universal_regions,
 162         &mut constraints,
 163     );
 164
 165     for u in ty::UniverseIndex::ROOT..infcx.universe() {
 166         let info = UniverseInfo::other();
 167         constraints.universe_causes.insert(u, info);
 168     }
 169
 170     let mut borrowck_context = BorrowCheckContext {
 171         universal_regions,
 172         location_table,
 173         borrow_set,
 174         all_facts,
 175         constraints: &mut constraints,
 176         upvars,
 177     };
 178
 179     let opaque_type_values = type_check_internal(
 180         infcx,
 181         param_env,
 182         body,
 183         promoted,
 184         &region_bound_pairs,
 185         implicit_region_bound,
 186         &mut borrowck_context,
 187         |mut cx| {
 188             cx.equate_inputs_and_outputs(&body, universal_regions, &normalized_inputs_and_output);
 189             liveness::generate(
 190                 &mut cx,
 191                 body,
 192                 elements,
 193                 flow_inits,
 194                 move_data,
 195                 location_table,
 196                 use_polonius,
 197             );
 198
 199             translate_outlives_facts(&mut cx);
 200             let opaque_type_values =
 201                 infcx.inner.borrow_mut().opaque_type_storage.take_opaque_types();
 202
 203             opaque_type_values
 204                 .into_iter()
 205                 .map(|(opaque_type_key, decl)| {
 206                     cx.fully_perform_op(
 207                         Locations::All(body.span),
 208                         ConstraintCategory::OpaqueType,
 209                         CustomTypeOp::new(
 210                             |infcx| {
 211                                 infcx.register_member_constraints(
 212                                     param_env,
 213                                     opaque_type_key,
 214                                     decl.hidden_type.ty,
 215                                     decl.hidden_type.span,
 216                                 );
 217                                 Ok(InferOk { value: (), obligations: vec![] })
 218                             },
 219                             || "opaque_type_map".to_string(),
 220                         ),
 221                     )
 222                     .unwrap();
 223                     let mut hidden_type = infcx.resolve_vars_if_possible(decl.hidden_type);
 224                     trace!(
 225                         "finalized opaque type {:?} to {:#?}",
 226                         opaque_type_key,
 227                         hidden_type.ty.kind()
 228                     );
 229                     if hidden_type.has_infer_types_or_consts() {
 230                         infcx.tcx.sess.delay_span_bug(
 231                             decl.hidden_type.span,
 232                             &format!("could not resolve {:#?}", hidden_type.ty.kind()),
 233                         );
 234                         hidden_type.ty = infcx.tcx.ty_error();
 235                     }
 236
 237                     (opaque_type_key, (hidden_type, decl.origin))
 238                 })
 239                 .collect()
 240         },
 241     );
 242
 243     MirTypeckResults { constraints, universal_region_relations, opaque_type_values }
 244 }
 245
 246 #[instrument(
 247     skip(infcx, body, promoted, region_bound_pairs, borrowck_context, extra),
 248     level = "debug"
 249 )]
 250 fn type_check_internal<'a, 'tcx, R>(
 251     infcx: &'a InferCtxt<'a, 'tcx>,
 252     param_env: ty::ParamEnv<'tcx>,
 253     body: &'a Body<'tcx>,
 254     promoted: &'a IndexVec<Promoted, Body<'tcx>>,
 255     region_bound_pairs: &'a RegionBoundPairs<'tcx>,
 256     implicit_region_bound: ty::Region<'tcx>,
 257     borrowck_context: &'a mut BorrowCheckContext<'a, 'tcx>,
 258     extra: impl FnOnce(TypeChecker<'a, 'tcx>) -> R,
 259 ) -> R {
 260     let mut checker = TypeChecker::new(
 261         infcx,
 262         body,
 263         param_env,
 264         region_bound_pairs,
 265         implicit_region_bound,
 266         borrowck_context,
 267     );
 268     let errors_reported = {
 269         let mut verifier = TypeVerifier::new(&mut checker, promoted);
 270         verifier.visit_body(&body);
 271         verifier.errors_reported
 272     };
 273
 274     if !errors_reported {
 275         // if verifier failed, don't do further checks to avoid ICEs
 276         checker.typeck_mir(body);
 277     }
 278
 279     extra(checker)
 280 }
 281
 282 fn translate_outlives_facts(typeck: &mut TypeChecker<'_, '_>) {
 283     let cx = &mut typeck.borrowck_context;
 284     if let Some(facts) = cx.all_facts {
 285         let _prof_timer = typeck.infcx.tcx.prof.generic_activity("polonius_fact_generation");
 286         let location_table = cx.location_table;
 287         facts.subset_base.extend(cx.constraints.outlives_constraints.outlives().iter().flat_map(
 288             |constraint: &OutlivesConstraint<'_>| {
 289                 if let Some(from_location) = constraint.locations.from_location() {
 290                     Either::Left(iter::once((
 291                         constraint.sup,
 292                         constraint.sub,
 293                         location_table.mid_index(from_location),
 294                     )))
 295                 } else {
 296                     Either::Right(
 297                         location_table
 298                             .all_points()
 299                             .map(move |location| (constraint.sup, constraint.sub, location)),
 300                     )
 301                 }
 302             },
 303         ));
 304     }
 305 }
 306
 307 #[track_caller]
 308 fn mirbug(tcx: TyCtxt<'_>, span: Span, msg: &str) {
 309     // We sometimes see MIR failures (notably predicate failures) due to
 310     // the fact that we check rvalue sized predicates here. So use `delay_span_bug`
 311     // to avoid reporting bugs in those cases.
 312     tcx.sess.diagnostic().delay_span_bug(span, msg);
 313 }
 314
 315 enum FieldAccessError {
 316     OutOfRange { field_count: usize },
 317 }
 318
 319 /// Verifies that MIR types are sane to not crash further checks.
 320 ///
 321 /// The sanitize_XYZ methods here take an MIR object and compute its
 322 /// type, calling `span_mirbug` and returning an error type if there
 323 /// is a problem.
 324 struct TypeVerifier<'a, 'b, 'tcx> {
 325     cx: &'a mut TypeChecker<'b, 'tcx>,
 326     promoted: &'b IndexVec<Promoted, Body<'tcx>>,
 327     last_span: Span,
 328     errors_reported: bool,
 329 }
 330
 331 impl<'a, 'b, 'tcx> Visitor<'tcx> for TypeVerifier<'a, 'b, 'tcx> {
 332     fn visit_span(&mut self, span: &Span) {
 333         if !span.is_dummy() {
 334             self.last_span = *span;
 335         }
 336     }
 337
 338     fn visit_place(&mut self, place: &Place<'tcx>, context: PlaceContext, location: Location) {
 339         self.sanitize_place(place, location, context);
 340     }
 341
 342     fn visit_constant(&mut self, constant: &Constant<'tcx>, location: Location) {
 343         self.super_constant(constant, location);
 344         let ty = self.sanitize_type(constant, constant.literal.ty());
 345
 346         self.cx.infcx.tcx.for_each_free_region(&ty, |live_region| {
 347             let live_region_vid =
 348                 self.cx.borrowck_context.universal_regions.to_region_vid(live_region);
 349             self.cx
 350                 .borrowck_context
 351                 .constraints
 352                 .liveness_constraints
 353                 .add_element(live_region_vid, location);
 354         });
 355
 356         if let Some(annotation_index) = constant.user_ty {
 357             if let Err(terr) = self.cx.relate_type_and_user_type(
 358                 constant.literal.ty(),
 359                 ty::Variance::Invariant,
 360                 &UserTypeProjection { base: annotation_index, projs: vec![] },
 361                 location.to_locations(),
 362                 ConstraintCategory::Boring,
 363             ) {
 364                 let annotation = &self.cx.user_type_annotations[annotation_index];
 365                 span_mirbug!(
 366                     self,
 367                     constant,
 368                     "bad constant user type {:?} vs {:?}: {:?}",
 369                     annotation,
 370                     constant.literal.ty(),
 371                     terr,
 372                 );
 373             }
 374         } else {
 375             let tcx = self.tcx();
 376             let maybe_uneval = match constant.literal {
 377                 ConstantKind::Ty(ct) => match ct.val() {
 378                     ty::ConstKind::Unevaluated(uv) => Some(uv),
 379                     _ => None,
 380                 },
 381                 _ => None,
 382             };
 383             if let Some(uv) = maybe_uneval {
 384                 if let Some(promoted) = uv.promoted {
 385                     let check_err = |verifier: &mut TypeVerifier<'a, 'b, 'tcx>,
 386                                      promoted: &Body<'tcx>,
 387                                      ty,
 388                                      san_ty| {
 389                         if let Err(terr) = verifier.cx.eq_types(
 390                             ty,
 391                             san_ty,
 392                             location.to_locations(),
 393                             ConstraintCategory::Boring,
 394                         ) {
 395                             span_mirbug!(
 396                                 verifier,
 397                                 promoted,
 398                                 "bad promoted type ({:?}: {:?}): {:?}",
 399                                 ty,
 400                                 san_ty,
 401                                 terr
 402                             );
 403                         };
 404                     };
 405
 406                     if !self.errors_reported {
 407                         let promoted_body = &self.promoted[promoted];
 408                         self.sanitize_promoted(promoted_body, location);
 409
 410                         let promoted_ty = promoted_body.return_ty();
 411                         check_err(self, promoted_body, ty, promoted_ty);
 412                     }
 413                 } else {
 414                     if let Err(terr) = self.cx.fully_perform_op(
 415                         location.to_locations(),
 416                         ConstraintCategory::Boring,
 417                         self.cx.param_env.and(type_op::ascribe_user_type::AscribeUserType::new(
 418                             constant.literal.ty(),
 419                             uv.def.did,
 420                             UserSubsts { substs: uv.substs, user_self_ty: None },
 421                         )),
 422                     ) {
 423                         span_mirbug!(
 424                             self,
 425                             constant,
 426                             "bad constant type {:?} ({:?})",
 427                             constant,
 428                             terr
 429                         );
 430                     }
 431                 }
 432             } else if let Some(static_def_id) = constant.check_static_ptr(tcx) {
 433                 let unnormalized_ty = tcx.type_of(static_def_id);
 434                 let locations = location.to_locations();
 435                 let normalized_ty = self.cx.normalize(unnormalized_ty, locations);
 436                 let literal_ty = constant.literal.ty().builtin_deref(true).unwrap().ty;
 437
 438                 if let Err(terr) = self.cx.eq_types(
 439                     literal_ty,
 440                     normalized_ty,
 441                     locations,
 442                     ConstraintCategory::Boring,
 443                 ) {
 444                     span_mirbug!(self, constant, "bad static type {:?} ({:?})", constant, terr);
 445                 }
 446             }
 447
 448             if let ty::FnDef(def_id, substs) = *constant.literal.ty().kind() {
 449                 let instantiated_predicates = tcx.predicates_of(def_id).instantiate(tcx, substs);
 450                 self.cx.normalize_and_prove_instantiated_predicates(
 451                     def_id,
 452                     instantiated_predicates,
 453                     location.to_locations(),
 454                 );
 455             }
 456         }
 457     }
 458
 459     fn visit_rvalue(&mut self, rvalue: &Rvalue<'tcx>, location: Location) {
 460         self.super_rvalue(rvalue, location);
 461         let rval_ty = rvalue.ty(self.body(), self.tcx());
 462         self.sanitize_type(rvalue, rval_ty);
 463     }
 464
 465     fn visit_local_decl(&mut self, local: Local, local_decl: &LocalDecl<'tcx>) {
 466         self.super_local_decl(local, local_decl);
 467         self.sanitize_type(local_decl, local_decl.ty);
 468
 469         if let Some(user_ty) = &local_decl.user_ty {
 470             for (user_ty, span) in user_ty.projections_and_spans() {
 471                 let ty = if !local_decl.is_nonref_binding() {
 472                     // If we have a binding of the form `let ref x: T = ..`
 473                     // then remove the outermost reference so we can check the
 474                     // type annotation for the remaining type.
 475                     if let ty::Ref(_, rty, _) = local_decl.ty.kind() {
 476                         *rty
 477                     } else {
 478                         bug!("{:?} with ref binding has wrong type {}", local, local_decl.ty);
 479                     }
 480                 } else {
 481                     local_decl.ty
 482                 };
 483
 484                 if let Err(terr) = self.cx.relate_type_and_user_type(
 485                     ty,
 486                     ty::Variance::Invariant,
 487                     user_ty,
 488                     Locations::All(*span),
 489                     ConstraintCategory::TypeAnnotation,
 490                 ) {
 491                     span_mirbug!(
 492                         self,
 493                         local,
 494                         "bad user type on variable {:?}: {:?} != {:?} ({:?})",
 495                         local,
 496                         local_decl.ty,
 497                         local_decl.user_ty,
 498                         terr,
 499                     );
 500                 }
 501             }
 502         }
 503     }
 504
 505     fn visit_body(&mut self, body: &Body<'tcx>) {
 506         self.sanitize_type(&"return type", body.return_ty());
 507         for local_decl in &body.local_decls {
 508             self.sanitize_type(local_decl, local_decl.ty);
 509         }
 510         if self.errors_reported {
 511             return;
 512         }
 513         self.super_body(body);
 514     }
 515 }
 516
 517 impl<'a, 'b, 'tcx> TypeVerifier<'a, 'b, 'tcx> {
 518     fn new(
 519         cx: &'a mut TypeChecker<'b, 'tcx>,
 520         promoted: &'b IndexVec<Promoted, Body<'tcx>>,
 521     ) -> Self {
 522         TypeVerifier { promoted, last_span: cx.body.span, cx, errors_reported: false }
 523     }
 524
 525     fn body(&self) -> &Body<'tcx> {
 526         self.cx.body
 527     }
 528
 529     fn tcx(&self) -> TyCtxt<'tcx> {
 530         self.cx.infcx.tcx
 531     }
 532
 533     fn sanitize_type(&mut self, parent: &dyn fmt::Debug, ty: Ty<'tcx>) -> Ty<'tcx> {
 534         if ty.has_escaping_bound_vars() || ty.references_error() {
 535             span_mirbug_and_err!(self, parent, "bad type {:?}", ty)
 536         } else {
 537             ty
 538         }
 539     }
 540
 541     /// Checks that the types internal to the `place` match up with
 542     /// what would be expected.
 543     fn sanitize_place(
 544         &mut self,
 545         place: &Place<'tcx>,
 546         location: Location,
 547         context: PlaceContext,
 548     ) -> PlaceTy<'tcx> {
 549         debug!("sanitize_place: {:?}", place);
 550
 551         let mut place_ty = PlaceTy::from_ty(self.body().local_decls[place.local].ty);
 552
 553         for elem in place.projection.iter() {
 554             if place_ty.variant_index.is_none() {
 555                 if place_ty.ty.references_error() {
 556                     assert!(self.errors_reported);
 557                     return PlaceTy::from_ty(self.tcx().ty_error());
 558                 }
 559             }
 560             place_ty = self.sanitize_projection(place_ty, elem, place, location);
 561         }
 562
 563         if let PlaceContext::NonMutatingUse(NonMutatingUseContext::Copy) = context {
 564             let tcx = self.tcx();
 565             let trait_ref = ty::TraitRef {
 566                 def_id: tcx.require_lang_item(LangItem::Copy, Some(self.last_span)),
 567                 substs: tcx.mk_substs_trait(place_ty.ty, &[]),
 568             };
 569
 570             // To have a `Copy` operand, the type `T` of the
 571             // value must be `Copy`. Note that we prove that `T: Copy`,
 572             // rather than using the `is_copy_modulo_regions`
 573             // test. This is important because
 574             // `is_copy_modulo_regions` ignores the resulting region
 575             // obligations and assumes they pass. This can result in
 576             // bounds from `Copy` impls being unsoundly ignored (e.g.,
 577             // #29149). Note that we decide to use `Copy` before knowing
 578             // whether the bounds fully apply: in effect, the rule is
 579             // that if a value of some type could implement `Copy`, then
 580             // it must.
 581             self.cx.prove_trait_ref(
 582                 trait_ref,
 583                 location.to_locations(),
 584                 ConstraintCategory::CopyBound,
 585             );
 586         }
 587
 588         place_ty
 589     }
 590
 591     fn sanitize_promoted(&mut self, promoted_body: &'b Body<'tcx>, location: Location) {
 592         // Determine the constraints from the promoted MIR by running the type
 593         // checker on the promoted MIR, then transfer the constraints back to
 594         // the main MIR, changing the locations to the provided location.
 595
 596         let parent_body = mem::replace(&mut self.cx.body, promoted_body);
 597
 598         // Use new sets of constraints and closure bounds so that we can
 599         // modify their locations.
 600         let all_facts = &mut None;
 601         let mut constraints = Default::default();
 602         let mut closure_bounds = Default::default();
 603         let mut liveness_constraints =
 604             LivenessValues::new(Rc::new(RegionValueElements::new(&promoted_body)));
 605         // Don't try to add borrow_region facts for the promoted MIR
 606
 607         let mut swap_constraints = |this: &mut Self| {
 608             mem::swap(this.cx.borrowck_context.all_facts, all_facts);
 609             mem::swap(
 610                 &mut this.cx.borrowck_context.constraints.outlives_constraints,
 611                 &mut constraints,
 612             );
 613             mem::swap(
 614                 &mut this.cx.borrowck_context.constraints.closure_bounds_mapping,
 615                 &mut closure_bounds,
 616             );
 617             mem::swap(
 618                 &mut this.cx.borrowck_context.constraints.liveness_constraints,
 619                 &mut liveness_constraints,
 620             );
 621         };
 622
 623         swap_constraints(self);
 624
 625         self.visit_body(&promoted_body);
 626
 627         if !self.errors_reported {
 628             // if verifier failed, don't do further checks to avoid ICEs
 629             self.cx.typeck_mir(promoted_body);
 630         }
 631
 632         self.cx.body = parent_body;
 633         // Merge the outlives constraints back in, at the given location.
 634         swap_constraints(self);
 635
 636         let locations = location.to_locations();
 637         for constraint in constraints.outlives().iter() {
 638             let mut constraint = constraint.clone();
 639             constraint.locations = locations;
 640             if let ConstraintCategory::Return(_)
 641             | ConstraintCategory::UseAsConst
 642             | ConstraintCategory::UseAsStatic = constraint.category
 643             {
 644                 // "Returning" from a promoted is an assignment to a
 645                 // temporary from the user's point of view.
 646                 constraint.category = ConstraintCategory::Boring;
 647             }
 648             self.cx.borrowck_context.constraints.outlives_constraints.push(constraint)
 649         }
 650         for region in liveness_constraints.rows() {
 651             // If the region is live at at least one location in the promoted MIR,
 652             // then add a liveness constraint to the main MIR for this region
 653             // at the location provided as an argument to this method
 654             if liveness_constraints.get_elements(region).next().is_some() {
 655                 self.cx
 656                     .borrowck_context
 657                     .constraints
 658                     .liveness_constraints
 659                     .add_element(region, location);
 660             }
 661         }
 662
 663         if !closure_bounds.is_empty() {
 664             let combined_bounds_mapping =
 665                 closure_bounds.into_iter().flat_map(|(_, value)| value).collect();
 666             let existing = self
 667                 .cx
 668                 .borrowck_context
 669                 .constraints
 670                 .closure_bounds_mapping
 671                 .insert(location, combined_bounds_mapping);
 672             assert!(existing.is_none(), "Multiple promoteds/closures at the same location.");
 673         }
 674     }
 675
 676     fn sanitize_projection(
 677         &mut self,
 678         base: PlaceTy<'tcx>,
 679         pi: PlaceElem<'tcx>,
 680         place: &Place<'tcx>,
 681         location: Location,
 682     ) -> PlaceTy<'tcx> {
 683         debug!("sanitize_projection: {:?} {:?} {:?}", base, pi, place);
 684         let tcx = self.tcx();
 685         let base_ty = base.ty;
 686         match pi {
 687             ProjectionElem::Deref => {
 688                 let deref_ty = base_ty.builtin_deref(true);
 689                 PlaceTy::from_ty(deref_ty.map(|t| t.ty).unwrap_or_else(|| {
 690                     span_mirbug_and_err!(self, place, "deref of non-pointer {:?}", base_ty)
 691                 }))
 692             }
 693             ProjectionElem::Index(i) => {
 694                 let index_ty = Place::from(i).ty(self.body(), tcx).ty;
 695                 if index_ty != tcx.types.usize {
 696                     PlaceTy::from_ty(span_mirbug_and_err!(self, i, "index by non-usize {:?}", i))
 697                 } else {
 698                     PlaceTy::from_ty(base_ty.builtin_index().unwrap_or_else(|| {
 699                         span_mirbug_and_err!(self, place, "index of non-array {:?}", base_ty)
 700                     }))
 701                 }
 702             }
 703             ProjectionElem::ConstantIndex { .. } => {
 704                 // consider verifying in-bounds
 705                 PlaceTy::from_ty(base_ty.builtin_index().unwrap_or_else(|| {
 706                     span_mirbug_and_err!(self, place, "index of non-array {:?}", base_ty)
 707                 }))
 708             }
 709             ProjectionElem::Subslice { from, to, from_end } => {
 710                 PlaceTy::from_ty(match base_ty.kind() {
 711                     ty::Array(inner, _) => {
 712                         assert!(!from_end, "array subslices should not use from_end");
 713                         tcx.mk_array(*inner, to - from)
 714                     }
 715                     ty::Slice(..) => {
 716                         assert!(from_end, "slice subslices should use from_end");
 717                         base_ty
 718                     }
 719                     _ => span_mirbug_and_err!(self, place, "slice of non-array {:?}", base_ty),
 720                 })
 721             }
 722             ProjectionElem::Downcast(maybe_name, index) => match base_ty.kind() {
 723                 ty::Adt(adt_def, _substs) if adt_def.is_enum() => {
 724                     if index.as_usize() >= adt_def.variants().len() {
 725                         PlaceTy::from_ty(span_mirbug_and_err!(
 726                             self,
 727                             place,
 728                             "cast to variant #{:?} but enum only has {:?}",
 729                             index,
 730                             adt_def.variants().len()
 731                         ))
 732                     } else {
 733                         PlaceTy { ty: base_ty, variant_index: Some(index) }
 734                     }
 735                 }
 736                 // We do not need to handle generators here, because this runs
 737                 // before the generator transform stage.
 738                 _ => {
 739                     let ty = if let Some(name) = maybe_name {
 740                         span_mirbug_and_err!(
 741                             self,
 742                             place,
 743                             "can't downcast {:?} as {:?}",
 744                             base_ty,
 745                             name
 746                         )
 747                     } else {
 748                         span_mirbug_and_err!(self, place, "can't downcast {:?}", base_ty)
 749                     };
 750                     PlaceTy::from_ty(ty)
 751                 }
 752             },
 753             ProjectionElem::Field(field, fty) => {
 754                 let fty = self.sanitize_type(place, fty);
 755                 let fty = self.cx.normalize(fty, location);
 756                 match self.field_ty(place, base, field, location) {
 757                     Ok(ty) => {
 758                         let ty = self.cx.normalize(ty, location);
 759                         if let Err(terr) = self.cx.eq_types(
 760                             ty,
 761                             fty,
 762                             location.to_locations(),
 763                             ConstraintCategory::Boring,
 764                         ) {
 765                             span_mirbug!(
 766                                 self,
 767                                 place,
 768                                 "bad field access ({:?}: {:?}): {:?}",
 769                                 ty,
 770                                 fty,
 771                                 terr
 772                             );
 773                         }
 774                     }
 775                     Err(FieldAccessError::OutOfRange { field_count }) => span_mirbug!(
 776                         self,
 777                         place,
 778                         "accessed field #{} but variant only has {}",
 779                         field.index(),
 780                         field_count
 781                     ),
 782                 }
 783                 PlaceTy::from_ty(fty)
 784             }
 785         }
 786     }
 787
 788     fn error(&mut self) -> Ty<'tcx> {
 789         self.errors_reported = true;
 790         self.tcx().ty_error()
 791     }
 792
 793     fn field_ty(
 794         &mut self,
 795         parent: &dyn fmt::Debug,
 796         base_ty: PlaceTy<'tcx>,
 797         field: Field,
 798         location: Location,
 799     ) -> Result<Ty<'tcx>, FieldAccessError> {
 800         let tcx = self.tcx();
 801
 802         let (variant, substs) = match base_ty {
 803             PlaceTy { ty, variant_index: Some(variant_index) } => match *ty.kind() {
 804                 ty::Adt(adt_def, substs) => (adt_def.variant(variant_index), substs),
 805                 ty::Generator(def_id, substs, _) => {
 806                     let mut variants = substs.as_generator().state_tys(def_id, tcx);
 807                     let Some(mut variant) = variants.nth(variant_index.into()) else {
 808                         bug!(
 809                             "variant_index of generator out of range: {:?}/{:?}",
 810                             variant_index,
 811                             substs.as_generator().state_tys(def_id, tcx).count()
 812                         );
 813                     };
 814                     return match variant.nth(field.index()) {
 815                         Some(ty) => Ok(ty),
 816                         None => Err(FieldAccessError::OutOfRange { field_count: variant.count() }),
 817                     };
 818                 }
 819                 _ => bug!("can't have downcast of non-adt non-generator type"),
 820             },
 821             PlaceTy { ty, variant_index: None } => match *ty.kind() {
 822                 ty::Adt(adt_def, substs) if !adt_def.is_enum() => {
 823                     (adt_def.variant(VariantIdx::new(0)), substs)
 824                 }
 825                 ty::Closure(_, substs) => {
 826                     return match substs
 827                         .as_closure()
 828                         .tupled_upvars_ty()
 829                         .tuple_fields()
 830                         .get(field.index())
 831                     {
 832                         Some(&ty) => Ok(ty),
 833                         None => Err(FieldAccessError::OutOfRange {
 834                             field_count: substs.as_closure().upvar_tys().count(),
 835                         }),
 836                     };
 837                 }
 838                 ty::Generator(_, substs, _) => {
 839                     // Only prefix fields (upvars and current state) are
 840                     // accessible without a variant index.
 841                     return match substs.as_generator().prefix_tys().nth(field.index()) {
 842                         Some(ty) => Ok(ty),
 843                         None => Err(FieldAccessError::OutOfRange {
 844                             field_count: substs.as_generator().prefix_tys().count(),
 845                         }),
 846                     };
 847                 }
 848                 ty::Tuple(tys) => {
 849                     return match tys.get(field.index()) {
 850                         Some(&ty) => Ok(ty),
 851                         None => Err(FieldAccessError::OutOfRange { field_count: tys.len() }),
 852                     };
 853                 }
 854                 _ => {
 855                     return Ok(span_mirbug_and_err!(
 856                         self,
 857                         parent,
 858                         "can't project out of {:?}",
 859                         base_ty
 860                     ));
 861                 }
 862             },
 863         };
 864
 865         if let Some(field) = variant.fields.get(field.index()) {
 866             Ok(self.cx.normalize(field.ty(tcx, substs), location))
 867         } else {
 868             Err(FieldAccessError::OutOfRange { field_count: variant.fields.len() })
 869         }
 870     }
 871 }
 872
 873 /// The MIR type checker. Visits the MIR and enforces all the
 874 /// constraints needed for it to be valid and well-typed. Along the
 875 /// way, it accrues region constraints -- these can later be used by
 876 /// NLL region checking.
 877 struct TypeChecker<'a, 'tcx> {
 878     infcx: &'a InferCtxt<'a, 'tcx>,
 879     param_env: ty::ParamEnv<'tcx>,
 880     last_span: Span,
 881     body: &'a Body<'tcx>,
 882     /// User type annotations are shared between the main MIR and the MIR of
 883     /// all of the promoted items.
 884     user_type_annotations: &'a CanonicalUserTypeAnnotations<'tcx>,
 885     region_bound_pairs: &'a RegionBoundPairs<'tcx>,
 886     implicit_region_bound: ty::Region<'tcx>,
 887     reported_errors: FxHashSet<(Ty<'tcx>, Span)>,
 888     borrowck_context: &'a mut BorrowCheckContext<'a, 'tcx>,
 889 }
 890
 891 struct BorrowCheckContext<'a, 'tcx> {
 892     pub(crate) universal_regions: &'a UniversalRegions<'tcx>,
 893     location_table: &'a LocationTable,
 894     all_facts: &'a mut Option<AllFacts>,
 895     borrow_set: &'a BorrowSet<'tcx>,
 896     pub(crate) constraints: &'a mut MirTypeckRegionConstraints<'tcx>,
 897     upvars: &'a [Upvar<'tcx>],
 898 }
 899
 900 pub(crate) struct MirTypeckResults<'tcx> {
 901     pub(crate) constraints: MirTypeckRegionConstraints<'tcx>,
 902     pub(crate) universal_region_relations: Frozen<UniversalRegionRelations<'tcx>>,
 903     pub(crate) opaque_type_values:
 904         VecMap<OpaqueTypeKey<'tcx>, (OpaqueHiddenType<'tcx>, OpaqueTyOrigin)>,
 905 }
 906
 907 /// A collection of region constraints that must be satisfied for the
 908 /// program to be considered well-typed.
 909 pub(crate) struct MirTypeckRegionConstraints<'tcx> {
 910     /// Maps from a `ty::Placeholder` to the corresponding
 911     /// `PlaceholderIndex` bit that we will use for it.
 912     ///
 913     /// To keep everything in sync, do not insert this set
 914     /// directly. Instead, use the `placeholder_region` helper.
 915     pub(crate) placeholder_indices: PlaceholderIndices,
 916
 917     /// Each time we add a placeholder to `placeholder_indices`, we
 918     /// also create a corresponding "representative" region vid for
 919     /// that wraps it. This vector tracks those. This way, when we
 920     /// convert the same `ty::RePlaceholder(p)` twice, we can map to
 921     /// the same underlying `RegionVid`.
 922     pub(crate) placeholder_index_to_region: IndexVec<PlaceholderIndex, ty::Region<'tcx>>,
 923
 924     /// In general, the type-checker is not responsible for enforcing
 925     /// liveness constraints; this job falls to the region inferencer,
 926     /// which performs a liveness analysis. However, in some limited
 927     /// cases, the MIR type-checker creates temporary regions that do
 928     /// not otherwise appear in the MIR -- in particular, the
 929     /// late-bound regions that it instantiates at call-sites -- and
 930     /// hence it must report on their liveness constraints.
 931     pub(crate) liveness_constraints: LivenessValues<RegionVid>,
 932
 933     pub(crate) outlives_constraints: OutlivesConstraintSet<'tcx>,
 934
 935     pub(crate) member_constraints: MemberConstraintSet<'tcx, RegionVid>,
 936
 937     pub(crate) closure_bounds_mapping:
 938         FxHashMap<Location, FxHashMap<(RegionVid, RegionVid), (ConstraintCategory, Span)>>,
 939
 940     pub(crate) universe_causes: FxHashMap<ty::UniverseIndex, UniverseInfo<'tcx>>,
 941
 942     pub(crate) type_tests: Vec<TypeTest<'tcx>>,
 943 }
 944
 945 impl<'tcx> MirTypeckRegionConstraints<'tcx> {
 946     fn placeholder_region(
 947         &mut self,
 948         infcx: &InferCtxt<'_, 'tcx>,
 949         placeholder: ty::PlaceholderRegion,
 950     ) -> ty::Region<'tcx> {
 951         let placeholder_index = self.placeholder_indices.insert(placeholder);
 952         match self.placeholder_index_to_region.get(placeholder_index) {
 953             Some(&v) => v,
 954             None => {
 955                 let origin = NllRegionVariableOrigin::Placeholder(placeholder);
 956                 let region = infcx.next_nll_region_var_in_universe(origin, placeholder.universe);
 957                 self.placeholder_index_to_region.push(region);
 958                 region
 959             }
 960         }
 961     }
 962 }
 963
 964 /// The `Locations` type summarizes *where* region constraints are
 965 /// required to hold. Normally, this is at a particular point which
 966 /// created the obligation, but for constraints that the user gave, we
 967 /// want the constraint to hold at all points.
 968 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
 969 pub enum Locations {
 970     /// Indicates that a type constraint should always be true. This
 971     /// is particularly important in the new borrowck analysis for
 972     /// things like the type of the return slot. Consider this
 973     /// example:
 974     ///
 975     /// ```compile_fail,E0515
 976     /// fn foo<'a>(x: &'a u32) -> &'a u32 {
 977     ///     let y = 22;
 978     ///     return &y; // error
 979     /// }
 980     /// ```
 981     ///
 982     /// Here, we wind up with the signature from the return type being
 983     /// something like `&'1 u32` where `'1` is a universal region. But
 984     /// the type of the return slot `_0` is something like `&'2 u32`
 985     /// where `'2` is an existential region variable. The type checker
 986     /// requires that `&'2 u32 = &'1 u32` -- but at what point? In the
 987     /// older NLL analysis, we required this only at the entry point
 988     /// to the function. By the nature of the constraints, this wound
 989     /// up propagating to all points reachable from start (because
 990     /// `'1` -- as a universal region -- is live everywhere). In the
 991     /// newer analysis, though, this doesn't work: `_0` is considered
 992     /// dead at the start (it has no usable value) and hence this type
 993     /// equality is basically a no-op. Then, later on, when we do `_0
 994     /// = &'3 y`, that region `'3` never winds up related to the
 995     /// universal region `'1` and hence no error occurs. Therefore, we
 996     /// use Locations::All instead, which ensures that the `'1` and
 997     /// `'2` are equal everything. We also use this for other
 998     /// user-given type annotations; e.g., if the user wrote `let mut
 999     /// x: &'static u32 = ...`, we would ensure that all values
1000     /// assigned to `x` are of `'static` lifetime.
1001     ///
1002     /// The span points to the place the constraint arose. For example,
1003     /// it points to the type in a user-given type annotation. If
1004     /// there's no sensible span then it's DUMMY_SP.
1005     All(Span),
1006
1007     /// An outlives constraint that only has to hold at a single location,
1008     /// usually it represents a point where references flow from one spot to
1009     /// another (e.g., `x = y`)
1010     Single(Location),
1011 }
1012
1013 impl Locations {
1014     pub fn from_location(&self) -> Option<Location> {
1015         match self {
1016             Locations::All(_) => None,
1017             Locations::Single(from_location) => Some(*from_location),
1018         }
1019     }
1020
1021     /// Gets a span representing the location.
1022     pub fn span(&self, body: &Body<'_>) -> Span {
1023         match self {
1024             Locations::All(span) => *span,
1025             Locations::Single(l) => body.source_info(*l).span,
1026         }
1027     }
1028 }
1029
1030 impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
1031     fn new(
1032         infcx: &'a InferCtxt<'a, 'tcx>,
1033         body: &'a Body<'tcx>,
1034         param_env: ty::ParamEnv<'tcx>,
1035         region_bound_pairs: &'a RegionBoundPairs<'tcx>,
1036         implicit_region_bound: ty::Region<'tcx>,
1037         borrowck_context: &'a mut BorrowCheckContext<'a, 'tcx>,
1038     ) -> Self {
1039         let mut checker = Self {
1040             infcx,
1041             last_span: DUMMY_SP,
1042             body,
1043             user_type_annotations: &body.user_type_annotations,
1044             param_env,
1045             region_bound_pairs,
1046             implicit_region_bound,
1047             borrowck_context,
1048             reported_errors: Default::default(),
1049         };
1050         checker.check_user_type_annotations();
1051         checker
1052     }
1053
1054     fn body(&self) -> &Body<'tcx> {
1055         self.body
1056     }
1057
1058     fn unsized_feature_enabled(&self) -> bool {
1059         let features = self.tcx().features();
1060         features.unsized_locals || features.unsized_fn_params
1061     }
1062
1063     /// Equate the inferred type and the annotated type for user type annotations
1064     #[instrument(skip(self), level = "debug")]
1065     fn check_user_type_annotations(&mut self) {
1066         debug!(?self.user_type_annotations);
1067         for user_annotation in self.user_type_annotations {
1068             let CanonicalUserTypeAnnotation { span, ref user_ty, inferred_ty } = *user_annotation;
1069             let inferred_ty = self.normalize(inferred_ty, Locations::All(span));
1070             let annotation = self.instantiate_canonical_with_fresh_inference_vars(span, user_ty);
1071             match annotation {
1072                 UserType::Ty(mut ty) => {
1073                     ty = self.normalize(ty, Locations::All(span));
1074
1075                     if let Err(terr) = self.eq_types(
1076                         ty,
1077                         inferred_ty,
1078                         Locations::All(span),
1079                         ConstraintCategory::BoringNoLocation,
1080                     ) {
1081                         span_mirbug!(
1082                             self,
1083                             user_annotation,
1084                             "bad user type ({:?} = {:?}): {:?}",
1085                             ty,
1086                             inferred_ty,
1087                             terr
1088                         );
1089                     }
1090
1091                     self.prove_predicate(
1092                         ty::Binder::dummy(ty::PredicateKind::WellFormed(inferred_ty.into()))
1093                             .to_predicate(self.tcx()),
1094                         Locations::All(span),
1095                         ConstraintCategory::TypeAnnotation,
1096                     );
1097                 }
1098                 UserType::TypeOf(def_id, user_substs) => {
1099                     if let Err(terr) = self.fully_perform_op(
1100                         Locations::All(span),
1101                         ConstraintCategory::BoringNoLocation,
1102                         self.param_env.and(type_op::ascribe_user_type::AscribeUserType::new(
1103                             inferred_ty,
1104                             def_id,
1105                             user_substs,
1106                         )),
1107                     ) {
1108                         span_mirbug!(
1109                             self,
1110                             user_annotation,
1111                             "bad user type AscribeUserType({:?}, {:?} {:?}, type_of={:?}): {:?}",
1112                             inferred_ty,
1113                             def_id,
1114                             user_substs,
1115                             self.tcx().type_of(def_id),
1116                             terr,
1117                         );
1118                     }
1119                 }
1120             }
1121         }
1122     }
1123
1124     #[instrument(skip(self, data), level = "debug")]
1125     fn push_region_constraints(
1126         &mut self,
1127         locations: Locations,
1128         category: ConstraintCategory,
1129         data: &QueryRegionConstraints<'tcx>,
1130     ) {
1131         debug!("constraints generated: {:#?}", data);
1132
1133         constraint_conversion::ConstraintConversion::new(
1134             self.infcx,
1135             self.borrowck_context.universal_regions,
1136             self.region_bound_pairs,
1137             Some(self.implicit_region_bound),
1138             self.param_env,
1139             locations,
1140             locations.span(self.body),
1141             category,
1142             &mut self.borrowck_context.constraints,
1143         )
1144         .convert_all(data);
1145     }
1146
1147     /// Try to relate `sub <: sup`
1148     fn sub_types(
1149         &mut self,
1150         sub: Ty<'tcx>,
1151         sup: Ty<'tcx>,
1152         locations: Locations,
1153         category: ConstraintCategory,
1154     ) -> Fallible<()> {
1155         // Use this order of parameters because the sup type is usually the
1156         // "expected" type in diagnostics.
1157         self.relate_types(sup, ty::Variance::Contravariant, sub, locations, category)
1158     }
1159
1160     #[instrument(skip(self, category), level = "debug")]
1161     fn eq_types(
1162         &mut self,
1163         expected: Ty<'tcx>,
1164         found: Ty<'tcx>,
1165         locations: Locations,
1166         category: ConstraintCategory,
1167     ) -> Fallible<()> {
1168         self.relate_types(expected, ty::Variance::Invariant, found, locations, category)
1169     }
1170
1171     #[instrument(skip(self), level = "debug")]
1172     fn relate_type_and_user_type(
1173         &mut self,
1174         a: Ty<'tcx>,
1175         v: ty::Variance,
1176         user_ty: &UserTypeProjection,
1177         locations: Locations,
1178         category: ConstraintCategory,
1179     ) -> Fallible<()> {
1180         let annotated_type = self.user_type_annotations[user_ty.base].inferred_ty;
1181         let mut curr_projected_ty = PlaceTy::from_ty(annotated_type);
1182
1183         let tcx = self.infcx.tcx;
1184
1185         for proj in &user_ty.projs {
1186             let projected_ty = curr_projected_ty.projection_ty_core(
1187                 tcx,
1188                 self.param_env,
1189                 proj,
1190                 |this, field, ()| {
1191                     let ty = this.field_ty(tcx, field);
1192                     self.normalize(ty, locations)
1193                 },
1194             );
1195             curr_projected_ty = projected_ty;
1196         }
1197         debug!(
1198             "user_ty base: {:?} freshened: {:?} projs: {:?} yields: {:?}",
1199             user_ty.base, annotated_type, user_ty.projs, curr_projected_ty
1200         );
1201
1202         let ty = curr_projected_ty.ty;
1203         self.relate_types(ty, v.xform(ty::Variance::Contravariant), a, locations, category)?;
1204
1205         Ok(())
1206     }
1207
1208     fn tcx(&self) -> TyCtxt<'tcx> {
1209         self.infcx.tcx
1210     }
1211
1212     #[instrument(skip(self, body, location), level = "debug")]
1213     fn check_stmt(&mut self, body: &Body<'tcx>, stmt: &Statement<'tcx>, location: Location) {
1214         let tcx = self.tcx();
1215         match stmt.kind {
1216             StatementKind::Assign(box (ref place, ref rv)) => {
1217                 // Assignments to temporaries are not "interesting";
1218                 // they are not caused by the user, but rather artifacts
1219                 // of lowering. Assignments to other sorts of places *are* interesting
1220                 // though.
1221                 let category = match place.as_local() {
1222                     Some(RETURN_PLACE) => {
1223                         let defining_ty = &self.borrowck_context.universal_regions.defining_ty;
1224                         if defining_ty.is_const() {
1225                             if tcx.is_static(defining_ty.def_id()) {
1226                                 ConstraintCategory::UseAsStatic
1227                             } else {
1228                                 ConstraintCategory::UseAsConst
1229                             }
1230                         } else {
1231                             ConstraintCategory::Return(ReturnConstraint::Normal)
1232                         }
1233                     }
1234                     Some(l)
1235                         if matches!(
1236                             body.local_decls[l].local_info,
1237                             Some(box LocalInfo::AggregateTemp)
1238                         ) =>
1239                     {
1240                         ConstraintCategory::Usage
1241                     }
1242                     Some(l) if !body.local_decls[l].is_user_variable() => {
1243                         ConstraintCategory::Boring
1244                     }
1245                     _ => ConstraintCategory::Assignment,
1246                 };
1247                 debug!(
1248                     "assignment category: {:?} {:?}",
1249                     category,
1250                     place.as_local().map(|l| &body.local_decls[l])
1251                 );
1252
1253                 let place_ty = place.ty(body, tcx).ty;
1254                 let place_ty = self.normalize(place_ty, location);
1255                 let rv_ty = rv.ty(body, tcx);
1256                 let rv_ty = self.normalize(rv_ty, location);
1257                 if let Err(terr) =
1258                     self.sub_types(rv_ty, place_ty, location.to_locations(), category)
1259                 {
1260                     span_mirbug!(
1261                         self,
1262                         stmt,
1263                         "bad assignment ({:?} = {:?}): {:?}",
1264                         place_ty,
1265                         rv_ty,
1266                         terr
1267                     );
1268                 }
1269
1270                 if let Some(annotation_index) = self.rvalue_user_ty(rv) {
1271                     if let Err(terr) = self.relate_type_and_user_type(
1272                         rv_ty,
1273                         ty::Variance::Invariant,
1274                         &UserTypeProjection { base: annotation_index, projs: vec![] },
1275                         location.to_locations(),
1276                         ConstraintCategory::Boring,
1277                     ) {
1278                         let annotation = &self.user_type_annotations[annotation_index];
1279                         span_mirbug!(
1280                             self,
1281                             stmt,
1282                             "bad user type on rvalue ({:?} = {:?}): {:?}",
1283                             annotation,
1284                             rv_ty,
1285                             terr
1286                         );
1287                     }
1288                 }
1289
1290                 self.check_rvalue(body, rv, location);
1291                 if !self.unsized_feature_enabled() {
1292                     let trait_ref = ty::TraitRef {
1293                         def_id: tcx.require_lang_item(LangItem::Sized, Some(self.last_span)),
1294                         substs: tcx.mk_substs_trait(place_ty, &[]),
1295                     };
1296                     self.prove_trait_ref(
1297                         trait_ref,
1298                         location.to_locations(),
1299                         ConstraintCategory::SizedBound,
1300                     );
1301                 }
1302             }
1303             StatementKind::AscribeUserType(box (ref place, ref projection), variance) => {
1304                 let place_ty = place.ty(body, tcx).ty;
1305                 if let Err(terr) = self.relate_type_and_user_type(
1306                     place_ty,
1307                     variance,
1308                     projection,
1309                     Locations::All(stmt.source_info.span),
1310                     ConstraintCategory::TypeAnnotation,
1311                 ) {
1312                     let annotation = &self.user_type_annotations[projection.base];
1313                     span_mirbug!(
1314                         self,
1315                         stmt,
1316                         "bad type assert ({:?} <: {:?} with projections {:?}): {:?}",
1317                         place_ty,
1318                         annotation,
1319                         projection.projs,
1320                         terr
1321                     );
1322                 }
1323             }
1324             StatementKind::CopyNonOverlapping(box rustc_middle::mir::CopyNonOverlapping {
1325                 ..
1326             }) => span_bug!(
1327                 stmt.source_info.span,
1328                 "Unexpected StatementKind::CopyNonOverlapping, should only appear after lowering_intrinsics",
1329             ),
1330             StatementKind::FakeRead(..)
1331             | StatementKind::StorageLive(..)
1332             | StatementKind::StorageDead(..)
1333             | StatementKind::Retag { .. }
1334             | StatementKind::Coverage(..)
1335             | StatementKind::Nop => {}
1336             StatementKind::Deinit(..) | StatementKind::SetDiscriminant { .. } => {
1337                 bug!("Statement not allowed in this MIR phase")
1338             }
1339         }
1340     }
1341
1342     #[instrument(skip(self, body, term_location), level = "debug")]
1343     fn check_terminator(
1344         &mut self,
1345         body: &Body<'tcx>,
1346         term: &Terminator<'tcx>,
1347         term_location: Location,
1348     ) {
1349         let tcx = self.tcx();
1350         match term.kind {
1351             TerminatorKind::Goto { .. }
1352             | TerminatorKind::Resume
1353             | TerminatorKind::Abort
1354             | TerminatorKind::Return
1355             | TerminatorKind::GeneratorDrop
1356             | TerminatorKind::Unreachable
1357             | TerminatorKind::Drop { .. }
1358             | TerminatorKind::FalseEdge { .. }
1359             | TerminatorKind::FalseUnwind { .. }
1360             | TerminatorKind::InlineAsm { .. } => {
1361                 // no checks needed for these
1362             }
1363
1364             TerminatorKind::DropAndReplace { ref place, ref value, target: _, unwind: _ } => {
1365                 let place_ty = place.ty(body, tcx).ty;
1366                 let rv_ty = value.ty(body, tcx);
1367
1368                 let locations = term_location.to_locations();
1369                 if let Err(terr) =
1370                     self.sub_types(rv_ty, place_ty, locations, ConstraintCategory::Assignment)
1371                 {
1372                     span_mirbug!(
1373                         self,
1374                         term,
1375                         "bad DropAndReplace ({:?} = {:?}): {:?}",
1376                         place_ty,
1377                         rv_ty,
1378                         terr
1379                     );
1380                 }
1381             }
1382             TerminatorKind::SwitchInt { ref discr, switch_ty, .. } => {
1383                 self.check_operand(discr, term_location);
1384
1385                 let discr_ty = discr.ty(body, tcx);
1386                 if let Err(terr) = self.sub_types(
1387                     discr_ty,
1388                     switch_ty,
1389                     term_location.to_locations(),
1390                     ConstraintCategory::Assignment,
1391                 ) {
1392                     span_mirbug!(
1393                         self,
1394                         term,
1395                         "bad SwitchInt ({:?} on {:?}): {:?}",
1396                         switch_ty,
1397                         discr_ty,
1398                         terr
1399                     );
1400                 }
1401                 if !switch_ty.is_integral() && !switch_ty.is_char() && !switch_ty.is_bool() {
1402                     span_mirbug!(self, term, "bad SwitchInt discr ty {:?}", switch_ty);
1403                 }
1404                 // FIXME: check the values
1405             }
1406             TerminatorKind::Call { ref func, ref args, ref destination, from_hir_call, .. } => {
1407                 self.check_operand(func, term_location);
1408                 for arg in args {
1409                     self.check_operand(arg, term_location);
1410                 }
1411
1412                 let func_ty = func.ty(body, tcx);
1413                 debug!("check_terminator: call, func_ty={:?}", func_ty);
1414                 let sig = match func_ty.kind() {
1415                     ty::FnDef(..) | ty::FnPtr(_) => func_ty.fn_sig(tcx),
1416                     _ => {
1417                         span_mirbug!(self, term, "call to non-function {:?}", func_ty);
1418                         return;
1419                     }
1420                 };
1421                 let (sig, map) = self.infcx.replace_bound_vars_with_fresh_vars(
1422                     term.source_info.span,
1423                     LateBoundRegionConversionTime::FnCall,
1424                     sig,
1425                 );
1426                 let sig = self.normalize(sig, term_location);
1427                 self.check_call_dest(body, term, &sig, destination, term_location);
1428
1429                 self.prove_predicates(
1430                     sig.inputs_and_output
1431                         .iter()
1432                         .map(|ty| ty::Binder::dummy(ty::PredicateKind::WellFormed(ty.into()))),
1433                     term_location.to_locations(),
1434                     ConstraintCategory::Boring,
1435                 );
1436
1437                 // The ordinary liveness rules will ensure that all
1438                 // regions in the type of the callee are live here. We
1439                 // then further constrain the late-bound regions that
1440                 // were instantiated at the call site to be live as
1441                 // well. The resulting is that all the input (and
1442                 // output) types in the signature must be live, since
1443                 // all the inputs that fed into it were live.
1444                 for &late_bound_region in map.values() {
1445                     let region_vid =
1446                         self.borrowck_context.universal_regions.to_region_vid(late_bound_region);
1447                     self.borrowck_context
1448                         .constraints
1449                         .liveness_constraints
1450                         .add_element(region_vid, term_location);
1451                 }
1452
1453                 self.check_call_inputs(body, term, &sig, args, term_location, from_hir_call);
1454             }
1455             TerminatorKind::Assert { ref cond, ref msg, .. } => {
1456                 self.check_operand(cond, term_location);
1457
1458                 let cond_ty = cond.ty(body, tcx);
1459                 if cond_ty != tcx.types.bool {
1460                     span_mirbug!(self, term, "bad Assert ({:?}, not bool", cond_ty);
1461                 }
1462
1463                 if let AssertKind::BoundsCheck { ref len, ref index } = *msg {
1464                     if len.ty(body, tcx) != tcx.types.usize {
1465                         span_mirbug!(self, len, "bounds-check length non-usize {:?}", len)
1466                     }
1467                     if index.ty(body, tcx) != tcx.types.usize {
1468                         span_mirbug!(self, index, "bounds-check index non-usize {:?}", index)
1469                     }
1470                 }
1471             }
1472             TerminatorKind::Yield { ref value, .. } => {
1473                 self.check_operand(value, term_location);
1474
1475                 let value_ty = value.ty(body, tcx);
1476                 match body.yield_ty() {
1477                     None => span_mirbug!(self, term, "yield in non-generator"),
1478                     Some(ty) => {
1479                         if let Err(terr) = self.sub_types(
1480                             value_ty,
1481                             ty,
1482                             term_location.to_locations(),
1483                             ConstraintCategory::Yield,
1484                         ) {
1485                             span_mirbug!(
1486                                 self,
1487                                 term,
1488                                 "type of yield value is {:?}, but the yield type is {:?}: {:?}",
1489                                 value_ty,
1490                                 ty,
1491                                 terr
1492                             );
1493                         }
1494                     }
1495                 }
1496             }
1497         }
1498     }
1499
1500     fn check_call_dest(
1501         &mut self,
1502         body: &Body<'tcx>,
1503         term: &Terminator<'tcx>,
1504         sig: &ty::FnSig<'tcx>,
1505         destination: &Option<(Place<'tcx>, BasicBlock)>,
1506         term_location: Location,
1507     ) {
1508         let tcx = self.tcx();
1509         match *destination {
1510             Some((ref dest, _target_block)) => {
1511                 let dest_ty = dest.ty(body, tcx).ty;
1512                 let dest_ty = self.normalize(dest_ty, term_location);
1513                 let category = match dest.as_local() {
1514                     Some(RETURN_PLACE) => {
1515                         if let BorrowCheckContext {
1516                             universal_regions:
1517                                 UniversalRegions {
1518                                     defining_ty:
1519                                         DefiningTy::Const(def_id, _)
1520                                         | DefiningTy::InlineConst(def_id, _),
1521                                     ..
1522                                 },
1523                             ..
1524                         } = self.borrowck_context
1525                         {
1526                             if tcx.is_static(*def_id) {
1527                                 ConstraintCategory::UseAsStatic
1528                             } else {
1529                                 ConstraintCategory::UseAsConst
1530                             }
1531                         } else {
1532                             ConstraintCategory::Return(ReturnConstraint::Normal)
1533                         }
1534                     }
1535                     Some(l) if !body.local_decls[l].is_user_variable() => {
1536                         ConstraintCategory::Boring
1537                     }
1538                     _ => ConstraintCategory::Assignment,
1539                 };
1540
1541                 let locations = term_location.to_locations();
1542
1543                 if let Err(terr) = self.sub_types(sig.output(), dest_ty, locations, category) {
1544                     span_mirbug!(
1545                         self,
1546                         term,
1547                         "call dest mismatch ({:?} <- {:?}): {:?}",
1548                         dest_ty,
1549                         sig.output(),
1550                         terr
1551                     );
1552                 }
1553
1554                 // When `unsized_fn_params` and `unsized_locals` are both not enabled,
1555                 // this check is done at `check_local`.
1556                 if self.unsized_feature_enabled() {
1557                     let span = term.source_info.span;
1558                     self.ensure_place_sized(dest_ty, span);
1559                 }
1560             }
1561             None => {
1562                 if !self
1563                     .tcx()
1564                     .conservative_is_privately_uninhabited(self.param_env.and(sig.output()))
1565                 {
1566                     span_mirbug!(self, term, "call to converging function {:?} w/o dest", sig);
1567                 }
1568             }
1569         }
1570     }
1571
1572     fn check_call_inputs(
1573         &mut self,
1574         body: &Body<'tcx>,
1575         term: &Terminator<'tcx>,
1576         sig: &ty::FnSig<'tcx>,
1577         args: &[Operand<'tcx>],
1578         term_location: Location,
1579         from_hir_call: bool,
1580     ) {
1581         debug!("check_call_inputs({:?}, {:?})", sig, args);
1582         if args.len() < sig.inputs().len() || (args.len() > sig.inputs().len() && !sig.c_variadic) {
1583             span_mirbug!(self, term, "call to {:?} with wrong # of args", sig);
1584         }
1585         for (n, (fn_arg, op_arg)) in iter::zip(sig.inputs(), args).enumerate() {
1586             let op_arg_ty = op_arg.ty(body, self.tcx());
1587             let op_arg_ty = self.normalize(op_arg_ty, term_location);
1588             let category = if from_hir_call {
1589                 ConstraintCategory::CallArgument
1590             } else {
1591                 ConstraintCategory::Boring
1592             };
1593             if let Err(terr) =
1594                 self.sub_types(op_arg_ty, *fn_arg, term_location.to_locations(), category)
1595             {
1596                 span_mirbug!(
1597                     self,
1598                     term,
1599                     "bad arg #{:?} ({:?} <- {:?}): {:?}",
1600                     n,
1601                     fn_arg,
1602                     op_arg_ty,
1603                     terr
1604                 );
1605             }
1606         }
1607     }
1608
1609     fn check_iscleanup(&mut self, body: &Body<'tcx>, block_data: &BasicBlockData<'tcx>) {
1610         let is_cleanup = block_data.is_cleanup;
1611         self.last_span = block_data.terminator().source_info.span;
1612         match block_data.terminator().kind {
1613             TerminatorKind::Goto { target } => {
1614                 self.assert_iscleanup(body, block_data, target, is_cleanup)
1615             }
1616             TerminatorKind::SwitchInt { ref targets, .. } => {
1617                 for target in targets.all_targets() {
1618                     self.assert_iscleanup(body, block_data, *target, is_cleanup);
1619                 }
1620             }
1621             TerminatorKind::Resume => {
1622                 if !is_cleanup {
1623                     span_mirbug!(self, block_data, "resume on non-cleanup block!")
1624                 }
1625             }
1626             TerminatorKind::Abort => {
1627                 if !is_cleanup {
1628                     span_mirbug!(self, block_data, "abort on non-cleanup block!")
1629                 }
1630             }
1631             TerminatorKind::Return => {
1632                 if is_cleanup {
1633                     span_mirbug!(self, block_data, "return on cleanup block")
1634                 }
1635             }
1636             TerminatorKind::GeneratorDrop { .. } => {
1637                 if is_cleanup {
1638                     span_mirbug!(self, block_data, "generator_drop in cleanup block")
1639                 }
1640             }
1641             TerminatorKind::Yield { resume, drop, .. } => {
1642                 if is_cleanup {
1643                     span_mirbug!(self, block_data, "yield in cleanup block")
1644                 }
1645                 self.assert_iscleanup(body, block_data, resume, is_cleanup);
1646                 if let Some(drop) = drop {
1647                     self.assert_iscleanup(body, block_data, drop, is_cleanup);
1648                 }
1649             }
1650             TerminatorKind::Unreachable => {}
1651             TerminatorKind::Drop { target, unwind, .. }
1652             | TerminatorKind::DropAndReplace { target, unwind, .. }
1653             | TerminatorKind::Assert { target, cleanup: unwind, .. } => {
1654                 self.assert_iscleanup(body, block_data, target, is_cleanup);
1655                 if let Some(unwind) = unwind {
1656                     if is_cleanup {
1657                         span_mirbug!(self, block_data, "unwind on cleanup block")
1658                     }
1659                     self.assert_iscleanup(body, block_data, unwind, true);
1660                 }
1661             }
1662             TerminatorKind::Call { ref destination, cleanup, .. } => {
1663                 if let &Some((_, target)) = destination {
1664                     self.assert_iscleanup(body, block_data, target, is_cleanup);
1665                 }
1666                 if let Some(cleanup) = cleanup {
1667                     if is_cleanup {
1668                         span_mirbug!(self, block_data, "cleanup on cleanup block")
1669                     }
1670                     self.assert_iscleanup(body, block_data, cleanup, true);
1671                 }
1672             }
1673             TerminatorKind::FalseEdge { real_target, imaginary_target } => {
1674                 self.assert_iscleanup(body, block_data, real_target, is_cleanup);
1675                 self.assert_iscleanup(body, block_data, imaginary_target, is_cleanup);
1676             }
1677             TerminatorKind::FalseUnwind { real_target, unwind } => {
1678                 self.assert_iscleanup(body, block_data, real_target, is_cleanup);
1679                 if let Some(unwind) = unwind {
1680                     if is_cleanup {
1681                         span_mirbug!(self, block_data, "cleanup in cleanup block via false unwind");
1682                     }
1683                     self.assert_iscleanup(body, block_data, unwind, true);
1684                 }
1685             }
1686             TerminatorKind::InlineAsm { destination, cleanup, .. } => {
1687                 if let Some(target) = destination {
1688                     self.assert_iscleanup(body, block_data, target, is_cleanup);
1689                 }
1690                 if let Some(cleanup) = cleanup {
1691                     if is_cleanup {
1692                         span_mirbug!(self, block_data, "cleanup on cleanup block")
1693                     }
1694                     self.assert_iscleanup(body, block_data, cleanup, true);
1695                 }
1696             }
1697         }
1698     }
1699
1700     fn assert_iscleanup(
1701         &mut self,
1702         body: &Body<'tcx>,
1703         ctxt: &dyn fmt::Debug,
1704         bb: BasicBlock,
1705         iscleanuppad: bool,
1706     ) {
1707         if body[bb].is_cleanup != iscleanuppad {
1708             span_mirbug!(self, ctxt, "cleanuppad mismatch: {:?} should be {:?}", bb, iscleanuppad);
1709         }
1710     }
1711
1712     fn check_local(&mut self, body: &Body<'tcx>, local: Local, local_decl: &LocalDecl<'tcx>) {
1713         match body.local_kind(local) {
1714             LocalKind::ReturnPointer | LocalKind::Arg => {
1715                 // return values of normal functions are required to be
1716                 // sized by typeck, but return values of ADT constructors are
1717                 // not because we don't include a `Self: Sized` bounds on them.
1718                 //
1719                 // Unbound parts of arguments were never required to be Sized
1720                 // - maybe we should make that a warning.
1721                 return;
1722             }
1723             LocalKind::Var | LocalKind::Temp => {}
1724         }
1725
1726         // When `unsized_fn_params` or `unsized_locals` is enabled, only function calls
1727         // and nullary ops are checked in `check_call_dest`.
1728         if !self.unsized_feature_enabled() {
1729             let span = local_decl.source_info.span;
1730             let ty = local_decl.ty;
1731             self.ensure_place_sized(ty, span);
1732         }
1733     }
1734
1735     fn ensure_place_sized(&mut self, ty: Ty<'tcx>, span: Span) {
1736         let tcx = self.tcx();
1737
1738         // Erase the regions from `ty` to get a global type.  The
1739         // `Sized` bound in no way depends on precise regions, so this
1740         // shouldn't affect `is_sized`.
1741         let erased_ty = tcx.erase_regions(ty);
1742         if !erased_ty.is_sized(tcx.at(span), self.param_env) {
1743             // in current MIR construction, all non-control-flow rvalue
1744             // expressions evaluate through `as_temp` or `into` a return
1745             // slot or local, so to find all unsized rvalues it is enough
1746             // to check all temps, return slots and locals.
1747             if self.reported_errors.replace((ty, span)).is_none() {
1748                 let mut diag = struct_span_err!(
1749                     self.tcx().sess,
1750                     span,
1751                     E0161,
1752                     "cannot move a value of type {0}: the size of {0} \
1753                      cannot be statically determined",
1754                     ty
1755                 );
1756
1757                 // While this is located in `nll::typeck` this error is not
1758                 // an NLL error, it's a required check to prevent creation
1759                 // of unsized rvalues in a call expression.
1760                 diag.emit();
1761             }
1762         }
1763     }
1764
1765     fn aggregate_field_ty(
1766         &mut self,
1767         ak: &AggregateKind<'tcx>,
1768         field_index: usize,
1769         location: Location,
1770     ) -> Result<Ty<'tcx>, FieldAccessError> {
1771         let tcx = self.tcx();
1772
1773         match *ak {
1774             AggregateKind::Adt(adt_did, variant_index, substs, _, active_field_index) => {
1775                 let def = tcx.adt_def(adt_did);
1776                 let variant = &def.variant(variant_index);
1777                 let adj_field_index = active_field_index.unwrap_or(field_index);
1778                 if let Some(field) = variant.fields.get(adj_field_index) {
1779                     Ok(self.normalize(field.ty(tcx, substs), location))
1780                 } else {
1781                     Err(FieldAccessError::OutOfRange { field_count: variant.fields.len() })
1782                 }
1783             }
1784             AggregateKind::Closure(_, substs) => {
1785                 match substs.as_closure().upvar_tys().nth(field_index) {
1786                     Some(ty) => Ok(ty),
1787                     None => Err(FieldAccessError::OutOfRange {
1788                         field_count: substs.as_closure().upvar_tys().count(),
1789                     }),
1790                 }
1791             }
1792             AggregateKind::Generator(_, substs, _) => {
1793                 // It doesn't make sense to look at a field beyond the prefix;
1794                 // these require a variant index, and are not initialized in
1795                 // aggregate rvalues.
1796                 match substs.as_generator().prefix_tys().nth(field_index) {
1797                     Some(ty) => Ok(ty),
1798                     None => Err(FieldAccessError::OutOfRange {
1799                         field_count: substs.as_generator().prefix_tys().count(),
1800                     }),
1801                 }
1802             }
1803             AggregateKind::Array(ty) => Ok(ty),
1804             AggregateKind::Tuple => {
1805                 unreachable!("This should have been covered in check_rvalues");
1806             }
1807         }
1808     }
1809
1810     fn check_operand(&mut self, op: &Operand<'tcx>, location: Location) {
1811         if let Operand::Constant(constant) = op {
1812             let maybe_uneval = match constant.literal {
1813                 ConstantKind::Ty(ct) => match ct.val() {
1814                     ty::ConstKind::Unevaluated(uv) => Some(uv),
1815                     _ => None,
1816                 },
1817                 _ => None,
1818             };
1819             if let Some(uv) = maybe_uneval {
1820                 if uv.promoted.is_none() {
1821                     let tcx = self.tcx();
1822                     let def_id = uv.def.def_id_for_type_of();
1823                     if tcx.def_kind(def_id) == DefKind::InlineConst {
1824                         let predicates = self.prove_closure_bounds(
1825                             tcx,
1826                             def_id.expect_local(),
1827                             uv.substs,
1828                             location,
1829                         );
1830                         self.normalize_and_prove_instantiated_predicates(
1831                             def_id,
1832                             predicates,
1833                             location.to_locations(),
1834                         );
1835                     }
1836                 }
1837             }
1838         }
1839     }
1840
1841     fn check_rvalue(&mut self, body: &Body<'tcx>, rvalue: &Rvalue<'tcx>, location: Location) {
1842         let tcx = self.tcx();
1843
1844         match rvalue {
1845             Rvalue::Aggregate(ak, ops) => {
1846                 for op in ops {
1847                     self.check_operand(op, location);
1848                 }
1849                 self.check_aggregate_rvalue(&body, rvalue, ak, ops, location)
1850             }
1851
1852             Rvalue::Repeat(operand, len) => {
1853                 self.check_operand(operand, location);
1854
1855                 // If the length cannot be evaluated we must assume that the length can be larger
1856                 // than 1.
1857                 // If the length is larger than 1, the repeat expression will need to copy the
1858                 // element, so we require the `Copy` trait.
1859                 if len.try_eval_usize(tcx, self.param_env).map_or(true, |len| len > 1) {
1860                     match operand {
1861                         Operand::Copy(..) | Operand::Constant(..) => {
1862                             // These are always okay: direct use of a const, or a value that can evidently be copied.
1863                         }
1864                         Operand::Move(place) => {
1865                             // Make sure that repeated elements implement `Copy`.
1866                             let span = body.source_info(location).span;
1867                             let ty = place.ty(body, tcx).ty;
1868                             let trait_ref = ty::TraitRef::new(
1869                                 tcx.require_lang_item(LangItem::Copy, Some(span)),
1870                                 tcx.mk_substs_trait(ty, &[]),
1871                             );
1872
1873                             self.prove_trait_ref(
1874                                 trait_ref,
1875                                 Locations::Single(location),
1876                                 ConstraintCategory::CopyBound,
1877                             );
1878                         }
1879                     }
1880                 }
1881             }
1882
1883             &Rvalue::NullaryOp(_, ty) => {
1884                 let trait_ref = ty::TraitRef {
1885                     def_id: tcx.require_lang_item(LangItem::Sized, Some(self.last_span)),
1886                     substs: tcx.mk_substs_trait(ty, &[]),
1887                 };
1888
1889                 self.prove_trait_ref(
1890                     trait_ref,
1891                     location.to_locations(),
1892                     ConstraintCategory::SizedBound,
1893                 );
1894             }
1895
1896             Rvalue::ShallowInitBox(operand, ty) => {
1897                 self.check_operand(operand, location);
1898
1899                 let trait_ref = ty::TraitRef {
1900                     def_id: tcx.require_lang_item(LangItem::Sized, Some(self.last_span)),
1901                     substs: tcx.mk_substs_trait(*ty, &[]),
1902                 };
1903
1904                 self.prove_trait_ref(
1905                     trait_ref,
1906                     location.to_locations(),
1907                     ConstraintCategory::SizedBound,
1908                 );
1909             }
1910
1911             Rvalue::Cast(cast_kind, op, ty) => {
1912                 self.check_operand(op, location);
1913
1914                 match cast_kind {
1915                     CastKind::Pointer(PointerCast::ReifyFnPointer) => {
1916                         let fn_sig = op.ty(body, tcx).fn_sig(tcx);
1917
1918                         // The type that we see in the fcx is like
1919                         // `foo::<'a, 'b>`, where `foo` is the path to a
1920                         // function definition. When we extract the
1921                         // signature, it comes from the `fn_sig` query,
1922                         // and hence may contain unnormalized results.
1923                         let fn_sig = self.normalize(fn_sig, location);
1924
1925                         let ty_fn_ptr_from = tcx.mk_fn_ptr(fn_sig);
1926
1927                         if let Err(terr) = self.eq_types(
1928                             *ty,
1929                             ty_fn_ptr_from,
1930                             location.to_locations(),
1931                             ConstraintCategory::Cast,
1932                         ) {
1933                             span_mirbug!(
1934                                 self,
1935                                 rvalue,
1936                                 "equating {:?} with {:?} yields {:?}",
1937                                 ty_fn_ptr_from,
1938                                 ty,
1939                                 terr
1940                             );
1941                         }
1942                     }
1943
1944                     CastKind::Pointer(PointerCast::ClosureFnPointer(unsafety)) => {
1945                         let sig = match op.ty(body, tcx).kind() {
1946                             ty::Closure(_, substs) => substs.as_closure().sig(),
1947                             _ => bug!(),
1948                         };
1949                         let ty_fn_ptr_from = tcx.mk_fn_ptr(tcx.signature_unclosure(sig, *unsafety));
1950
1951                         if let Err(terr) = self.eq_types(
1952                             *ty,
1953                             ty_fn_ptr_from,
1954                             location.to_locations(),
1955                             ConstraintCategory::Cast,
1956                         ) {
1957                             span_mirbug!(
1958                                 self,
1959                                 rvalue,
1960                                 "equating {:?} with {:?} yields {:?}",
1961                                 ty_fn_ptr_from,
1962                                 ty,
1963                                 terr
1964                             );
1965                         }
1966                     }
1967
1968                     CastKind::Pointer(PointerCast::UnsafeFnPointer) => {
1969                         let fn_sig = op.ty(body, tcx).fn_sig(tcx);
1970
1971                         // The type that we see in the fcx is like
1972                         // `foo::<'a, 'b>`, where `foo` is the path to a
1973                         // function definition. When we extract the
1974                         // signature, it comes from the `fn_sig` query,
1975                         // and hence may contain unnormalized results.
1976                         let fn_sig = self.normalize(fn_sig, location);
1977
1978                         let ty_fn_ptr_from = tcx.safe_to_unsafe_fn_ty(fn_sig);
1979
1980                         if let Err(terr) = self.eq_types(
1981                             *ty,
1982                             ty_fn_ptr_from,
1983                             location.to_locations(),
1984                             ConstraintCategory::Cast,
1985                         ) {
1986                             span_mirbug!(
1987                                 self,
1988                                 rvalue,
1989                                 "equating {:?} with {:?} yields {:?}",
1990                                 ty_fn_ptr_from,
1991                                 ty,
1992                                 terr
1993                             );
1994                         }
1995                     }
1996
1997                     CastKind::Pointer(PointerCast::Unsize) => {
1998                         let &ty = ty;
1999                         let trait_ref = ty::TraitRef {
2000                             def_id: tcx
2001                                 .require_lang_item(LangItem::CoerceUnsized, Some(self.last_span)),
2002                             substs: tcx.mk_substs_trait(op.ty(body, tcx), &[ty.into()]),
2003                         };
2004
2005                         self.prove_trait_ref(
2006                             trait_ref,
2007                             location.to_locations(),
2008                             ConstraintCategory::Cast,
2009                         );
2010                     }
2011
2012                     CastKind::Pointer(PointerCast::MutToConstPointer) => {
2013                         let ty::RawPtr(ty::TypeAndMut {
2014                             ty: ty_from,
2015                             mutbl: hir::Mutability::Mut,
2016                         }) = op.ty(body, tcx).kind() else {
2017                             span_mirbug!(
2018                                 self,
2019                                 rvalue,
2020                                 "unexpected base type for cast {:?}",
2021                                 ty,
2022                             );
2023                             return;
2024                         };
2025                         let ty::RawPtr(ty::TypeAndMut {
2026                             ty: ty_to,
2027                             mutbl: hir::Mutability::Not,
2028                         }) = ty.kind() else {
2029                             span_mirbug!(
2030                                 self,
2031                                 rvalue,
2032                                 "unexpected target type for cast {:?}",
2033                                 ty,
2034                             );
2035                             return;
2036                         };
2037                         if let Err(terr) = self.sub_types(
2038                             *ty_from,
2039                             *ty_to,
2040                             location.to_locations(),
2041                             ConstraintCategory::Cast,
2042                         ) {
2043                             span_mirbug!(
2044                                 self,
2045                                 rvalue,
2046                                 "relating {:?} with {:?} yields {:?}",
2047                                 ty_from,
2048                                 ty_to,
2049                                 terr
2050                             );
2051                         }
2052                     }
2053
2054                     CastKind::Pointer(PointerCast::ArrayToPointer) => {
2055                         let ty_from = op.ty(body, tcx);
2056
2057                         let opt_ty_elem_mut = match ty_from.kind() {
2058                             ty::RawPtr(ty::TypeAndMut { mutbl: array_mut, ty: array_ty }) => {
2059                                 match array_ty.kind() {
2060                                     ty::Array(ty_elem, _) => Some((ty_elem, *array_mut)),
2061                                     _ => None,
2062                                 }
2063                             }
2064                             _ => None,
2065                         };
2066
2067                         let Some((ty_elem, ty_mut)) = opt_ty_elem_mut else {
2068                             span_mirbug!(
2069                                 self,
2070                                 rvalue,
2071                                 "ArrayToPointer cast from unexpected type {:?}",
2072                                 ty_from,
2073                             );
2074                             return;
2075                         };
2076
2077                         let (ty_to, ty_to_mut) = match ty.kind() {
2078                             ty::RawPtr(ty::TypeAndMut { mutbl: ty_to_mut, ty: ty_to }) => {
2079                                 (ty_to, *ty_to_mut)
2080                             }
2081                             _ => {
2082                                 span_mirbug!(
2083                                     self,
2084                                     rvalue,
2085                                     "ArrayToPointer cast to unexpected type {:?}",
2086                                     ty,
2087                                 );
2088                                 return;
2089                             }
2090                         };
2091
2092                         if ty_to_mut == Mutability::Mut && ty_mut == Mutability::Not {
2093                             span_mirbug!(
2094                                 self,
2095                                 rvalue,
2096                                 "ArrayToPointer cast from const {:?} to mut {:?}",
2097                                 ty,
2098                                 ty_to
2099                             );
2100                             return;
2101                         }
2102
2103                         if let Err(terr) = self.sub_types(
2104                             *ty_elem,
2105                             *ty_to,
2106                             location.to_locations(),
2107                             ConstraintCategory::Cast,
2108                         ) {
2109                             span_mirbug!(
2110                                 self,
2111                                 rvalue,
2112                                 "relating {:?} with {:?} yields {:?}",
2113                                 ty_elem,
2114                                 ty_to,
2115                                 terr
2116                             )
2117                         }
2118                     }
2119
2120                     CastKind::Misc => {
2121                         let ty_from = op.ty(body, tcx);
2122                         let cast_ty_from = CastTy::from_ty(ty_from);
2123                         let cast_ty_to = CastTy::from_ty(*ty);
2124                         match (cast_ty_from, cast_ty_to) {
2125                             (None, _)
2126                             | (_, None | Some(CastTy::FnPtr))
2127                             | (Some(CastTy::Float), Some(CastTy::Ptr(_)))
2128                             | (Some(CastTy::Ptr(_) | CastTy::FnPtr), Some(CastTy::Float)) => {
2129                                 span_mirbug!(self, rvalue, "Invalid cast {:?} -> {:?}", ty_from, ty,)
2130                             }
2131                             (
2132                                 Some(CastTy::Int(_)),
2133                                 Some(CastTy::Int(_) | CastTy::Float | CastTy::Ptr(_)),
2134                             )
2135                             | (Some(CastTy::Float), Some(CastTy::Int(_) | CastTy::Float))
2136                             | (Some(CastTy::Ptr(_)), Some(CastTy::Int(_) | CastTy::Ptr(_)))
2137                             | (Some(CastTy::FnPtr), Some(CastTy::Int(_) | CastTy::Ptr(_))) => (),
2138                         }
2139                     }
2140                 }
2141             }
2142
2143             Rvalue::Ref(region, _borrow_kind, borrowed_place) => {
2144                 self.add_reborrow_constraint(&body, location, *region, borrowed_place);
2145             }
2146
2147             Rvalue::BinaryOp(
2148                 BinOp::Eq | BinOp::Ne | BinOp::Lt | BinOp::Le | BinOp::Gt | BinOp::Ge,
2149                 box (left, right),
2150             ) => {
2151                 self.check_operand(left, location);
2152                 self.check_operand(right, location);
2153
2154                 let ty_left = left.ty(body, tcx);
2155                 match ty_left.kind() {
2156                     // Types with regions are comparable if they have a common super-type.
2157                     ty::RawPtr(_) | ty::FnPtr(_) => {
2158                         let ty_right = right.ty(body, tcx);
2159                         let common_ty = self.infcx.next_ty_var(TypeVariableOrigin {
2160                             kind: TypeVariableOriginKind::MiscVariable,
2161                             span: body.source_info(location).span,
2162                         });
2163                         self.sub_types(
2164                             ty_left,
2165                             common_ty,
2166                             location.to_locations(),
2167                             ConstraintCategory::Boring,
2168                         )
2169                         .unwrap_or_else(|err| {
2170                             bug!("Could not equate type variable with {:?}: {:?}", ty_left, err)
2171                         });
2172                         if let Err(terr) = self.sub_types(
2173                             ty_right,
2174                             common_ty,
2175                             location.to_locations(),
2176                             ConstraintCategory::Boring,
2177                         ) {
2178                             span_mirbug!(
2179                                 self,
2180                                 rvalue,
2181                                 "unexpected comparison types {:?} and {:?} yields {:?}",
2182                                 ty_left,
2183                                 ty_right,
2184                                 terr
2185                             )
2186                         }
2187                     }
2188                     // For types with no regions we can just check that the
2189                     // both operands have the same type.
2190                     ty::Int(_) | ty::Uint(_) | ty::Bool | ty::Char | ty::Float(_)
2191                         if ty_left == right.ty(body, tcx) => {}
2192                     // Other types are compared by trait methods, not by
2193                     // `Rvalue::BinaryOp`.
2194                     _ => span_mirbug!(
2195                         self,
2196                         rvalue,
2197                         "unexpected comparison types {:?} and {:?}",
2198                         ty_left,
2199                         right.ty(body, tcx)
2200                     ),
2201                 }
2202             }
2203
2204             Rvalue::Use(operand) | Rvalue::UnaryOp(_, operand) => {
2205                 self.check_operand(operand, location);
2206             }
2207
2208             Rvalue::BinaryOp(_, box (left, right))
2209             | Rvalue::CheckedBinaryOp(_, box (left, right)) => {
2210                 self.check_operand(left, location);
2211                 self.check_operand(right, location);
2212             }
2213
2214             Rvalue::AddressOf(..)
2215             | Rvalue::ThreadLocalRef(..)
2216             | Rvalue::Len(..)
2217             | Rvalue::Discriminant(..) => {}
2218         }
2219     }
2220
2221     /// If this rvalue supports a user-given type annotation, then
2222     /// extract and return it. This represents the final type of the
2223     /// rvalue and will be unified with the inferred type.
2224     fn rvalue_user_ty(&self, rvalue: &Rvalue<'tcx>) -> Option<UserTypeAnnotationIndex> {
2225         match rvalue {
2226             Rvalue::Use(_)
2227             | Rvalue::ThreadLocalRef(_)
2228             | Rvalue::Repeat(..)
2229             | Rvalue::Ref(..)
2230             | Rvalue::AddressOf(..)
2231             | Rvalue::Len(..)
2232             | Rvalue::Cast(..)
2233             | Rvalue::ShallowInitBox(..)
2234             | Rvalue::BinaryOp(..)
2235             | Rvalue::CheckedBinaryOp(..)
2236             | Rvalue::NullaryOp(..)
2237             | Rvalue::UnaryOp(..)
2238             | Rvalue::Discriminant(..) => None,
2239
2240             Rvalue::Aggregate(aggregate, _) => match **aggregate {
2241                 AggregateKind::Adt(_, _, _, user_ty, _) => user_ty,
2242                 AggregateKind::Array(_) => None,
2243                 AggregateKind::Tuple => None,
2244                 AggregateKind::Closure(_, _) => None,
2245                 AggregateKind::Generator(_, _, _) => None,
2246             },
2247         }
2248     }
2249
2250     fn check_aggregate_rvalue(
2251         &mut self,
2252         body: &Body<'tcx>,
2253         rvalue: &Rvalue<'tcx>,
2254         aggregate_kind: &AggregateKind<'tcx>,
2255         operands: &[Operand<'tcx>],
2256         location: Location,
2257     ) {
2258         let tcx = self.tcx();
2259
2260         self.prove_aggregate_predicates(aggregate_kind, location);
2261
2262         if *aggregate_kind == AggregateKind::Tuple {
2263             // tuple rvalue field type is always the type of the op. Nothing to check here.
2264             return;
2265         }
2266
2267         for (i, operand) in operands.iter().enumerate() {
2268             let field_ty = match self.aggregate_field_ty(aggregate_kind, i, location) {
2269                 Ok(field_ty) => field_ty,
2270                 Err(FieldAccessError::OutOfRange { field_count }) => {
2271                     span_mirbug!(
2272                         self,
2273                         rvalue,
2274                         "accessed field #{} but variant only has {}",
2275                         i,
2276                         field_count
2277                     );
2278                     continue;
2279                 }
2280             };
2281             let operand_ty = operand.ty(body, tcx);
2282             let operand_ty = self.normalize(operand_ty, location);
2283
2284             if let Err(terr) = self.sub_types(
2285                 operand_ty,
2286                 field_ty,
2287                 location.to_locations(),
2288                 ConstraintCategory::Boring,
2289             ) {
2290                 span_mirbug!(
2291                     self,
2292                     rvalue,
2293                     "{:?} is not a subtype of {:?}: {:?}",
2294                     operand_ty,
2295                     field_ty,
2296                     terr
2297                 );
2298             }
2299         }
2300     }
2301
2302     /// Adds the constraints that arise from a borrow expression `&'a P` at the location `L`.
2303     ///
2304     /// # Parameters
2305     ///
2306     /// - `location`: the location `L` where the borrow expression occurs
2307     /// - `borrow_region`: the region `'a` associated with the borrow
2308     /// - `borrowed_place`: the place `P` being borrowed
2309     fn add_reborrow_constraint(
2310         &mut self,
2311         body: &Body<'tcx>,
2312         location: Location,
2313         borrow_region: ty::Region<'tcx>,
2314         borrowed_place: &Place<'tcx>,
2315     ) {
2316         // These constraints are only meaningful during borrowck:
2317         let BorrowCheckContext { borrow_set, location_table, all_facts, constraints, .. } =
2318             self.borrowck_context;
2319
2320         // In Polonius mode, we also push a `loan_issued_at` fact
2321         // linking the loan to the region (in some cases, though,
2322         // there is no loan associated with this borrow expression --
2323         // that occurs when we are borrowing an unsafe place, for
2324         // example).
2325         if let Some(all_facts) = all_facts {
2326             let _prof_timer = self.infcx.tcx.prof.generic_activity("polonius_fact_generation");
2327             if let Some(borrow_index) = borrow_set.get_index_of(&location) {
2328                 let region_vid = borrow_region.to_region_vid();
2329                 all_facts.loan_issued_at.push((
2330                     region_vid,
2331                     borrow_index,
2332                     location_table.mid_index(location),
2333                 ));
2334             }
2335         }
2336
2337         // If we are reborrowing the referent of another reference, we
2338         // need to add outlives relationships. In a case like `&mut
2339         // *p`, where the `p` has type `&'b mut Foo`, for example, we
2340         // need to ensure that `'b: 'a`.
2341
2342         debug!(
2343             "add_reborrow_constraint({:?}, {:?}, {:?})",
2344             location, borrow_region, borrowed_place
2345         );
2346
2347         let mut cursor = borrowed_place.projection.as_ref();
2348         let tcx = self.infcx.tcx;
2349         let field = path_utils::is_upvar_field_projection(
2350             tcx,
2351             &self.borrowck_context.upvars,
2352             borrowed_place.as_ref(),
2353             body,
2354         );
2355         let category = if let Some(field) = field {
2356             ConstraintCategory::ClosureUpvar(field)
2357         } else {
2358             ConstraintCategory::Boring
2359         };
2360
2361         while let [proj_base @ .., elem] = cursor {
2362             cursor = proj_base;
2363
2364             debug!("add_reborrow_constraint - iteration {:?}", elem);
2365
2366             match elem {
2367                 ProjectionElem::Deref => {
2368                     let base_ty = Place::ty_from(borrowed_place.local, proj_base, body, tcx).ty;
2369
2370                     debug!("add_reborrow_constraint - base_ty = {:?}", base_ty);
2371                     match base_ty.kind() {
2372                         ty::Ref(ref_region, _, mutbl) => {
2373                             constraints.outlives_constraints.push(OutlivesConstraint {
2374                                 sup: ref_region.to_region_vid(),
2375                                 sub: borrow_region.to_region_vid(),
2376                                 locations: location.to_locations(),
2377                                 span: location.to_locations().span(body),
2378                                 category,
2379                                 variance_info: ty::VarianceDiagInfo::default(),
2380                             });
2381
2382                             match mutbl {
2383                                 hir::Mutability::Not => {
2384                                     // Immutable reference. We don't need the base
2385                                     // to be valid for the entire lifetime of
2386                                     // the borrow.
2387                                     break;
2388                                 }
2389                                 hir::Mutability::Mut => {
2390                                     // Mutable reference. We *do* need the base
2391                                     // to be valid, because after the base becomes
2392                                     // invalid, someone else can use our mutable deref.
2393
2394                                     // This is in order to make the following function
2395                                     // illegal:
2396                                     // ```
2397                                     // fn unsafe_deref<'a, 'b>(x: &'a &'b mut T) -> &'b mut T {
2398                                     //     &mut *x
2399                                     // }
2400                                     // ```
2401                                     //
2402                                     // As otherwise you could clone `&mut T` using the
2403                                     // following function:
2404                                     // ```
2405                                     // fn bad(x: &mut T) -> (&mut T, &mut T) {
2406                                     //     let my_clone = unsafe_deref(&'a x);
2407                                     //     ENDREGION 'a;
2408                                     //     (my_clone, x)
2409                                     // }
2410                                     // ```
2411                                 }
2412                             }
2413                         }
2414                         ty::RawPtr(..) => {
2415                             // deref of raw pointer, guaranteed to be valid
2416                             break;
2417                         }
2418                         ty::Adt(def, _) if def.is_box() => {
2419                             // deref of `Box`, need the base to be valid - propagate
2420                         }
2421                         _ => bug!("unexpected deref ty {:?} in {:?}", base_ty, borrowed_place),
2422                     }
2423                 }
2424                 ProjectionElem::Field(..)
2425                 | ProjectionElem::Downcast(..)
2426                 | ProjectionElem::Index(..)
2427                 | ProjectionElem::ConstantIndex { .. }
2428                 | ProjectionElem::Subslice { .. } => {
2429                     // other field access
2430                 }
2431             }
2432         }
2433     }
2434
2435     fn prove_aggregate_predicates(
2436         &mut self,
2437         aggregate_kind: &AggregateKind<'tcx>,
2438         location: Location,
2439     ) {
2440         let tcx = self.tcx();
2441
2442         debug!(
2443             "prove_aggregate_predicates(aggregate_kind={:?}, location={:?})",
2444             aggregate_kind, location
2445         );
2446
2447         let (def_id, instantiated_predicates) = match aggregate_kind {
2448             AggregateKind::Adt(adt_did, _, substs, _, _) => {
2449                 (*adt_did, tcx.predicates_of(*adt_did).instantiate(tcx, substs))
2450             }
2451
2452             // For closures, we have some **extra requirements** we
2453             //
2454             // have to check. In particular, in their upvars and
2455             // signatures, closures often reference various regions
2456             // from the surrounding function -- we call those the
2457             // closure's free regions. When we borrow-check (and hence
2458             // region-check) closures, we may find that the closure
2459             // requires certain relationships between those free
2460             // regions. However, because those free regions refer to
2461             // portions of the CFG of their caller, the closure is not
2462             // in a position to verify those relationships. In that
2463             // case, the requirements get "propagated" to us, and so
2464             // we have to solve them here where we instantiate the
2465             // closure.
2466             //
2467             // Despite the opacity of the previous paragraph, this is
2468             // actually relatively easy to understand in terms of the
2469             // desugaring. A closure gets desugared to a struct, and
2470             // these extra requirements are basically like where
2471             // clauses on the struct.
2472             AggregateKind::Closure(def_id, substs)
2473             | AggregateKind::Generator(def_id, substs, _) => {
2474                 (*def_id, self.prove_closure_bounds(tcx, def_id.expect_local(), substs, location))
2475             }
2476
2477             AggregateKind::Array(_) | AggregateKind::Tuple => {
2478                 (CRATE_DEF_ID.to_def_id(), ty::InstantiatedPredicates::empty())
2479             }
2480         };
2481
2482         self.normalize_and_prove_instantiated_predicates(
2483             def_id,
2484             instantiated_predicates,
2485             location.to_locations(),
2486         );
2487     }
2488
2489     fn prove_closure_bounds(
2490         &mut self,
2491         tcx: TyCtxt<'tcx>,
2492         def_id: LocalDefId,
2493         substs: SubstsRef<'tcx>,
2494         location: Location,
2495     ) -> ty::InstantiatedPredicates<'tcx> {
2496         if let Some(ref closure_region_requirements) = tcx.mir_borrowck(def_id).closure_requirements
2497         {
2498             let closure_constraints = QueryRegionConstraints {
2499                 outlives: closure_region_requirements.apply_requirements(
2500                     tcx,
2501                     def_id.to_def_id(),
2502                     substs,
2503                 ),
2504
2505                 // Presently, closures never propagate member
2506                 // constraints to their parents -- they are enforced
2507                 // locally.  This is largely a non-issue as member
2508                 // constraints only come from `-> impl Trait` and
2509                 // friends which don't appear (thus far...) in
2510                 // closures.
2511                 member_constraints: vec![],
2512             };
2513
2514             let bounds_mapping = closure_constraints
2515                 .outlives
2516                 .iter()
2517                 .enumerate()
2518                 .filter_map(|(idx, constraint)| {
2519                     let ty::OutlivesPredicate(k1, r2) =
2520                         constraint.no_bound_vars().unwrap_or_else(|| {
2521                             bug!("query_constraint {:?} contained bound vars", constraint,);
2522                         });
2523
2524                     match k1.unpack() {
2525                         GenericArgKind::Lifetime(r1) => {
2526                             // constraint is r1: r2
2527                             let r1_vid = self.borrowck_context.universal_regions.to_region_vid(r1);
2528                             let r2_vid = self.borrowck_context.universal_regions.to_region_vid(r2);
2529                             let outlives_requirements =
2530                                 &closure_region_requirements.outlives_requirements[idx];
2531                             Some((
2532                                 (r1_vid, r2_vid),
2533                                 (outlives_requirements.category, outlives_requirements.blame_span),
2534                             ))
2535                         }
2536                         GenericArgKind::Type(_) | GenericArgKind::Const(_) => None,
2537                     }
2538                 })
2539                 .collect();
2540
2541             let existing = self
2542                 .borrowck_context
2543                 .constraints
2544                 .closure_bounds_mapping
2545                 .insert(location, bounds_mapping);
2546             assert!(existing.is_none(), "Multiple closures at the same location.");
2547
2548             self.push_region_constraints(
2549                 location.to_locations(),
2550                 ConstraintCategory::ClosureBounds,
2551                 &closure_constraints,
2552             );
2553         }
2554
2555         tcx.predicates_of(def_id).instantiate(tcx, substs)
2556     }
2557
2558     #[instrument(skip(self, body), level = "debug")]
2559     fn typeck_mir(&mut self, body: &Body<'tcx>) {
2560         self.last_span = body.span;
2561         debug!(?body.span);
2562
2563         for (local, local_decl) in body.local_decls.iter_enumerated() {
2564             self.check_local(&body, local, local_decl);
2565         }
2566
2567         for (block, block_data) in body.basic_blocks().iter_enumerated() {
2568             let mut location = Location { block, statement_index: 0 };
2569             for stmt in &block_data.statements {
2570                 if !stmt.source_info.span.is_dummy() {
2571                     self.last_span = stmt.source_info.span;
2572                 }
2573                 self.check_stmt(body, stmt, location);
2574                 location.statement_index += 1;
2575             }
2576
2577             self.check_terminator(&body, block_data.terminator(), location);
2578             self.check_iscleanup(&body, block_data);
2579         }
2580     }
2581 }
2582
2583 trait NormalizeLocation: fmt::Debug + Copy {
2584     fn to_locations(self) -> Locations;
2585 }
2586
2587 impl NormalizeLocation for Locations {
2588     fn to_locations(self) -> Locations {
2589         self
2590     }
2591 }
2592
2593 impl NormalizeLocation for Location {
2594     fn to_locations(self) -> Locations {
2595         Locations::Single(self)
2596     }
2597 }
2598
2599 /// Runs `infcx.instantiate_opaque_types`. Unlike other `TypeOp`s,
2600 /// this is not canonicalized - it directly affects the main `InferCtxt`
2601 /// that we use during MIR borrowchecking.
2602 #[derive(Debug)]
2603 pub(super) struct InstantiateOpaqueType<'tcx> {
2604     pub base_universe: Option<ty::UniverseIndex>,
2605     pub region_constraints: Option<RegionConstraintData<'tcx>>,
2606     pub obligations: Vec<PredicateObligation<'tcx>>,
2607 }
2608
2609 impl<'tcx> TypeOp<'tcx> for InstantiateOpaqueType<'tcx> {
2610     type Output = ();
2611     /// We use this type itself to store the information used
2612     /// when reporting errors. Since this is not a query, we don't
2613     /// re-run anything during error reporting - we just use the information
2614     /// we saved to help extract an error from the already-existing region
2615     /// constraints in our `InferCtxt`
2616     type ErrorInfo = InstantiateOpaqueType<'tcx>;
2617
2618     fn fully_perform(mut self, infcx: &InferCtxt<'_, 'tcx>) -> Fallible<TypeOpOutput<'tcx, Self>> {
2619         let (mut output, region_constraints) = scrape_region_constraints(infcx, || {
2620             Ok(InferOk { value: (), obligations: self.obligations.clone() })
2621         })?;
2622         self.region_constraints = Some(region_constraints);
2623         output.error_info = Some(self);
2624         Ok(output)
2625     }
2626 }