---

yaml
---
r: 150829
b: refs/heads/try2
c: 349d66a
h: refs/heads/master
i:
  150827: ded25ae
v: v3

Author: bors

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: c18c9284b352f3605553343cd78c7a8eb75b5cd2
+refs/heads/try2: 349d66af9420eeeeedfc648eb6ec3fd28015d4b3
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/doc/guide-unsafe.md

@@ -70,7 +70,7 @@ use std::cast;
 let mut x: u8 = 1;
 
 let ref_1: &mut u8 = &mut x;
-let ref_2: &mut u8 = unsafe { cast::transmute_mut_region(ref_1) };
+let ref_2: &mut u8 = unsafe { cast::transmute_mut_lifetime(ref_1) };
 
 // oops, ref_1 and ref_2 point to the same piece of data (x) and are
 // both usable

branches/try2/src/libarena/lib.rs

@@ -26,7 +26,7 @@
 
 extern crate collections;
 
-use std::cast::{transmute, transmute_mut, transmute_mut_region};
+use std::cast::{transmute, transmute_mut, transmute_mut_lifetime};
 use std::cast;
 use std::cell::{Cell, RefCell};
 use std::mem;
@@ -186,7 +186,7 @@ impl Arena {
     #[inline]
     fn alloc_copy_inner(&mut self, n_bytes: uint, align: uint) -> *u8 {
         unsafe {
-            let this = transmute_mut_region(self);
+            let this = transmute_mut_lifetime(self);
             let start = round_up(this.copy_head.fill.get(), align);
             let end = start + n_bytes;
             if end > self.chunk_size() {
@@ -233,7 +233,7 @@ impl Arena {
             let after_tydesc;
 
             {
-                let head = transmute_mut_region(&mut self.head);
+                let head = transmute_mut_lifetime(&mut self.head);
 
                 tydesc_start = head.fill.get();
                 after_tydesc = head.fill.get() + mem::size_of::<*TyDesc>();
@@ -245,7 +245,7 @@ impl Arena {
                 return self.alloc_noncopy_grow(n_bytes, align);
             }
 
-            let head = transmute_mut_region(&mut self.head);
+            let head = transmute_mut_lifetime(&mut self.head);
             head.fill.set(round_up(end, mem::pref_align_of::<*TyDesc>()));
 
             //debug!("idx = {}, size = {}, align = {}, fill = {}",

branches/try2/src/libgreen/sched.rs

@@ -630,7 +630,7 @@ impl Scheduler {
         unsafe {
 
             let sched: &mut Scheduler =
-                cast::transmute_mut_region(*next_task.sched.get_mut_ref());
+                cast::transmute_mut_lifetime(*next_task.sched.get_mut_ref());
 
             let current_task: &mut GreenTask = match sched.cleanup_job {
                 Some(CleanupJob { task: ref mut task, .. }) => &mut **task,
@@ -681,8 +681,8 @@ impl Scheduler {
         let next_task_context =
                 &mut next_task.coroutine.get_mut_ref().saved_context;
         unsafe {
-            (cast::transmute_mut_region(current_task_context),
-             cast::transmute_mut_region(next_task_context))
+            (cast::transmute_mut_lifetime(current_task_context),
+             cast::transmute_mut_lifetime(next_task_context))
         }
     }
 

branches/try2/src/librustc/middle/trans/base.rs

@@ -936,7 +936,7 @@ pub fn init_local<'a>(bcx: &'a Block<'a>, local: &ast::Local)
         // Handle let _ = e; just like e;
         match local.init {
             Some(init) => {
-              return expr::trans_into(bcx, init, expr::Ignore);
+                return controlflow::trans_stmt_semi(bcx, init)
             }
             None => { return bcx; }
         }

branches/try2/src/librustc/middle/trans/controlflow.rs

@@ -19,6 +19,7 @@ use middle::trans::debuginfo;
 use middle::trans::cleanup;
 use middle::trans::cleanup::CleanupMethods;
 use middle::trans::expr;
+use middle::ty;
 use util::ppaux::Repr;
 
 use middle::trans::type_::Type;
@@ -49,7 +50,7 @@ pub fn trans_stmt<'a>(cx: &'a Block<'a>,
 
     match s.node {
         ast::StmtExpr(e, _) | ast::StmtSemi(e, _) => {
-            bcx = expr::trans_into(cx, e, expr::Ignore);
+            bcx = trans_stmt_semi(bcx, e);
         }
         ast::StmtDecl(d, _) => {
             match d.node {
@@ -71,6 +72,16 @@ pub fn trans_stmt<'a>(cx: &'a Block<'a>,
     return bcx;
 }
 
+pub fn trans_stmt_semi<'a>(cx: &'a Block<'a>, e: &ast::Expr) -> &'a Block<'a> {
+    let _icx = push_ctxt("trans_stmt_semi");
+    let ty = expr_ty(cx, e);
+    if ty::type_needs_drop(cx.tcx(), ty) {
+        expr::trans_to_lvalue(cx, e, "stmt").bcx
+    } else {
+        expr::trans_into(cx, e, expr::Ignore)
+    }
+}
+
 pub fn trans_block<'a>(bcx: &'a Block<'a>,
                        b: &ast::Block,
                        mut dest: expr::Dest)

branches/try2/src/libstd/cast.rs

@@ -63,9 +63,9 @@ pub unsafe fn transmute<L, G>(thing: L) -> G {
 #[inline]
 pub unsafe fn transmute_mut<'a,T>(ptr: &'a T) -> &'a mut T { transmute(ptr) }
 
-/// Coerce a reference to have an arbitrary associated region.
+/// Coerce a reference to have an arbitrary associated lifetime.
 #[inline]
-pub unsafe fn transmute_region<'a,'b,T>(ptr: &'a T) -> &'b T {
+pub unsafe fn transmute_lifetime<'a,'b,T>(ptr: &'a T) -> &'b T {
     transmute(ptr)
 }
 
@@ -75,28 +75,28 @@ pub unsafe fn transmute_mut_unsafe<T>(ptr: *T) -> *mut T {
     transmute(ptr)
 }
 
-/// Coerce a mutable reference to have an arbitrary associated region.
+/// Coerce a mutable reference to have an arbitrary associated lifetime.
 #[inline]
-pub unsafe fn transmute_mut_region<'a,'b,T>(ptr: &'a mut T) -> &'b mut T {
+pub unsafe fn transmute_mut_lifetime<'a,'b,T>(ptr: &'a mut T) -> &'b mut T {
     transmute(ptr)
 }
 
 /// Transforms lifetime of the second pointer to match the first.
 #[inline]
 pub unsafe fn copy_lifetime<'a,S,T>(_ptr: &'a S, ptr: &T) -> &'a T {
-    transmute_region(ptr)
+    transmute_lifetime(ptr)
 }
 
 /// Transforms lifetime of the second pointer to match the first.
 #[inline]
 pub unsafe fn copy_mut_lifetime<'a,S,T>(_ptr: &'a mut S, ptr: &mut T) -> &'a mut T {
-    transmute_mut_region(ptr)
+    transmute_mut_lifetime(ptr)
 }
 
 /// Transforms lifetime of the second pointer to match the first.
 #[inline]
 pub unsafe fn copy_lifetime_vec<'a,S,T>(_ptr: &'a [S], ptr: &T) -> &'a T {
-    transmute_region(ptr)
+    transmute_lifetime(ptr)
 }
 
 

branches/try2/src/test/run-pass/issue-4734.rs

@@ -0,0 +1,44 @@
+// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Ensures that destructors are run for expressions of the form "e;" where
+// `e` is a type which requires a destructor.
+
+#![allow(path_statement)]
+
+struct A { n: int }
+struct B;
+
+static mut NUM_DROPS: uint = 0;
+
+impl Drop for A {
+    fn drop(&mut self) {
+        unsafe { NUM_DROPS += 1; }
+    }
+}
+
+impl Drop for B {
+    fn drop(&mut self) {
+        unsafe { NUM_DROPS += 1; }
+    }
+}
+
+fn main() {
+    assert_eq!(unsafe { NUM_DROPS }, 0);
+    { let _a = A { n: 1 }; }
+    assert_eq!(unsafe { NUM_DROPS }, 1);
+    { A { n: 3 }; }
+    assert_eq!(unsafe { NUM_DROPS }, 2);
+
+    { let _b = B; }
+    assert_eq!(unsafe { NUM_DROPS }, 3);
+    { B; }
+    assert_eq!(unsafe { NUM_DROPS }, 4);
+}

branches/try2/src/test/run-pass/issue-6892.rs

@@ -0,0 +1,52 @@
+// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Ensures that destructors are run for expressions of the form "let _ = e;"
+// where `e` is a type which requires a destructor.
+
+struct Foo;
+struct Bar { x: int }
+struct Baz(int);
+
+static mut NUM_DROPS: uint = 0;
+
+impl Drop for Foo {
+    fn drop(&mut self) {
+        unsafe { NUM_DROPS += 1; }
+    }
+}
+impl Drop for Bar {
+    fn drop(&mut self) {
+        unsafe { NUM_DROPS += 1; }
+    }
+}
+impl Drop for Baz {
+    fn drop(&mut self) {
+        unsafe { NUM_DROPS += 1; }
+    }
+}
+
+fn main() {
+    assert_eq!(unsafe { NUM_DROPS }, 0);
+    { let _x = Foo; }
+    assert_eq!(unsafe { NUM_DROPS }, 1);
+    { let _x = Bar { x: 21 }; }
+    assert_eq!(unsafe { NUM_DROPS }, 2);
+    { let _x = Baz(21); }
+    assert_eq!(unsafe { NUM_DROPS }, 3);
+
+    assert_eq!(unsafe { NUM_DROPS }, 3);
+    { let _ = Foo; }
+    assert_eq!(unsafe { NUM_DROPS }, 4);
+    { let _ = Bar { x: 21 }; }
+    assert_eq!(unsafe { NUM_DROPS }, 5);
+    { let _ = Baz(21); }
+    assert_eq!(unsafe { NUM_DROPS }, 6);
+}