Merge remote-tracking branch 'origin/master' into gen

src/librustc_mir/build/expr/as_rvalue.rs

@@ -242,7 +242,7 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, '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(expr_span);
+                let cleanup = this.generator_drop_cleanup();
                 this.cfg.terminate(block, source_info, TerminatorKind::Yield {
                     value: value,
                     resume: resume,

src/librustc_mir/build/scope.rs

@@ -234,6 +234,15 @@ impl CachedBlock {
     }
 }
 
+impl DropKind {
+    fn may_panic(&self) -> bool {
+        match *self {
+            DropKind::Value { .. } => true,
+            DropKind::Storage => false
+        }
+    }
+}
+
 impl<'tcx> Scope<'tcx> {
     /// Invalidate all the cached blocks in the scope.
     ///
@@ -463,13 +472,13 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
     ///
     /// This path terminates in GeneratorDrop. Returns the start of the path.
     /// None indicates there’s no cleanup to do at this point.
-    pub fn generator_drop_cleanup(&mut self, span: Span) -> Option<BasicBlock> {
+    pub fn generator_drop_cleanup(&mut self) -> Option<BasicBlock> {
         if !self.scopes.iter().any(|scope| scope.needs_cleanup) {
             return None;
         }
 
         // Fill in the cache
-        self.diverge_cleanup_gen(span, true);
+        self.diverge_cleanup_gen(true);
 
         let src_info = self.scopes[0].source_info(self.fn_span);
         let tmp = self.get_unit_temp();
@@ -732,11 +741,11 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
     /// This path terminates in Resume. Returns the start of the path.
     /// See module comment for more details. None indicates there’s no
     /// cleanup to do at this point.
-    pub fn diverge_cleanup(&mut self, span: Span) -> Option<BasicBlock> {
-        self.diverge_cleanup_gen(span, false)
+    pub fn diverge_cleanup(&mut self) -> Option<BasicBlock> {
+        self.diverge_cleanup_gen(false)
     }
 
-    fn diverge_cleanup_gen(&mut self, span: Span, generator_drop: bool) -> Option<BasicBlock> {
+    fn diverge_cleanup_gen(&mut self, generator_drop: bool) -> Option<BasicBlock> {
         if !self.scopes.iter().any(|scope| scope.needs_cleanup) {
             return None;
         }
@@ -773,7 +782,7 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
             target = build_diverge_scope(hir.tcx(),
                                          cfg,
                                          &unit_temp,
-                                         span,
+                                         scope.extent_span,
                                          scope,
                                          target,
                                          generator_drop);
@@ -856,45 +865,43 @@ fn build_scope_drops<'tcx>(cfg: &mut CFG<'tcx>,
                            arg_count: usize,
                            generator_drop: bool)
                            -> BlockAnd<()> {
-
+    debug!("build_scope_drops({:?} -> {:?})", block, scope);
     let mut iter = scope.drops.iter().rev().peekable();
     while let Some(drop_data) = iter.next() {
         let source_info = scope.source_info(drop_data.span);
-        if let DropKind::Value { .. } = drop_data.kind {
-            // Try to find the next block with its cached block
-            // for us to diverge into in case the drop panics.
-            let on_diverge = iter.peek().iter().filter_map(|dd| {
-                match dd.kind {
-                    DropKind::Value { cached_block } => cached_block.get(generator_drop),
-                    DropKind::Storage => None
-                }
-            }).next();
-            // If there’s no `cached_block`s within current scope,
-            // we must look for one in the enclosing scope.
-            let on_diverge = on_diverge.or_else(||{
-                earlier_scopes.iter().rev().flat_map(|s| s.cached_block(generator_drop)).next()
-            });
-            let next = cfg.start_new_block();
-            cfg.terminate(block, source_info, TerminatorKind::Drop {
-                location: drop_data.location.clone(),
-                target: next,
-                unwind: on_diverge
-            });
-            block = next;
-        }
         match drop_data.kind {
-            DropKind::Value { .. } |
-            DropKind::Storage => {
-                // We do not need to emit these for generator drops
-                if generator_drop {
-                    continue
-                }
-
-                // Only temps and vars need their storage dead.
-                match drop_data.location {
-                    Lvalue::Local(index) if index.index() > arg_count => {}
-                    _ => continue
-                }
+            DropKind::Value { .. } => {
+                // Try to find the next block with its cached block
+                // for us to diverge into in case the drop panics.
+                let on_diverge = iter.peek().iter().filter_map(|dd| {
+                    match dd.kind {
+                        DropKind::Value {
+                            cached_block: CachedBlock {
+                                unwind: None,
+                                generator_drop: None,
+                            }
+                        } => {
+                            span_bug!(drop_data.span, "cached block not present?")
+                        }
+                        DropKind::Value { cached_block } => cached_block.get(generator_drop),
+                        DropKind::Storage => None
+                    }
+                }).next();
+                // If there’s no `cached_block`s within current scope,
+                // we must look for one in the enclosing scope.
+                let on_diverge = on_diverge.or_else(|| {
+                    earlier_scopes.iter().rev().flat_map(|s| s.cached_block(generator_drop)).next()
+                });
+                let next = cfg.start_new_block();
+                cfg.terminate(block, source_info, TerminatorKind::Drop {
+                    location: drop_data.location.clone(),
+                    target: next,
+                    unwind: on_diverge
+                });
+                block = next;
+            }
+            DropKind::Storage => {}
+        }
 
         // Drop the storage for both value and storage drops.
         // Only temps and vars need their storage dead.

src/librustc_mir/util/liveness.rs

@@ -65,6 +65,7 @@ impl<'tcx> Visitor<'tcx> for BlockInfoVisitor {
 
                 LvalueContext::Inspect |
                 LvalueContext::Consume |
+                LvalueContext::Validate |
 
                 // We consider drops to always be uses of locals.
                 // Drop eloboration should be run before this analysis otherwise

src/librustc_typeck/check/mod.rs

@@ -4011,7 +4011,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                     self.check_expr_coercable_to_type(&value, ty);
                 }
                 None => {
-                    struct_span_err!(self.tcx.sess, expr.span, E0624,
+                    struct_span_err!(self.tcx.sess, expr.span, E0627,
                                  "yield statement outside of generator literal").emit();
                 }
             }

src/librustc_typeck/diagnostics.rs

@@ -4649,7 +4649,7 @@ A private item was used outside of its scope.
 
 Erroneous code example:
 
-```compile_fail,E0624
+```compile_fail,E0627
 mod inner {
     pub struct Foo;
 
@@ -4774,5 +4774,5 @@ register_diagnostics! {
     E0588, // packed struct cannot transitively contain a `[repr(align)]` struct
     E0592, // duplicate definitions with name `{}`
 //  E0613, // Removed (merged with E0609)
-    E0624, // yield statement outside of generator literal
+    E0627, // yield statement outside of generator literal
 }