src/librustc_mir_build/build/mod.rs

   1 use crate::build;
   2 use crate::build::scope::DropKind;
   3 use crate::hair::cx::Cx;
   4 use crate::hair::{BindingMode, LintLevel, PatKind};
   5 use rustc_attr::{self as attr, UnwindAttr};
   6 use rustc_errors::ErrorReported;
   7 use rustc_hir as hir;
   8 use rustc_hir::def_id::DefId;
   9 use rustc_hir::lang_items;
  10 use rustc_hir::{GeneratorKind, HirIdMap, Node};
  11 use rustc_index::vec::{Idx, IndexVec};
  12 use rustc_infer::infer::TyCtxtInferExt;
  13 use rustc_middle::middle::region;
  14 use rustc_middle::mir::*;
  15 use rustc_middle::ty::subst::Subst;
  16 use rustc_middle::ty::{self, Ty, TyCtxt, TypeFoldable};
  17 use rustc_span::symbol::kw;
  18 use rustc_span::Span;
  19 use rustc_target::spec::abi::Abi;
  20 use rustc_target::spec::PanicStrategy;
  21
  22 use super::lints;
  23
  24 crate fn mir_built(tcx: TyCtxt<'_>, def_id: DefId) -> &ty::steal::Steal<Body<'_>> {
  25     tcx.alloc_steal_mir(mir_build(tcx, def_id))
  26 }
  27
  28 /// Construct the MIR for a given `DefId`.
  29 fn mir_build(tcx: TyCtxt<'_>, def_id: DefId) -> Body<'_> {
  30     let id = tcx.hir().as_local_hir_id(def_id).unwrap();
  31
  32     // Figure out what primary body this item has.
  33     let (body_id, return_ty_span) = match tcx.hir().get(id) {
  34         Node::Expr(hir::Expr { kind: hir::ExprKind::Closure(_, decl, body_id, _, _), .. }) => {
  35             (*body_id, decl.output.span())
  36         }
  37         Node::Item(hir::Item {
  38             kind: hir::ItemKind::Fn(hir::FnSig { decl, .. }, _, body_id),
  39             ..
  40         })
  41         | Node::ImplItem(hir::ImplItem {
  42             kind: hir::ImplItemKind::Fn(hir::FnSig { decl, .. }, body_id),
  43             ..
  44         })
  45         | Node::TraitItem(hir::TraitItem {
  46             kind: hir::TraitItemKind::Fn(hir::FnSig { decl, .. }, hir::TraitFn::Provided(body_id)),
  47             ..
  48         }) => (*body_id, decl.output.span()),
  49         Node::Item(hir::Item {
  50             kind: hir::ItemKind::Static(ty, _, body_id) | hir::ItemKind::Const(ty, body_id),
  51             ..
  52         })
  53         | Node::ImplItem(hir::ImplItem { kind: hir::ImplItemKind::Const(ty, body_id), .. })
  54         | Node::TraitItem(hir::TraitItem {
  55             kind: hir::TraitItemKind::Const(ty, Some(body_id)),
  56             ..
  57         }) => (*body_id, ty.span),
  58         Node::AnonConst(hir::AnonConst { body, hir_id, .. }) => (*body, tcx.hir().span(*hir_id)),
  59
  60         _ => span_bug!(tcx.hir().span(id), "can't build MIR for {:?}", def_id),
  61     };
  62
  63     tcx.infer_ctxt().enter(|infcx| {
  64         let cx = Cx::new(&infcx, id);
  65         let body = if let Some(ErrorReported) = cx.tables().tainted_by_errors {
  66             build::construct_error(cx, body_id)
  67         } else if cx.body_owner_kind.is_fn_or_closure() {
  68             // fetch the fully liberated fn signature (that is, all bound
  69             // types/lifetimes replaced)
  70             let fn_sig = cx.tables().liberated_fn_sigs()[id];
  71             let fn_def_id = tcx.hir().local_def_id(id);
  72
  73             let safety = match fn_sig.unsafety {
  74                 hir::Unsafety::Normal => Safety::Safe,
  75                 hir::Unsafety::Unsafe => Safety::FnUnsafe,
  76             };
  77
  78             let body = tcx.hir().body(body_id);
  79             let ty = tcx.type_of(fn_def_id);
  80             let mut abi = fn_sig.abi;
  81             let implicit_argument = match ty.kind {
  82                 ty::Closure(..) => {
  83                     // HACK(eddyb) Avoid having RustCall on closures,
  84                     // as it adds unnecessary (and wrong) auto-tupling.
  85                     abi = Abi::Rust;
  86                     vec![ArgInfo(liberated_closure_env_ty(tcx, id, body_id), None, None, None)]
  87                 }
  88                 ty::Generator(..) => {
  89                     let gen_ty = tcx.body_tables(body_id).node_type(id);
  90
  91                     // The resume argument may be missing, in that case we need to provide it here.
  92                     // It will always be `()` in this case.
  93                     if body.params.is_empty() {
  94                         vec![
  95                             ArgInfo(gen_ty, None, None, None),
  96                             ArgInfo(tcx.mk_unit(), None, None, None),
  97                         ]
  98                     } else {
  99                         vec![ArgInfo(gen_ty, None, None, None)]
 100                     }
 101                 }
 102                 _ => vec![],
 103             };
 104
 105             let explicit_arguments = body.params.iter().enumerate().map(|(index, arg)| {
 106                 let owner_id = tcx.hir().body_owner(body_id);
 107                 let opt_ty_info;
 108                 let self_arg;
 109                 if let Some(ref fn_decl) = tcx.hir().fn_decl_by_hir_id(owner_id) {
 110                     opt_ty_info = fn_decl.inputs.get(index).map(|ty| ty.span);
 111                     self_arg = if index == 0 && fn_decl.implicit_self.has_implicit_self() {
 112                         match fn_decl.implicit_self {
 113                             hir::ImplicitSelfKind::Imm => Some(ImplicitSelfKind::Imm),
 114                             hir::ImplicitSelfKind::Mut => Some(ImplicitSelfKind::Mut),
 115                             hir::ImplicitSelfKind::ImmRef => Some(ImplicitSelfKind::ImmRef),
 116                             hir::ImplicitSelfKind::MutRef => Some(ImplicitSelfKind::MutRef),
 117                             _ => None,
 118                         }
 119                     } else {
 120                         None
 121                     };
 122                 } else {
 123                     opt_ty_info = None;
 124                     self_arg = None;
 125                 }
 126
 127                 // C-variadic fns also have a `VaList` input that's not listed in `fn_sig`
 128                 // (as it's created inside the body itself, not passed in from outside).
 129                 let ty = if fn_sig.c_variadic && index == fn_sig.inputs().len() {
 130                     let va_list_did =
 131                         tcx.require_lang_item(lang_items::VaListTypeLangItem, Some(arg.span));
 132
 133                     tcx.type_of(va_list_did).subst(tcx, &[tcx.lifetimes.re_erased.into()])
 134                 } else {
 135                     fn_sig.inputs()[index]
 136                 };
 137
 138                 ArgInfo(ty, opt_ty_info, Some(&arg), self_arg)
 139             });
 140
 141             let arguments = implicit_argument.into_iter().chain(explicit_arguments);
 142
 143             let (yield_ty, return_ty) = if body.generator_kind.is_some() {
 144                 let gen_ty = tcx.body_tables(body_id).node_type(id);
 145                 let gen_sig = match gen_ty.kind {
 146                     ty::Generator(_, gen_substs, ..) => gen_substs.as_generator().sig(),
 147                     _ => span_bug!(tcx.hir().span(id), "generator w/o generator type: {:?}", ty),
 148                 };
 149                 (Some(gen_sig.yield_ty), gen_sig.return_ty)
 150             } else {
 151                 (None, fn_sig.output())
 152             };
 153
 154             let mut mir = build::construct_fn(
 155                 cx,
 156                 id,
 157                 arguments,
 158                 safety,
 159                 abi,
 160                 return_ty,
 161                 return_ty_span,
 162                 body,
 163             );
 164             mir.yield_ty = yield_ty;
 165             mir
 166         } else {
 167             // Get the revealed type of this const. This is *not* the adjusted
 168             // type of its body, which may be a subtype of this type. For
 169             // example:
 170             //
 171             // fn foo(_: &()) {}
 172             // static X: fn(&'static ()) = foo;
 173             //
 174             // The adjusted type of the body of X is `for<'a> fn(&'a ())` which
 175             // is not the same as the type of X. We need the type of the return
 176             // place to be the type of the constant because NLL typeck will
 177             // equate them.
 178
 179             let return_ty = cx.tables().node_type(id);
 180
 181             build::construct_const(cx, body_id, return_ty, return_ty_span)
 182         };
 183
 184         lints::check(tcx, &body, def_id);
 185
 186         // The borrow checker will replace all the regions here with its own
 187         // inference variables. There's no point having non-erased regions here.
 188         // The exception is `body.user_type_annotations`, which is used unmodified
 189         // by borrow checking.
 190         debug_assert!(
 191             !(body.local_decls.has_free_regions()
 192                 || body.basic_blocks().has_free_regions()
 193                 || body.var_debug_info.has_free_regions()
 194                 || body.yield_ty.has_free_regions()),
 195             "Unexpected free regions in MIR: {:?}",
 196             body,
 197         );
 198
 199         body
 200     })
 201 }
 202
 203 ///////////////////////////////////////////////////////////////////////////
 204 // BuildMir -- walks a crate, looking for fn items and methods to build MIR from
 205
 206 fn liberated_closure_env_ty(
 207     tcx: TyCtxt<'_>,
 208     closure_expr_id: hir::HirId,
 209     body_id: hir::BodyId,
 210 ) -> Ty<'_> {
 211     let closure_ty = tcx.body_tables(body_id).node_type(closure_expr_id);
 212
 213     let (closure_def_id, closure_substs) = match closure_ty.kind {
 214         ty::Closure(closure_def_id, closure_substs) => (closure_def_id, closure_substs),
 215         _ => bug!("closure expr does not have closure type: {:?}", closure_ty),
 216     };
 217
 218     let closure_env_ty = tcx.closure_env_ty(closure_def_id, closure_substs).unwrap();
 219     tcx.erase_late_bound_regions(&closure_env_ty)
 220 }
 221
 222 #[derive(Debug, PartialEq, Eq)]
 223 enum BlockFrame {
 224     /// Evaluation is currently within a statement.
 225     ///
 226     /// Examples include:
 227     /// 1. `EXPR;`
 228     /// 2. `let _ = EXPR;`
 229     /// 3. `let x = EXPR;`
 230     Statement {
 231         /// If true, then statement discards result from evaluating
 232         /// the expression (such as examples 1 and 2 above).
 233         ignores_expr_result: bool,
 234     },
 235
 236     /// Evaluation is currently within the tail expression of a block.
 237     ///
 238     /// Example: `{ STMT_1; STMT_2; EXPR }`
 239     TailExpr {
 240         /// If true, then the surrounding context of the block ignores
 241         /// the result of evaluating the block's tail expression.
 242         ///
 243         /// Example: `let _ = { STMT_1; EXPR };`
 244         tail_result_is_ignored: bool,
 245     },
 246
 247     /// Generic mark meaning that the block occurred as a subexpression
 248     /// where the result might be used.
 249     ///
 250     /// Examples: `foo(EXPR)`, `match EXPR { ... }`
 251     SubExpr,
 252 }
 253
 254 impl BlockFrame {
 255     fn is_tail_expr(&self) -> bool {
 256         match *self {
 257             BlockFrame::TailExpr { .. } => true,
 258
 259             BlockFrame::Statement { .. } | BlockFrame::SubExpr => false,
 260         }
 261     }
 262     fn is_statement(&self) -> bool {
 263         match *self {
 264             BlockFrame::Statement { .. } => true,
 265
 266             BlockFrame::TailExpr { .. } | BlockFrame::SubExpr => false,
 267         }
 268     }
 269 }
 270
 271 #[derive(Debug)]
 272 struct BlockContext(Vec<BlockFrame>);
 273
 274 struct Builder<'a, 'tcx> {
 275     hir: Cx<'a, 'tcx>,
 276     cfg: CFG<'tcx>,
 277
 278     fn_span: Span,
 279     arg_count: usize,
 280     generator_kind: Option<GeneratorKind>,
 281
 282     /// The current set of scopes, updated as we traverse;
 283     /// see the `scope` module for more details.
 284     scopes: scope::Scopes<'tcx>,
 285
 286     /// The block-context: each time we build the code within an hair::Block,
 287     /// we push a frame here tracking whether we are building a statement or
 288     /// if we are pushing the tail expression of the block. This is used to
 289     /// embed information in generated temps about whether they were created
 290     /// for a block tail expression or not.
 291     ///
 292     /// It would be great if we could fold this into `self.scopes`
 293     /// somehow, but right now I think that is very tightly tied to
 294     /// the code generation in ways that we cannot (or should not)
 295     /// start just throwing new entries onto that vector in order to
 296     /// distinguish the context of EXPR1 from the context of EXPR2 in
 297     /// `{ STMTS; EXPR1 } + EXPR2`.
 298     block_context: BlockContext,
 299
 300     /// The current unsafe block in scope, even if it is hidden by
 301     /// a `PushUnsafeBlock`.
 302     unpushed_unsafe: Safety,
 303
 304     /// The number of `push_unsafe_block` levels in scope.
 305     push_unsafe_count: usize,
 306
 307     /// The vector of all scopes that we have created thus far;
 308     /// we track this for debuginfo later.
 309     source_scopes: IndexVec<SourceScope, SourceScopeData>,
 310     source_scope: SourceScope,
 311
 312     /// The guard-context: each time we build the guard expression for
 313     /// a match arm, we push onto this stack, and then pop when we
 314     /// finish building it.
 315     guard_context: Vec<GuardFrame>,
 316
 317     /// Maps `HirId`s of variable bindings to the `Local`s created for them.
 318     /// (A match binding can have two locals; the 2nd is for the arm's guard.)
 319     var_indices: HirIdMap<LocalsForNode>,
 320     local_decls: IndexVec<Local, LocalDecl<'tcx>>,
 321     canonical_user_type_annotations: ty::CanonicalUserTypeAnnotations<'tcx>,
 322     upvar_mutbls: Vec<Mutability>,
 323     unit_temp: Option<Place<'tcx>>,
 324
 325     var_debug_info: Vec<VarDebugInfo<'tcx>>,
 326
 327     /// Cached block with the `RESUME` terminator; this is created
 328     /// when first set of cleanups are built.
 329     cached_resume_block: Option<BasicBlock>,
 330     /// Cached block with the `RETURN` terminator.
 331     cached_return_block: Option<BasicBlock>,
 332     /// Cached block with the `UNREACHABLE` terminator.
 333     cached_unreachable_block: Option<BasicBlock>,
 334 }
 335
 336 impl<'a, 'tcx> Builder<'a, 'tcx> {
 337     fn is_bound_var_in_guard(&self, id: hir::HirId) -> bool {
 338         self.guard_context.iter().any(|frame| frame.locals.iter().any(|local| local.id == id))
 339     }
 340
 341     fn var_local_id(&self, id: hir::HirId, for_guard: ForGuard) -> Local {
 342         self.var_indices[&id].local_id(for_guard)
 343     }
 344 }
 345
 346 impl BlockContext {
 347     fn new() -> Self {
 348         BlockContext(vec![])
 349     }
 350     fn push(&mut self, bf: BlockFrame) {
 351         self.0.push(bf);
 352     }
 353     fn pop(&mut self) -> Option<BlockFrame> {
 354         self.0.pop()
 355     }
 356
 357     /// Traverses the frames on the `BlockContext`, searching for either
 358     /// the first block-tail expression frame with no intervening
 359     /// statement frame.
 360     ///
 361     /// Notably, this skips over `SubExpr` frames; this method is
 362     /// meant to be used in the context of understanding the
 363     /// relationship of a temp (created within some complicated
 364     /// expression) with its containing expression, and whether the
 365     /// value of that *containing expression* (not the temp!) is
 366     /// ignored.
 367     fn currently_in_block_tail(&self) -> Option<BlockTailInfo> {
 368         for bf in self.0.iter().rev() {
 369             match bf {
 370                 BlockFrame::SubExpr => continue,
 371                 BlockFrame::Statement { .. } => break,
 372                 &BlockFrame::TailExpr { tail_result_is_ignored } => {
 373                     return Some(BlockTailInfo { tail_result_is_ignored });
 374                 }
 375             }
 376         }
 377
 378         None
 379     }
 380
 381     /// Looks at the topmost frame on the BlockContext and reports
 382     /// whether its one that would discard a block tail result.
 383     ///
 384     /// Unlike `currently_within_ignored_tail_expression`, this does
 385     /// *not* skip over `SubExpr` frames: here, we want to know
 386     /// whether the block result itself is discarded.
 387     fn currently_ignores_tail_results(&self) -> bool {
 388         match self.0.last() {
 389             // no context: conservatively assume result is read
 390             None => false,
 391
 392             // sub-expression: block result feeds into some computation
 393             Some(BlockFrame::SubExpr) => false,
 394
 395             // otherwise: use accumulated is_ignored state.
 396             Some(
 397                 BlockFrame::TailExpr { tail_result_is_ignored: ignored }
 398                 | BlockFrame::Statement { ignores_expr_result: ignored },
 399             ) => *ignored,
 400         }
 401     }
 402 }
 403
 404 #[derive(Debug)]
 405 enum LocalsForNode {
 406     /// In the usual case, a `HirId` for an identifier maps to at most
 407     /// one `Local` declaration.
 408     One(Local),
 409
 410     /// The exceptional case is identifiers in a match arm's pattern
 411     /// that are referenced in a guard of that match arm. For these,
 412     /// we have `2` Locals.
 413     ///
 414     /// * `for_arm_body` is the Local used in the arm body (which is
 415     ///   just like the `One` case above),
 416     ///
 417     /// * `ref_for_guard` is the Local used in the arm's guard (which
 418     ///   is a reference to a temp that is an alias of
 419     ///   `for_arm_body`).
 420     ForGuard { ref_for_guard: Local, for_arm_body: Local },
 421 }
 422
 423 #[derive(Debug)]
 424 struct GuardFrameLocal {
 425     id: hir::HirId,
 426 }
 427
 428 impl GuardFrameLocal {
 429     fn new(id: hir::HirId, _binding_mode: BindingMode) -> Self {
 430         GuardFrameLocal { id }
 431     }
 432 }
 433
 434 #[derive(Debug)]
 435 struct GuardFrame {
 436     /// These are the id's of names that are bound by patterns of the
 437     /// arm of *this* guard.
 438     ///
 439     /// (Frames higher up the stack will have the id's bound in arms
 440     /// further out, such as in a case like:
 441     ///
 442     /// match E1 {
 443     ///      P1(id1) if (... (match E2 { P2(id2) if ... => B2 })) => B1,
 444     /// }
 445     ///
 446     /// here, when building for FIXME.
 447     locals: Vec<GuardFrameLocal>,
 448 }
 449
 450 /// `ForGuard` indicates whether we are talking about:
 451 ///   1. The variable for use outside of guard expressions, or
 452 ///   2. The temp that holds reference to (1.), which is actually what the
 453 ///      guard expressions see.
 454 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 455 enum ForGuard {
 456     RefWithinGuard,
 457     OutsideGuard,
 458 }
 459
 460 impl LocalsForNode {
 461     fn local_id(&self, for_guard: ForGuard) -> Local {
 462         match (self, for_guard) {
 463             (&LocalsForNode::One(local_id), ForGuard::OutsideGuard)
 464             | (
 465                 &LocalsForNode::ForGuard { ref_for_guard: local_id, .. },
 466                 ForGuard::RefWithinGuard,
 467             )
 468             | (&LocalsForNode::ForGuard { for_arm_body: local_id, .. }, ForGuard::OutsideGuard) => {
 469                 local_id
 470             }
 471
 472             (&LocalsForNode::One(_), ForGuard::RefWithinGuard) => {
 473                 bug!("anything with one local should never be within a guard.")
 474             }
 475         }
 476     }
 477 }
 478
 479 struct CFG<'tcx> {
 480     basic_blocks: IndexVec<BasicBlock, BasicBlockData<'tcx>>,
 481 }
 482
 483 rustc_index::newtype_index! {
 484     struct ScopeId { .. }
 485 }
 486
 487 ///////////////////////////////////////////////////////////////////////////
 488 /// The `BlockAnd` "monad" packages up the new basic block along with a
 489 /// produced value (sometimes just unit, of course). The `unpack!`
 490 /// macro (and methods below) makes working with `BlockAnd` much more
 491 /// convenient.
 492
 493 #[must_use = "if you don't use one of these results, you're leaving a dangling edge"]
 494 struct BlockAnd<T>(BasicBlock, T);
 495
 496 trait BlockAndExtension {
 497     fn and<T>(self, v: T) -> BlockAnd<T>;
 498     fn unit(self) -> BlockAnd<()>;
 499 }
 500
 501 impl BlockAndExtension for BasicBlock {
 502     fn and<T>(self, v: T) -> BlockAnd<T> {
 503         BlockAnd(self, v)
 504     }
 505
 506     fn unit(self) -> BlockAnd<()> {
 507         BlockAnd(self, ())
 508     }
 509 }
 510
 511 /// Update a block pointer and return the value.
 512 /// Use it like `let x = unpack!(block = self.foo(block, foo))`.
 513 macro_rules! unpack {
 514     ($x:ident = $c:expr) => {{
 515         let BlockAnd(b, v) = $c;
 516         $x = b;
 517         v
 518     }};
 519
 520     ($c:expr) => {{
 521         let BlockAnd(b, ()) = $c;
 522         b
 523     }};
 524 }
 525
 526 fn should_abort_on_panic(tcx: TyCtxt<'_>, fn_def_id: DefId, _abi: Abi) -> bool {
 527     // Validate `#[unwind]` syntax regardless of platform-specific panic strategy.
 528     let attrs = &tcx.get_attrs(fn_def_id);
 529     let unwind_attr = attr::find_unwind_attr(Some(tcx.sess.diagnostic()), attrs);
 530
 531     // We never unwind, so it's not relevant to stop an unwind.
 532     if tcx.sess.panic_strategy() != PanicStrategy::Unwind {
 533         return false;
 534     }
 535
 536     // We cannot add landing pads, so don't add one.
 537     if tcx.sess.no_landing_pads() {
 538         return false;
 539     }
 540
 541     // This is a special case: some functions have a C abi but are meant to
 542     // unwind anyway. Don't stop them.
 543     match unwind_attr {
 544         None => false, // FIXME(#58794); should be `!(abi == Abi::Rust || abi == Abi::RustCall)`
 545         Some(UnwindAttr::Allowed) => false,
 546         Some(UnwindAttr::Aborts) => true,
 547     }
 548 }
 549
 550 ///////////////////////////////////////////////////////////////////////////
 551 /// the main entry point for building MIR for a function
 552
 553 struct ArgInfo<'tcx>(
 554     Ty<'tcx>,
 555     Option<Span>,
 556     Option<&'tcx hir::Param<'tcx>>,
 557     Option<ImplicitSelfKind>,
 558 );
 559
 560 fn construct_fn<'a, 'tcx, A>(
 561     hir: Cx<'a, 'tcx>,
 562     fn_id: hir::HirId,
 563     arguments: A,
 564     safety: Safety,
 565     abi: Abi,
 566     return_ty: Ty<'tcx>,
 567     return_ty_span: Span,
 568     body: &'tcx hir::Body<'tcx>,
 569 ) -> Body<'tcx>
 570 where
 571     A: Iterator<Item = ArgInfo<'tcx>>,
 572 {
 573     let arguments: Vec<_> = arguments.collect();
 574
 575     let tcx = hir.tcx();
 576     let tcx_hir = tcx.hir();
 577     let span = tcx_hir.span(fn_id);
 578
 579     let fn_def_id = tcx_hir.local_def_id(fn_id);
 580
 581     let mut builder = Builder::new(
 582         hir,
 583         span,
 584         arguments.len(),
 585         safety,
 586         return_ty,
 587         return_ty_span,
 588         body.generator_kind,
 589     );
 590
 591     let call_site_scope =
 592         region::Scope { id: body.value.hir_id.local_id, data: region::ScopeData::CallSite };
 593     let arg_scope =
 594         region::Scope { id: body.value.hir_id.local_id, data: region::ScopeData::Arguments };
 595     let mut block = START_BLOCK;
 596     let source_info = builder.source_info(span);
 597     let call_site_s = (call_site_scope, source_info);
 598     unpack!(
 599         block = builder.in_scope(call_site_s, LintLevel::Inherited, |builder| {
 600             if should_abort_on_panic(tcx, fn_def_id, abi) {
 601                 builder.schedule_abort();
 602             }
 603
 604             let arg_scope_s = (arg_scope, source_info);
 605             // `return_block` is called when we evaluate a `return` expression, so
 606             // we just use `START_BLOCK` here.
 607             unpack!(
 608                 block = builder.in_breakable_scope(
 609                     None,
 610                     START_BLOCK,
 611                     Place::return_place(),
 612                     |builder| {
 613                         builder.in_scope(arg_scope_s, LintLevel::Inherited, |builder| {
 614                             builder.args_and_body(
 615                                 block,
 616                                 fn_def_id,
 617                                 &arguments,
 618                                 arg_scope,
 619                                 &body.value,
 620                             )
 621                         })
 622                     },
 623                 )
 624             );
 625             // Attribute epilogue to function's closing brace
 626             let fn_end = span.shrink_to_hi();
 627             let source_info = builder.source_info(fn_end);
 628             let return_block = builder.return_block();
 629             builder.cfg.goto(block, source_info, return_block);
 630             builder.cfg.terminate(return_block, source_info, TerminatorKind::Return);
 631             // Attribute any unreachable codepaths to the function's closing brace
 632             if let Some(unreachable_block) = builder.cached_unreachable_block {
 633                 builder.cfg.terminate(unreachable_block, source_info, TerminatorKind::Unreachable);
 634             }
 635             return_block.unit()
 636         })
 637     );
 638     assert_eq!(block, builder.return_block());
 639
 640     let spread_arg = if abi == Abi::RustCall {
 641         // RustCall pseudo-ABI untuples the last argument.
 642         Some(Local::new(arguments.len()))
 643     } else {
 644         None
 645     };
 646     debug!("fn_id {:?} has attrs {:?}", fn_def_id, tcx.get_attrs(fn_def_id));
 647
 648     let mut body = builder.finish();
 649     body.spread_arg = spread_arg;
 650     body
 651 }
 652
 653 fn construct_const<'a, 'tcx>(
 654     hir: Cx<'a, 'tcx>,
 655     body_id: hir::BodyId,
 656     const_ty: Ty<'tcx>,
 657     const_ty_span: Span,
 658 ) -> Body<'tcx> {
 659     let tcx = hir.tcx();
 660     let owner_id = tcx.hir().body_owner(body_id);
 661     let span = tcx.hir().span(owner_id);
 662     let mut builder = Builder::new(hir, span, 0, Safety::Safe, const_ty, const_ty_span, None);
 663
 664     let mut block = START_BLOCK;
 665     let ast_expr = &tcx.hir().body(body_id).value;
 666     let expr = builder.hir.mirror(ast_expr);
 667     unpack!(block = builder.into_expr(Place::return_place(), block, expr));
 668
 669     let source_info = builder.source_info(span);
 670     builder.cfg.terminate(block, source_info, TerminatorKind::Return);
 671
 672     // Constants can't `return` so a return block should not be created.
 673     assert_eq!(builder.cached_return_block, None);
 674
 675     // Constants may be match expressions in which case an unreachable block may
 676     // be created, so terminate it properly.
 677     if let Some(unreachable_block) = builder.cached_unreachable_block {
 678         builder.cfg.terminate(unreachable_block, source_info, TerminatorKind::Unreachable);
 679     }
 680
 681     builder.finish()
 682 }
 683
 684 /// Construct MIR for a item that has had errors in type checking.
 685 ///
 686 /// This is required because we may still want to run MIR passes on an item
 687 /// with type errors, but normal MIR construction can't handle that in general.
 688 fn construct_error<'a, 'tcx>(hir: Cx<'a, 'tcx>, body_id: hir::BodyId) -> Body<'tcx> {
 689     let tcx = hir.tcx();
 690     let owner_id = tcx.hir().body_owner(body_id);
 691     let span = tcx.hir().span(owner_id);
 692     let ty = tcx.types.err;
 693     let num_params = match hir.body_owner_kind {
 694         hir::BodyOwnerKind::Fn => tcx.hir().fn_decl_by_hir_id(owner_id).unwrap().inputs.len(),
 695         hir::BodyOwnerKind::Closure => {
 696             if tcx.hir().body(body_id).generator_kind().is_some() {
 697                 // Generators have an implicit `self` parameter *and* a possibly
 698                 // implicit resume parameter.
 699                 2
 700             } else {
 701                 // The implicit self parameter adds another local in MIR.
 702                 1 + tcx.hir().fn_decl_by_hir_id(owner_id).unwrap().inputs.len()
 703             }
 704         }
 705         hir::BodyOwnerKind::Const => 0,
 706         hir::BodyOwnerKind::Static(_) => 0,
 707     };
 708     let mut builder = Builder::new(hir, span, num_params, Safety::Safe, ty, span, None);
 709     let source_info = builder.source_info(span);
 710     // Some MIR passes will expect the number of parameters to match the
 711     // function declaration.
 712     for _ in 0..num_params {
 713         builder.local_decls.push(LocalDecl {
 714             mutability: Mutability::Mut,
 715             ty,
 716             user_ty: UserTypeProjections::none(),
 717             source_info,
 718             internal: false,
 719             local_info: LocalInfo::Other,
 720             is_block_tail: None,
 721         });
 722     }
 723     builder.cfg.terminate(START_BLOCK, source_info, TerminatorKind::Unreachable);
 724     let mut body = builder.finish();
 725     if tcx.hir().body(body_id).generator_kind.is_some() {
 726         body.yield_ty = Some(ty);
 727     }
 728     body
 729 }
 730
 731 impl<'a, 'tcx> Builder<'a, 'tcx> {
 732     fn new(
 733         hir: Cx<'a, 'tcx>,
 734         span: Span,
 735         arg_count: usize,
 736         safety: Safety,
 737         return_ty: Ty<'tcx>,
 738         return_span: Span,
 739         generator_kind: Option<GeneratorKind>,
 740     ) -> Builder<'a, 'tcx> {
 741         let lint_level = LintLevel::Explicit(hir.root_lint_level);
 742         let mut builder = Builder {
 743             hir,
 744             cfg: CFG { basic_blocks: IndexVec::new() },
 745             fn_span: span,
 746             arg_count,
 747             generator_kind,
 748             scopes: Default::default(),
 749             block_context: BlockContext::new(),
 750             source_scopes: IndexVec::new(),
 751             source_scope: OUTERMOST_SOURCE_SCOPE,
 752             guard_context: vec![],
 753             push_unsafe_count: 0,
 754             unpushed_unsafe: safety,
 755             local_decls: IndexVec::from_elem_n(
 756                 LocalDecl::new_return_place(return_ty, return_span),
 757                 1,
 758             ),
 759             canonical_user_type_annotations: IndexVec::new(),
 760             upvar_mutbls: vec![],
 761             var_indices: Default::default(),
 762             unit_temp: None,
 763             var_debug_info: vec![],
 764             cached_resume_block: None,
 765             cached_return_block: None,
 766             cached_unreachable_block: None,
 767         };
 768
 769         assert_eq!(builder.cfg.start_new_block(), START_BLOCK);
 770         assert_eq!(
 771             builder.new_source_scope(span, lint_level, Some(safety)),
 772             OUTERMOST_SOURCE_SCOPE
 773         );
 774         builder.source_scopes[OUTERMOST_SOURCE_SCOPE].parent_scope = None;
 775
 776         builder
 777     }
 778
 779     fn finish(self) -> Body<'tcx> {
 780         for (index, block) in self.cfg.basic_blocks.iter().enumerate() {
 781             if block.terminator.is_none() {
 782                 span_bug!(self.fn_span, "no terminator on block {:?}", index);
 783             }
 784         }
 785
 786         Body::new(
 787             self.cfg.basic_blocks,
 788             self.source_scopes,
 789             self.local_decls,
 790             self.canonical_user_type_annotations,
 791             self.arg_count,
 792             self.var_debug_info,
 793             self.fn_span,
 794             self.hir.control_flow_destroyed(),
 795             self.generator_kind,
 796         )
 797     }
 798
 799     fn args_and_body(
 800         &mut self,
 801         mut block: BasicBlock,
 802         fn_def_id: DefId,
 803         arguments: &[ArgInfo<'tcx>],
 804         argument_scope: region::Scope,
 805         ast_body: &'tcx hir::Expr<'tcx>,
 806     ) -> BlockAnd<()> {
 807         // Allocate locals for the function arguments
 808         for &ArgInfo(ty, _, arg_opt, _) in arguments.iter() {
 809             let source_info = SourceInfo {
 810                 scope: OUTERMOST_SOURCE_SCOPE,
 811                 span: arg_opt.map_or(self.fn_span, |arg| arg.pat.span),
 812             };
 813             let arg_local = self.local_decls.push(LocalDecl {
 814                 mutability: Mutability::Mut,
 815                 ty,
 816                 user_ty: UserTypeProjections::none(),
 817                 source_info,
 818                 internal: false,
 819                 local_info: LocalInfo::Other,
 820                 is_block_tail: None,
 821             });
 822
 823             // If this is a simple binding pattern, give debuginfo a nice name.
 824             if let Some(arg) = arg_opt {
 825                 if let Some(ident) = arg.pat.simple_ident() {
 826                     self.var_debug_info.push(VarDebugInfo {
 827                         name: ident.name,
 828                         source_info,
 829                         place: arg_local.into(),
 830                     });
 831                 }
 832             }
 833         }
 834
 835         let tcx = self.hir.tcx();
 836         let tcx_hir = tcx.hir();
 837         let hir_tables = self.hir.tables();
 838
 839         // In analyze_closure() in upvar.rs we gathered a list of upvars used by a
 840         // closure and we stored in a map called upvar_list in TypeckTables indexed
 841         // with the closure's DefId. Here, we run through that vec of UpvarIds for
 842         // the given closure and use the necessary information to create upvar
 843         // debuginfo and to fill `self.upvar_mutbls`.
 844         if let Some(upvars) = hir_tables.upvar_list.get(&fn_def_id) {
 845             let closure_env_arg = Local::new(1);
 846             let mut closure_env_projs = vec![];
 847             let mut closure_ty = self.local_decls[closure_env_arg].ty;
 848             if let ty::Ref(_, ty, _) = closure_ty.kind {
 849                 closure_env_projs.push(ProjectionElem::Deref);
 850                 closure_ty = ty;
 851             }
 852             let upvar_substs = match closure_ty.kind {
 853                 ty::Closure(_, substs) => ty::UpvarSubsts::Closure(substs),
 854                 ty::Generator(_, substs, _) => ty::UpvarSubsts::Generator(substs),
 855                 _ => span_bug!(self.fn_span, "upvars with non-closure env ty {:?}", closure_ty),
 856             };
 857             let upvar_tys = upvar_substs.upvar_tys();
 858             let upvars_with_tys = upvars.iter().zip(upvar_tys);
 859             self.upvar_mutbls = upvars_with_tys
 860                 .enumerate()
 861                 .map(|(i, ((&var_id, &upvar_id), ty))| {
 862                     let capture = hir_tables.upvar_capture(upvar_id);
 863
 864                     let mut mutability = Mutability::Not;
 865                     let mut name = kw::Invalid;
 866                     if let Some(Node::Binding(pat)) = tcx_hir.find(var_id) {
 867                         if let hir::PatKind::Binding(_, _, ident, _) = pat.kind {
 868                             name = ident.name;
 869                             match hir_tables.extract_binding_mode(tcx.sess, pat.hir_id, pat.span) {
 870                                 Some(ty::BindByValue(hir::Mutability::Mut)) => {
 871                                     mutability = Mutability::Mut;
 872                                 }
 873                                 Some(_) => mutability = Mutability::Not,
 874                                 _ => {}
 875                             }
 876                         }
 877                     }
 878
 879                     let mut projs = closure_env_projs.clone();
 880                     projs.push(ProjectionElem::Field(Field::new(i), ty));
 881                     match capture {
 882                         ty::UpvarCapture::ByValue => {}
 883                         ty::UpvarCapture::ByRef(..) => {
 884                             projs.push(ProjectionElem::Deref);
 885                         }
 886                     };
 887
 888                     self.var_debug_info.push(VarDebugInfo {
 889                         name,
 890                         source_info: SourceInfo {
 891                             scope: OUTERMOST_SOURCE_SCOPE,
 892                             span: tcx_hir.span(var_id),
 893                         },
 894                         place: Place {
 895                             local: closure_env_arg,
 896                             projection: tcx.intern_place_elems(&projs),
 897                         },
 898                     });
 899
 900                     mutability
 901                 })
 902                 .collect();
 903         }
 904
 905         let mut scope = None;
 906         // Bind the argument patterns
 907         for (index, arg_info) in arguments.iter().enumerate() {
 908             // Function arguments always get the first Local indices after the return place
 909             let local = Local::new(index + 1);
 910             let place = Place::from(local);
 911             let &ArgInfo(_, opt_ty_info, arg_opt, ref self_binding) = arg_info;
 912
 913             // Make sure we drop (parts of) the argument even when not matched on.
 914             self.schedule_drop(
 915                 arg_opt.as_ref().map_or(ast_body.span, |arg| arg.pat.span),
 916                 argument_scope,
 917                 local,
 918                 DropKind::Value,
 919             );
 920
 921             if let Some(arg) = arg_opt {
 922                 let pattern = self.hir.pattern_from_hir(&arg.pat);
 923                 let original_source_scope = self.source_scope;
 924                 let span = pattern.span;
 925                 self.set_correct_source_scope_for_arg(arg.hir_id, original_source_scope, span);
 926                 match *pattern.kind {
 927                     // Don't introduce extra copies for simple bindings
 928                     PatKind::Binding {
 929                         mutability,
 930                         var,
 931                         mode: BindingMode::ByValue,
 932                         subpattern: None,
 933                         ..
 934                     } => {
 935                         self.local_decls[local].mutability = mutability;
 936                         self.local_decls[local].source_info.scope = self.source_scope;
 937                         self.local_decls[local].local_info = if let Some(kind) = self_binding {
 938                             LocalInfo::User(ClearCrossCrate::Set(BindingForm::ImplicitSelf(*kind)))
 939                         } else {
 940                             let binding_mode = ty::BindingMode::BindByValue(mutability);
 941                             LocalInfo::User(ClearCrossCrate::Set(BindingForm::Var(
 942                                 VarBindingForm {
 943                                     binding_mode,
 944                                     opt_ty_info,
 945                                     opt_match_place: Some((Some(place), span)),
 946                                     pat_span: span,
 947                                 },
 948                             )))
 949                         };
 950                         self.var_indices.insert(var, LocalsForNode::One(local));
 951                     }
 952                     _ => {
 953                         scope = self.declare_bindings(
 954                             scope,
 955                             ast_body.span,
 956                             &pattern,
 957                             matches::ArmHasGuard(false),
 958                             Some((Some(&place), span)),
 959                         );
 960                         unpack!(block = self.place_into_pattern(block, pattern, place, false));
 961                     }
 962                 }
 963                 self.source_scope = original_source_scope;
 964             }
 965         }
 966
 967         // Enter the argument pattern bindings source scope, if it exists.
 968         if let Some(source_scope) = scope {
 969             self.source_scope = source_scope;
 970         }
 971
 972         let body = self.hir.mirror(ast_body);
 973         self.into(Place::return_place(), block, body)
 974     }
 975
 976     fn set_correct_source_scope_for_arg(
 977         &mut self,
 978         arg_hir_id: hir::HirId,
 979         original_source_scope: SourceScope,
 980         pattern_span: Span,
 981     ) {
 982         let tcx = self.hir.tcx();
 983         let current_root = tcx.maybe_lint_level_root_bounded(arg_hir_id, self.hir.root_lint_level);
 984         let parent_root = tcx.maybe_lint_level_root_bounded(
 985             self.source_scopes[original_source_scope]
 986                 .local_data
 987                 .as_ref()
 988                 .assert_crate_local()
 989                 .lint_root,
 990             self.hir.root_lint_level,
 991         );
 992         if current_root != parent_root {
 993             self.source_scope =
 994                 self.new_source_scope(pattern_span, LintLevel::Explicit(current_root), None);
 995         }
 996     }
 997
 998     fn get_unit_temp(&mut self) -> Place<'tcx> {
 999         match self.unit_temp {
1000             Some(tmp) => tmp,
1001             None => {
1002                 let ty = self.hir.unit_ty();
1003                 let fn_span = self.fn_span;
1004                 let tmp = self.temp(ty, fn_span);
1005                 self.unit_temp = Some(tmp);
1006                 tmp
1007             }
1008         }
1009     }
1010
1011     fn return_block(&mut self) -> BasicBlock {
1012         match self.cached_return_block {
1013             Some(rb) => rb,
1014             None => {
1015                 let rb = self.cfg.start_new_block();
1016                 self.cached_return_block = Some(rb);
1017                 rb
1018             }
1019         }
1020     }
1021 }
1022
1023 ///////////////////////////////////////////////////////////////////////////
1024 // Builder methods are broken up into modules, depending on what kind
1025 // of thing is being lowered. Note that they use the `unpack` macro
1026 // above extensively.
1027
1028 mod block;
1029 mod cfg;
1030 mod expr;
1031 mod into;
1032 mod matches;
1033 mod misc;
1034 mod scope;