1 use crate::build::matches::ArmHasGuard;
2 use crate::build::ForGuard::OutsideGuard;
3 use crate::build::{BlockAnd, BlockAndExtension, BlockFrame, Builder};
9 impl<'a, 'tcx> Builder<'a, 'tcx> {
12 destination: &Place<'tcx>,
14 ast_block: &'tcx hir::Block<'tcx>,
15 source_info: SourceInfo,
19 opt_destruction_scope,
25 } = self.hir.mirror(ast_block);
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 is a `break`-able block
30 let exit_block = this.cfg.start_new_block();
32 this.in_breakable_scope(None, exit_block, destination.clone(), |this| {
33 this.ast_block_stmts(destination, block, span, stmts, expr, safety_mode)
35 this.cfg.goto(unpack!(block_exit), source_info, exit_block);
38 this.ast_block_stmts(destination, block, span, stmts, expr, safety_mode)
46 destination: &Place<'tcx>,
47 mut block: BasicBlock,
49 stmts: Vec<StmtRef<'tcx>>,
50 expr: Option<ExprRef<'tcx>>,
51 safety_mode: BlockSafety,
55 // This convoluted structure is to avoid using recursion as we walk down a list
56 // of statements. Basically, the structure we get back is something like:
58 // let x = <init> in {
60 // let y = <init> in {
67 // The let bindings are valid till the end of block so all we have to do is to pop all
68 // the let-scopes at the end.
70 // First we build all the statements in the block.
71 let mut let_scope_stack = Vec::with_capacity(8);
72 let outer_source_scope = this.source_scope;
73 let outer_push_unsafe_count = this.push_unsafe_count;
74 let outer_unpushed_unsafe = this.unpushed_unsafe;
75 this.update_source_scope_for_safety_mode(span, safety_mode);
77 let source_info = this.source_info(span);
79 let Stmt { kind, opt_destruction_scope } = this.hir.mirror(stmt);
81 StmtKind::Expr { scope, expr } => {
82 this.block_context.push(BlockFrame::Statement { ignores_expr_result: true });
84 block = this.in_opt_scope(
85 opt_destruction_scope.map(|de| (de, source_info)),
87 let si = (scope, source_info);
88 this.in_scope(si, LintLevel::Inherited, |this| {
89 let expr = this.hir.mirror(expr);
90 this.stmt_expr(block, expr, Some(scope))
96 StmtKind::Let { remainder_scope, init_scope, pattern, initializer, lint_level } => {
97 let ignores_expr_result =
98 if let PatKind::Wild = *pattern.kind { true } else { false };
99 this.block_context.push(BlockFrame::Statement { ignores_expr_result });
101 // Enter the remainder scope, i.e., the bindings' destruction scope.
102 this.push_scope((remainder_scope, source_info));
103 let_scope_stack.push(remainder_scope);
105 // Declare the bindings, which may create a source scope.
107 remainder_scope.span(this.hir.tcx(), &this.hir.region_scope_tree);
109 let visibility_scope =
110 Some(this.new_source_scope(remainder_span, LintLevel::Inherited, None));
112 // Evaluate the initializer, if present.
113 if let Some(init) = initializer {
114 let initializer_span = init.span();
117 block = this.in_opt_scope(
118 opt_destruction_scope.map(|de| (de, source_info)),
120 let scope = (init_scope, source_info);
121 this.in_scope(scope, lint_level, |this| {
122 this.declare_bindings(
127 Some((None, initializer_span)),
129 this.expr_into_pattern(block, pattern, init)
135 let scope = (init_scope, source_info);
136 unpack!(this.in_scope(scope, lint_level, |this| {
137 this.declare_bindings(
147 debug!("ast_block_stmts: pattern={:?}", pattern);
150 UserTypeProjections::none(),
151 &mut |this, _, _, _, node, span, _, _| {
152 this.storage_live_binding(block, node, span, OutsideGuard);
153 this.schedule_drop_for_binding(node, span, OutsideGuard);
158 // Enter the visibility scope, after evaluating the initializer.
159 if let Some(source_scope) = visibility_scope {
160 this.source_scope = source_scope;
165 let popped = this.block_context.pop();
166 assert!(popped.map_or(false, |bf| bf.is_statement()));
169 // Then, the block may have an optional trailing expression which is a “return” value
170 // of the block, which is stored into `destination`.
171 let tcx = this.hir.tcx();
172 let destination_ty = destination.ty(&this.local_decls, tcx).ty;
173 if let Some(expr) = expr {
174 let tail_result_is_ignored =
175 destination_ty.is_unit() || this.block_context.currently_ignores_tail_results();
176 this.block_context.push(BlockFrame::TailExpr { tail_result_is_ignored });
178 unpack!(block = this.into(destination, block, expr));
179 let popped = this.block_context.pop();
181 assert!(popped.map_or(false, |bf| bf.is_tail_expr()));
183 // If a block has no trailing expression, then it is given an implicit return type.
184 // This return type is usually `()`, unless the block is diverging, in which case the
185 // return type is `!`. For the unit type, we need to actually return the unit, but in
186 // the case of `!`, no return value is required, as the block will never return.
187 if destination_ty.is_unit() {
188 // We only want to assign an implicit `()` as the return value of the block if the
189 // block does not diverge. (Otherwise, we may try to assign a unit to a `!`-type.)
190 this.cfg.push_assign_unit(block, source_info, destination);
193 // Finally, we pop all the let scopes before exiting out from the scope of block
195 for scope in let_scope_stack.into_iter().rev() {
196 unpack!(block = this.pop_scope((scope, source_info), block));
198 // Restore the original source scope.
199 this.source_scope = outer_source_scope;
200 this.push_unsafe_count = outer_push_unsafe_count;
201 this.unpushed_unsafe = outer_unpushed_unsafe;
205 /// If we are changing the safety mode, create a new source scope
206 fn update_source_scope_for_safety_mode(&mut self, span: Span, safety_mode: BlockSafety) {
207 debug!("update_source_scope_for({:?}, {:?})", span, safety_mode);
208 let new_unsafety = match safety_mode {
209 BlockSafety::Safe => None,
210 BlockSafety::ExplicitUnsafe(hir_id) => {
211 assert_eq!(self.push_unsafe_count, 0);
212 match self.unpushed_unsafe {
216 self.unpushed_unsafe = Safety::ExplicitUnsafe(hir_id);
217 Some(Safety::ExplicitUnsafe(hir_id))
219 BlockSafety::PushUnsafe => {
220 self.push_unsafe_count += 1;
221 Some(Safety::BuiltinUnsafe)
223 BlockSafety::PopUnsafe => {
224 self.push_unsafe_count = self
227 .unwrap_or_else(|| span_bug!(span, "unsafe count underflow"));
228 if self.push_unsafe_count == 0 { Some(self.unpushed_unsafe) } else { None }
232 if let Some(unsafety) = new_unsafety {
233 self.source_scope = self.new_source_scope(span, LintLevel::Inherited, Some(unsafety));