Temp: Initial impl

Author: matthewjasper

src/librustc_mir/build/block.rs

@@ -26,16 +26,19 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         self.in_opt_scope(opt_destruction_scope.map(|de|(de, source_info)), move |this| {
             this.in_scope((region_scope, source_info), LintLevel::Inherited, move |this| {
                 if targeted_by_break {
-                    // This is a `break`-able block
-                    let exit_block = this.cfg.start_new_block();
-                    let block_exit = this.in_breakable_scope(
-                        None, exit_block, destination.clone(), |this| {
-                            this.ast_block_stmts(destination, block, span, stmts, expr,
-                                                 safety_mode)
-                        });
-                    this.cfg.terminate(unpack!(block_exit), source_info,
-                                       TerminatorKind::Goto { target: exit_block });
-                    exit_block.unit()
+                    this.in_breakable_scope(
+                        None,
+                        destination.clone(),
+                        span,
+                        |this| Some(this.ast_block_stmts(
+                            destination,
+                            block,
+                            span,
+                            stmts,
+                            expr,
+                            safety_mode,
+                        )),
+                    )
                 } else {
                     this.ast_block_stmts(destination, block, span, stmts, expr,
                                          safety_mode)

src/librustc_mir/build/expr/as_rvalue.rs

@@ -257,14 +257,14 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             ExprKind::Yield { value } => {
                 let value = unpack!(block = this.as_operand(block, scope, value));
                 let resume = this.cfg.start_new_block();
-                let cleanup = this.generator_drop_cleanup();
+                this.generator_drop_cleanup(block);
                 this.cfg.terminate(
                     block,
                     source_info,
                     TerminatorKind::Yield {
                         value: value,
                         resume: resume,
-                        drop: cleanup,
+                        drop: None,
                     },
                 );
                 resume.and(this.unit_rvalue())

src/librustc_mir/build/expr/into.rs

@@ -157,7 +157,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 // body, even when the exact code in the body cannot unwind
 
                 let loop_block = this.cfg.start_new_block();
-                let exit_block = this.cfg.start_new_block();
 
                 // start the loop
                 this.cfg.terminate(
@@ -168,18 +167,18 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
                 this.in_breakable_scope(
                     Some(loop_block),
-                    exit_block,
                     destination.clone(),
+                    expr_span,
                     move |this| {
                         // conduct the test, if necessary
                         let body_block = this.cfg.start_new_block();
-                        let diverge_cleanup = this.diverge_cleanup();
+                        this.diverge_from(loop_block);
                         this.cfg.terminate(
                             loop_block,
                             source_info,
                             TerminatorKind::FalseUnwind {
                                 real_target: body_block,
-                                unwind: Some(diverge_cleanup),
+                                unwind: None,
                             },
                         );
 
@@ -193,9 +192,9 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                             source_info,
                             TerminatorKind::Goto { target: loop_block },
                         );
+                        None
                     },
-                );
-                exit_block.unit()
+                )
             }
             ExprKind::Call { ty, fun, args, from_hir_call } => {
                 let intrinsic = match ty.kind {
@@ -244,17 +243,17 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         .collect();
 
                     let success = this.cfg.start_new_block();
-                    let cleanup = this.diverge_cleanup();
 
                     this.record_operands_moved(&args);
 
+                    this.diverge_from(block);
                     this.cfg.terminate(
                         block,
                         source_info,
                         TerminatorKind::Call {
                             func: fun,
                             args,
-                            cleanup: Some(cleanup),
+                            cleanup: None,
                             // FIXME(varkor): replace this with an uninhabitedness-based check.
                             // This requires getting access to the current module to call
                             // `tcx.is_ty_uninhabited_from`, which is currently tricky to do.

src/librustc_mir/build/matches/mod.rs

@@ -12,7 +12,6 @@ use crate::build::{GuardFrame, GuardFrameLocal, LocalsForNode};
 use crate::hair::{self, *};
 use rustc::hir::HirId;
 use rustc::mir::*;
-use rustc::middle::region;
 use rustc::ty::{self, CanonicalUserTypeAnnotation, Ty};
 use rustc::ty::layout::VariantIdx;
 use rustc_index::bit_set::BitSet;
@@ -228,8 +227,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         };
 
         // Step 5. Create everything else: the guards and the arms.
-        let match_scope = self.scopes.topmost();
-
         let arm_end_blocks: Vec<_> = arm_candidates.into_iter().map(|(arm, mut candidates)| {
             let arm_source_info = self.source_info(arm.span);
             let arm_scope = (arm.scope, arm_source_info);
@@ -250,7 +247,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         arm.guard.clone(),
                         &fake_borrow_temps,
                         scrutinee_span,
-                        match_scope,
+                        //match_scope,
                     );
                 } else {
                     arm_block = this.cfg.start_new_block();
@@ -261,7 +258,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                             arm.guard.clone(),
                             &fake_borrow_temps,
                             scrutinee_span,
-                            match_scope,
+                            //match_scope,
                         );
                         this.cfg.terminate(
                             binding_end,
@@ -1353,7 +1350,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         guard: Option<Guard<'tcx>>,
         fake_borrows: &Vec<(PlaceRef<'_, 'tcx>, Local)>,
         scrutinee_span: Span,
-        region_scope: region::Scope,
+        //region_scope: region::Scope,
     ) -> BasicBlock {
         debug!("bind_and_guard_matched_candidate(candidate={:?})", candidate);
 
@@ -1524,11 +1521,10 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 });
             }
 
-            self.exit_scope(
-                source_info.span,
-                region_scope,
+            self.exit_top_scope(
                 otherwise_post_guard_block,
                 candidate.otherwise_block.unwrap(),
+                source_info,
             );
 
             // We want to ensure that the matched candidates are bound

src/librustc_mir/build/matches/test.rs

@@ -449,7 +449,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         let bool_ty = self.hir.bool_ty();
         let eq_result = self.temp(bool_ty, source_info.span);
         let eq_block = self.cfg.start_new_block();
-        let cleanup = self.diverge_cleanup();
+        self.diverge_from(block);
         self.cfg.terminate(block, source_info, TerminatorKind::Call {
             func: Operand::Constant(box Constant {
                 span: source_info.span,
@@ -464,7 +464,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             }),
             args: vec![val, expect],
             destination: Some((eq_result.clone(), eq_block)),
-            cleanup: Some(cleanup),
+            cleanup: None,
             from_hir_call: false,
         });
 

src/librustc_mir/build/mod.rs

@@ -316,11 +316,6 @@ struct Builder<'a, 'tcx> {
     upvar_mutbls: Vec<Mutability>,
     unit_temp: Option<Place<'tcx>>,
 
-    /// Cached block with the `RESUME` terminator; this is created
-    /// when first set of cleanups are built.
-    cached_resume_block: Option<BasicBlock>,
-    /// Cached block with the `RETURN` terminator.
-    cached_return_block: Option<BasicBlock>,
     /// Cached block with the `UNREACHABLE` terminator.
     cached_unreachable_block: Option<BasicBlock>,
 }
@@ -614,43 +609,32 @@ where
         id: body.value.hir_id.local_id,
         data: region::ScopeData::Arguments
     };
-    let mut block = START_BLOCK;
     let source_info = builder.source_info(span);
     let call_site_s = (call_site_scope, source_info);
-    unpack!(block = builder.in_scope(call_site_s, LintLevel::Inherited, |builder| {
-        if should_abort_on_panic(tcx, fn_def_id, abi) {
-            builder.schedule_abort();
-        }
-
+    unpack!(builder.in_scope(call_site_s, LintLevel::Inherited, |builder| {
         let arg_scope_s = (arg_scope, source_info);
-        // `return_block` is called when we evaluate a `return` expression, so
-        // we just use `START_BLOCK` here.
-        unpack!(block = builder.in_breakable_scope(
+        // Attribute epilogue to function's closing brace
+        let fn_end = span.shrink_to_hi();
+        let return_block = unpack!(builder.in_breakable_scope(
             None,
-            START_BLOCK,
             Place::return_place(),
+            fn_end,
             |builder| {
-                builder.in_scope(arg_scope_s, LintLevel::Inherited, |builder| {
-                    builder.args_and_body(block, &arguments, arg_scope, &body.value)
-                })
+                Some(builder.in_scope(arg_scope_s, LintLevel::Inherited, |builder| {
+                    builder.args_and_body(START_BLOCK, &arguments, arg_scope, &body.value)
+                }))
             },
         ));
-        // Attribute epilogue to function's closing brace
-        let fn_end = span.shrink_to_hi();
         let source_info = builder.source_info(fn_end);
-        let return_block = builder.return_block();
-        builder.cfg.terminate(block, source_info,
-                              TerminatorKind::Goto { target: return_block });
-        builder.cfg.terminate(return_block, source_info,
-                              TerminatorKind::Return);
+        builder.cfg.terminate(return_block, source_info, TerminatorKind::Return);
+        let should_abort = should_abort_on_panic(tcx, fn_def_id, abi);
+        builder.build_drop_trees(should_abort);
         // Attribute any unreachable codepaths to the function's closing brace
         if let Some(unreachable_block) = builder.cached_unreachable_block {
-            builder.cfg.terminate(unreachable_block, source_info,
-                                  TerminatorKind::Unreachable);
+            builder.cfg.terminate(unreachable_block, source_info, TerminatorKind::Unreachable);
         }
         return_block.unit()
     }));
-    assert_eq!(block, builder.return_block());
 
     let mut spread_arg = None;
     if abi == Abi::RustCall {
@@ -694,9 +678,6 @@ fn construct_const<'a, 'tcx>(
     let source_info = builder.source_info(span);
     builder.cfg.terminate(block, source_info, TerminatorKind::Return);
 
-    // Constants can't `return` so a return block should not be created.
-    assert_eq!(builder.cached_return_block, None);
-
     // Constants may be match expressions in which case an unreachable block may
     // be created, so terminate it properly.
     if let Some(unreachable_block) = builder.cached_unreachable_block {
@@ -738,7 +719,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             fn_span: span,
             arg_count,
             is_generator,
-            scopes: Default::default(),
+            scopes: scope::Scopes::new(is_generator),
             block_context: BlockContext::new(),
             source_scopes: IndexVec::new(),
             source_scope: OUTERMOST_SOURCE_SCOPE,
@@ -755,8 +736,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             upvar_mutbls,
             var_indices: Default::default(),
             unit_temp: None,
-            cached_resume_block: None,
-            cached_return_block: None,
             cached_unreachable_block: None,
         };
 
@@ -933,17 +912,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             }
         }
     }
-
-    fn return_block(&mut self) -> BasicBlock {
-        match self.cached_return_block {
-            Some(rb) => rb,
-            None => {
-                let rb = self.cfg.start_new_block();
-                self.cached_return_block = Some(rb);
-                rb
-            }
-        }
-    }
 }
 
 ///////////////////////////////////////////////////////////////////////////