Extended fn pop_scope to accept SourceInfo with the extent argument.

Author: pnkfelix

src/librustc_mir/build/block.rs

@@ -58,7 +58,7 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
                         }));
 
                         if let Some(de) = opt_destruction_extent {
-                            unpack!(block = this.pop_scope(de, block));
+                            unpack!(block = this.pop_scope((de, source_info), block));
                         }
                     }
                     StmtKind::Let { remainder_scope, init_scope, pattern, initializer } => {
@@ -87,7 +87,7 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
                             }));
 
                             if let Some(de) = opt_destruction_extent {
-                                unpack!(block = this.pop_scope(de, block));
+                                unpack!(block = this.pop_scope((de, source_info), block));
                             }
                         } else {
                             this.storage_live_for_bindings(block, &pattern);
@@ -111,7 +111,7 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
             // Finally, we pop all the let scopes before exiting out from the scope of block
             // itself.
             for (extent, source_info) in let_extent_stack.into_iter().rev() {
-                unpack!(block = this.pop_scope(extent, block));
+                unpack!(block = this.pop_scope((extent, source_info), block));
                 if this.seen_borrows.contains(&extent) {
                     this.cfg.push_end_region(block, source_info, extent);
                 }
@@ -122,7 +122,7 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
         });
 
         if let Some(de) = opt_destruction_extent {
-            self.pop_scope(de, unpack!(block_and))
+            self.pop_scope((de, source_info), unpack!(block_and))
         } else {
             block_and
         }

src/librustc_mir/build/scope.rs

@@ -282,7 +282,7 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
         debug!("in_scope(extent={:?}, block={:?})", extent, block);
         self.push_scope(extent.0);
         let rv = unpack!(block = f(self));
-        unpack!(block = self.pop_scope(extent.0, block));
+        unpack!(block = self.pop_scope(extent, block));
         if self.seen_borrows.contains(&extent.0) {
             self.cfg.push_end_region(block, extent.1, extent.0);
         }
@@ -311,15 +311,15 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
     /// drops onto the end of `block` that are needed.  This must
     /// match 1-to-1 with `push_scope`.
     pub(crate) fn pop_scope(&mut self,
-                     extent: CodeExtent,
+                     extent: (CodeExtent, SourceInfo),
                      mut block: BasicBlock)
                      -> BlockAnd<()> {
         debug!("pop_scope({:?}, {:?})", extent, block);
         // We need to have `cached_block`s available for all the drops, so we call diverge_cleanup
         // to make sure all the `cached_block`s are filled in.
         self.diverge_cleanup();
         let scope = self.scopes.pop().unwrap();
-        assert_eq!(scope.extent, extent);
+        assert_eq!(scope.extent, extent.0);
         unpack!(block = build_scope_drops(&mut self.cfg,
                                           &scope,
                                           &self.scopes,