1 use crate::build::ForGuard::OutsideGuard;
2 use crate::build::{BlockAnd, BlockAndExtension, BlockFrame, Builder};
3 use rustc_middle::middle::region::Scope;
4 use rustc_middle::thir::*;
5 use rustc_middle::{mir::*, ty};
8 impl<'a, 'tcx> Builder<'a, 'tcx> {
9 pub(crate) fn ast_block(
11 destination: Place<'tcx>,
14 source_info: SourceInfo,
18 opt_destruction_scope,
24 } = self.thir[ast_block];
25 let expr = expr.map(|expr| &self.thir[expr]);
26 self.in_opt_scope(opt_destruction_scope.map(|de| (de, source_info)), move |this| {
27 this.in_scope((region_scope, source_info), LintLevel::Inherited, move |this| {
28 if targeted_by_break {
29 this.in_breakable_scope(None, destination, span, |this| {
30 Some(this.ast_block_stmts(
57 destination: Place<'tcx>,
58 mut block: BasicBlock,
61 expr: Option<&Expr<'tcx>>,
62 safety_mode: BlockSafety,
67 // This convoluted structure is to avoid using recursion as we walk down a list
68 // of statements. Basically, the structure we get back is something like:
70 // let x = <init> in {
72 // let y = <init> in {
79 // The let bindings are valid till the end of block so all we have to do is to pop all
80 // the let-scopes at the end.
82 // First we build all the statements in the block.
83 let mut let_scope_stack = Vec::with_capacity(8);
84 let outer_source_scope = this.source_scope;
85 let outer_in_scope_unsafe = this.in_scope_unsafe;
86 // This scope information is kept for breaking out of the parent remainder scope in case
87 // one let-else pattern matching fails.
88 // By doing so, we can be sure that even temporaries that receive extended lifetime
89 // assignments are dropped, too.
90 let mut last_remainder_scope = region_scope;
91 this.update_source_scope_for_safety_mode(span, safety_mode);
93 let source_info = this.source_info(span);
95 let Stmt { ref kind, opt_destruction_scope } = this.thir[*stmt];
97 StmtKind::Expr { scope, expr } => {
98 this.block_context.push(BlockFrame::Statement { ignores_expr_result: true });
100 block = this.in_opt_scope(
101 opt_destruction_scope.map(|de| (de, source_info)),
103 let si = (*scope, source_info);
104 this.in_scope(si, LintLevel::Inherited, |this| {
105 this.stmt_expr(block, &this.thir[*expr], Some(*scope))
115 initializer: Some(initializer),
117 else_block: Some(else_block),
119 // When lowering the statement `let <pat> = <expr> else { <else> };`,
120 // the `<else>` block is nested in the parent scope enclosing this statement.
121 // That scope is usually either the enclosing block scope,
122 // or the remainder scope of the last statement.
123 // This is to make sure that temporaries instantiated in `<expr>` are dropped
125 // In addition, even though bindings in `<pat>` only come into scope if
126 // the pattern matching passes, in the MIR building the storages for them
127 // are declared as live any way.
128 // This is similar to `let x;` statements without an initializer expression,
129 // where the value of `x` in this example may or may be assigned,
130 // because the storage for their values may not be live after all due to
131 // failure in pattern matching.
132 // For this reason, we declare those storages as live but we do not schedule
133 // any drop yet- they are scheduled later after the pattern matching.
134 // The generated MIR will have `StorageDead` whenever the control flow breaks out
135 // of the parent scope, regardless of the result of the pattern matching.
136 // However, the drops are inserted in MIR only when the control flow breaks out of
137 // the scope of the remainder scope associated with this `let .. else` statement.
138 // Pictorial explanation of the scope structure:
139 // ┌─────────────────────────────────┐
140 // │ Scope of the enclosing block, │
141 // │ or the last remainder scope │
142 // │ ┌───────────────────────────┐ │
143 // │ │ Scope for <else> block │ │
144 // │ └───────────────────────────┘ │
145 // │ ┌───────────────────────────┐ │
146 // │ │ Remainder scope of │ │
147 // │ │ this let-else statement │ │
148 // │ │ ┌─────────────────────┐ │ │
149 // │ │ │ <expr> scope │ │ │
150 // │ │ └─────────────────────┘ │ │
151 // │ │ extended temporaries in │ │
152 // │ │ <expr> lives in this │ │
154 // │ │ ┌─────────────────────┐ │ │
155 // │ │ │ Scopes for the rest │ │ │
156 // │ │ └─────────────────────┘ │ │
157 // │ └───────────────────────────┘ │
158 // └─────────────────────────────────┘
159 // Generated control flow:
160 // │ let Some(x) = y() else { return; }
162 // ┌────────▼───────┐
164 // └────────┬───────┘
165 // │ ┌────────────────┐
166 // ┌────────▼───────┐ │Drop temporaries│
167 // │Test the pattern├──────►in y() │
168 // └────────┬───────┘ │because breaking│
169 // │ │out of <expr> │
170 // ┌────────▼───────┐ │scope │
171 // │Move value into │ └───────┬────────┘
173 // └────────┬───────┘ ┌───────▼────────┐
174 // │ │Drop extended │
175 // ┌────────▼───────┐ │temporaries in │
176 // │Drop temporaries│ │<expr> because │
177 // │in y() │ │breaking out of │
178 // │because breaking│ │remainder scope │
179 // │out of <expr> │ └───────┬────────┘
181 // └────────┬───────┘ ┌───────▼────────┐
182 // │ │Enter <else> ├────────►
183 // ┌────────▼───────┐ │block │ return;
184 // │Continue... │ └────────────────┘
185 // └────────────────┘
187 let ignores_expr_result = matches!(pattern.kind, PatKind::Wild);
188 this.block_context.push(BlockFrame::Statement { ignores_expr_result });
190 // Lower the `else` block first because its parent scope is actually
191 // enclosing the rest of the `let .. else ..` parts.
192 let else_block_span = this.thir[*else_block].span;
193 // This place is not really used because this destination place
194 // should never be used to take values at the end of the failure
196 let dummy_place = this.temp(this.tcx.types.never, else_block_span);
197 let failure_entry = this.cfg.start_new_block();
200 failure_block = this.ast_block(
204 this.source_info(else_block_span),
209 this.source_info(else_block_span),
210 TerminatorKind::Unreachable,
213 // Declare the bindings, which may create a source scope.
214 let remainder_span = remainder_scope.span(this.tcx, this.region_scope_tree);
215 this.push_scope((*remainder_scope, source_info));
216 let_scope_stack.push(remainder_scope);
218 let visibility_scope =
219 Some(this.new_source_scope(remainder_span, LintLevel::Inherited, None));
221 let init = &this.thir[*initializer];
222 let initializer_span = init.span;
223 let failure = unpack!(
224 block = this.in_opt_scope(
225 opt_destruction_scope.map(|de| (de, source_info)),
227 let scope = (*init_scope, source_info);
228 this.in_scope(scope, *lint_level, |this| {
229 this.declare_bindings(
234 Some((None, initializer_span)),
236 this.visit_primary_bindings(
238 UserTypeProjections::none(),
239 &mut |this, _, _, _, node, span, _, _| {
240 this.storage_live_binding(
254 &last_remainder_scope,
261 this.cfg.goto(failure, source_info, failure_entry);
263 if let Some(source_scope) = visibility_scope {
264 this.source_scope = source_scope;
266 last_remainder_scope = *remainder_scope;
268 StmtKind::Let { init_scope, initializer: None, else_block: Some(_), .. } => {
270 init_scope.span(this.tcx, this.region_scope_tree),
271 "initializer is missing, but else block is present in this let binding",
282 let ignores_expr_result = matches!(pattern.kind, PatKind::Wild);
283 this.block_context.push(BlockFrame::Statement { ignores_expr_result });
285 // Enter the remainder scope, i.e., the bindings' destruction scope.
286 this.push_scope((*remainder_scope, source_info));
287 let_scope_stack.push(remainder_scope);
289 // Declare the bindings, which may create a source scope.
290 let remainder_span = remainder_scope.span(this.tcx, this.region_scope_tree);
292 let visibility_scope =
293 Some(this.new_source_scope(remainder_span, LintLevel::Inherited, None));
295 // Evaluate the initializer, if present.
296 if let Some(init) = initializer {
297 let init = &this.thir[*init];
298 let initializer_span = init.span;
301 block = this.in_opt_scope(
302 opt_destruction_scope.map(|de| (de, source_info)),
304 let scope = (*init_scope, source_info);
305 this.in_scope(scope, *lint_level, |this| {
306 this.declare_bindings(
311 Some((None, initializer_span)),
313 this.expr_into_pattern(block, &pattern, init)
314 // irrefutable pattern
320 let scope = (*init_scope, source_info);
321 unpack!(this.in_scope(scope, *lint_level, |this| {
322 this.declare_bindings(
332 debug!("ast_block_stmts: pattern={:?}", pattern);
333 this.visit_primary_bindings(
335 UserTypeProjections::none(),
336 &mut |this, _, _, _, node, span, _, _| {
337 this.storage_live_binding(block, node, span, OutsideGuard, true);
338 this.schedule_drop_for_binding(node, span, OutsideGuard);
343 // Enter the visibility scope, after evaluating the initializer.
344 if let Some(source_scope) = visibility_scope {
345 this.source_scope = source_scope;
347 last_remainder_scope = *remainder_scope;
351 let popped = this.block_context.pop();
352 assert!(popped.map_or(false, |bf| bf.is_statement()));
355 // Then, the block may have an optional trailing expression which is a “return” value
356 // of the block, which is stored into `destination`.
358 let destination_ty = destination.ty(&this.local_decls, tcx).ty;
359 if let Some(expr) = expr {
360 let tail_result_is_ignored =
361 destination_ty.is_unit() || this.block_context.currently_ignores_tail_results();
363 .push(BlockFrame::TailExpr { tail_result_is_ignored, span: expr.span });
365 unpack!(block = this.expr_into_dest(destination, block, expr));
366 let popped = this.block_context.pop();
368 assert!(popped.map_or(false, |bf| bf.is_tail_expr()));
370 // If a block has no trailing expression, then it is given an implicit return type.
371 // This return type is usually `()`, unless the block is diverging, in which case the
372 // return type is `!`. For the unit type, we need to actually return the unit, but in
373 // the case of `!`, no return value is required, as the block will never return.
374 // Opaque types of empty bodies also need this unit assignment, in order to infer that their
375 // type is actually unit. Otherwise there will be no defining use found in the MIR.
376 if destination_ty.is_unit() || matches!(destination_ty.kind(), ty::Opaque(..)) {
377 // We only want to assign an implicit `()` as the return value of the block if the
378 // block does not diverge. (Otherwise, we may try to assign a unit to a `!`-type.)
379 this.cfg.push_assign_unit(block, source_info, destination, this.tcx);
382 // Finally, we pop all the let scopes before exiting out from the scope of block
384 for scope in let_scope_stack.into_iter().rev() {
385 unpack!(block = this.pop_scope((*scope, source_info), block));
387 // Restore the original source scope.
388 this.source_scope = outer_source_scope;
389 this.in_scope_unsafe = outer_in_scope_unsafe;
393 /// If we are entering an unsafe block, create a new source scope
394 fn update_source_scope_for_safety_mode(&mut self, span: Span, safety_mode: BlockSafety) {
395 debug!("update_source_scope_for({:?}, {:?})", span, safety_mode);
396 let new_unsafety = match safety_mode {
397 BlockSafety::Safe => return,
398 BlockSafety::BuiltinUnsafe => Safety::BuiltinUnsafe,
399 BlockSafety::ExplicitUnsafe(hir_id) => {
400 self.in_scope_unsafe = Safety::ExplicitUnsafe(hir_id);
401 Safety::ExplicitUnsafe(hir_id)
405 self.source_scope = self.new_source_scope(span, LintLevel::Inherited, Some(new_unsafety));