---

yaml
---
r: 126767
b: refs/heads/snap-stage3
c: 87ef2f3
h: refs/heads/master
i:
  126765: 18d79d0
  126763: 203dffd
  126759: 538176a
  126751: 2a0270a
v: v3

Author: treeman

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 7be8f0af0393dcdb077c2f6b1653836fd3fba235
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: e70ee120bf70d5b6195c2b355b9820a8609564cf
+refs/heads/snap-stage3: 87ef2f390b7e463ce3e64973abce02be8c7a9ceb
 refs/heads/try: 502e4c045236682e9728539dc0d2b3d0b237f55c
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/doc/intro.md

@@ -276,7 +276,7 @@ fn main() {
 
         spawn(proc() {
             let numbers = rx.recv();
-            println!("{:d}", numbers[num]);
+            println!("{:d}", numbers[num as uint]);
         })
     }
 }

branches/snap-stage3/src/libcollections/priority_queue.rs

@@ -180,6 +180,25 @@ impl<T: Ord> Default for PriorityQueue<T> {
 }
 
 impl<T: Ord> PriorityQueue<T> {
+    /// Create an empty PriorityQueue
+    pub fn new() -> PriorityQueue<T> { PriorityQueue{data: vec!(),} }
+
+    /// Create an empty PriorityQueue with capacity `capacity`
+    pub fn with_capacity(capacity: uint) -> PriorityQueue<T> {
+        PriorityQueue { data: Vec::with_capacity(capacity) }
+    }
+
+    /// Create a PriorityQueue from a vector (heapify)
+    pub fn from_vec(xs: Vec<T>) -> PriorityQueue<T> {
+        let mut q = PriorityQueue{data: xs,};
+        let mut n = q.len() / 2;
+        while n > 0 {
+            n -= 1;
+            q.siftdown(n)
+        }
+        q
+    }
+
     /// An iterator visiting all values in underlying vector, in
     /// arbitrary order.
     pub fn iter<'a>(&'a self) -> Items<'a, T> {
@@ -278,25 +297,6 @@ impl<T: Ord> PriorityQueue<T> {
         q.into_vec()
     }
 
-    /// Create an empty PriorityQueue
-    pub fn new() -> PriorityQueue<T> { PriorityQueue{data: vec!(),} }
-
-    /// Create an empty PriorityQueue with capacity `capacity`
-    pub fn with_capacity(capacity: uint) -> PriorityQueue<T> {
-        PriorityQueue { data: Vec::with_capacity(capacity) }
-    }
-
-    /// Create a PriorityQueue from a vector (heapify)
-    pub fn from_vec(xs: Vec<T>) -> PriorityQueue<T> {
-        let mut q = PriorityQueue{data: xs,};
-        let mut n = q.len() / 2;
-        while n > 0 {
-            n -= 1;
-            q.siftdown(n)
-        }
-        q
-    }
-
     // The implementations of siftup and siftdown use unsafe blocks in
     // order to move an element out of the vector (leaving behind a
     // zeroed element), shift along the others and move it back into the

branches/snap-stage3/src/librustc/middle/trans/_match.rs

@@ -892,12 +892,7 @@ fn insert_lllocals<'a>(mut bcx: &'a Block<'a>, bindings_map: &BindingsMap,
             TrByCopy(llbinding) => {
                 let llval = Load(bcx, binding_info.llmatch);
                 let datum = Datum::new(llval, binding_info.ty, Lvalue);
-                call_lifetime_start(bcx, llbinding);
                 bcx = datum.store_to(bcx, llbinding);
-                match cs {
-                    Some(cs) => bcx.fcx.schedule_lifetime_end(cs, llbinding),
-                    _ => {}
-                }
 
                 llbinding
             },
@@ -911,10 +906,7 @@ fn insert_lllocals<'a>(mut bcx: &'a Block<'a>, bindings_map: &BindingsMap,
 
         let datum = Datum::new(llval, binding_info.ty, Lvalue);
         match cs {
-            Some(cs) => {
-                bcx.fcx.schedule_drop_and_zero_mem(cs, llval, binding_info.ty);
-                bcx.fcx.schedule_lifetime_end(cs, binding_info.llmatch);
-            }
+            Some(cs) => bcx.fcx.schedule_drop_and_zero_mem(cs, llval, binding_info.ty),
             _ => {}
         }
 
@@ -953,17 +945,9 @@ fn compile_guard<'a, 'b>(
     let val = unpack_datum!(bcx, expr::trans(bcx, guard_expr));
     let val = val.to_llbool(bcx);
 
-    for (_, &binding_info) in data.bindings_map.iter() {
-        match binding_info.trmode {
-            TrByCopy(llbinding) => call_lifetime_end(bcx, llbinding),
-            _ => {}
-        }
-    }
-
     return with_cond(bcx, Not(bcx, val), |bcx| {
         // Guard does not match: remove all bindings from the lllocals table
         for (_, &binding_info) in data.bindings_map.iter() {
-            call_lifetime_end(bcx, binding_info.llmatch);
             bcx.fcx.lllocals.borrow_mut().remove(&binding_info.id);
         }
         match chk {
@@ -1004,7 +988,6 @@ fn compile_submatch<'a, 'b>(
         let data = &m[0].data;
         for &(ref ident, ref value_ptr) in m[0].bound_ptrs.iter() {
             let llmatch = data.bindings_map.get(ident).llmatch;
-            call_lifetime_start(bcx, llmatch);
             Store(bcx, *value_ptr, llmatch);
         }
         match data.arm.guard {
@@ -1311,24 +1294,24 @@ fn create_bindings_map(bcx: &Block, pat: Gc<ast::Pat>) -> BindingsMap {
         match bm {
             ast::BindByValue(_)
                 if !ty::type_moves_by_default(tcx, variable_ty) => {
-                llmatch = alloca_no_lifetime(bcx,
+                llmatch = alloca(bcx,
                                  llvariable_ty.ptr_to(),
                                  "__llmatch");
-                trmode = TrByCopy(alloca_no_lifetime(bcx,
+                trmode = TrByCopy(alloca(bcx,
                                          llvariable_ty,
                                          bcx.ident(ident).as_slice()));
             }
             ast::BindByValue(_) => {
                 // in this case, the final type of the variable will be T,
                 // but during matching we need to store a *T as explained
                 // above
-                llmatch = alloca_no_lifetime(bcx,
+                llmatch = alloca(bcx,
                                  llvariable_ty.ptr_to(),
                                  bcx.ident(ident).as_slice());
                 trmode = TrByMove;
             }
             ast::BindByRef(_) => {
-                llmatch = alloca_no_lifetime(bcx,
+                llmatch = alloca(bcx,
                                  llvariable_ty,
                                  bcx.ident(ident).as_slice());
                 trmode = TrByRef;

branches/snap-stage3/src/librustc/middle/trans/base.rs

@@ -1169,32 +1169,25 @@ pub fn alloc_ty(bcx: &Block, t: ty::t, name: &str) -> ValueRef {
 }
 
 pub fn alloca(cx: &Block, ty: Type, name: &str) -> ValueRef {
-    let p = alloca_no_lifetime(cx, ty, name);
-    call_lifetime_start(cx, p);
-    p
+    alloca_maybe_zeroed(cx, ty, name, false)
 }
 
-pub fn alloca_no_lifetime(cx: &Block, ty: Type, name: &str) -> ValueRef {
+pub fn alloca_maybe_zeroed(cx: &Block, ty: Type, name: &str, zero: bool) -> ValueRef {
     let _icx = push_ctxt("alloca");
     if cx.unreachable.get() {
         unsafe {
             return llvm::LLVMGetUndef(ty.ptr_to().to_ref());
         }
     }
     debuginfo::clear_source_location(cx.fcx);
-    Alloca(cx, ty, name)
-}
-
-pub fn alloca_zeroed(cx: &Block, ty: Type, name: &str) -> ValueRef {
-    if cx.unreachable.get() {
-        unsafe {
-            return llvm::LLVMGetUndef(ty.ptr_to().to_ref());
-        }
+    let p = Alloca(cx, ty, name);
+    if zero {
+        let b = cx.fcx.ccx.builder();
+        b.position_before(cx.fcx.alloca_insert_pt.get().unwrap());
+        memzero(&b, p, ty);
+    } else {
+        call_lifetime_start(cx, p);
     }
-    let p = alloca_no_lifetime(cx, ty, name);
-    let b = cx.fcx.ccx.builder();
-    b.position_before(cx.fcx.alloca_insert_pt.get().unwrap());
-    memzero(&b, p, ty);
     p
 }
 

branches/snap-stage3/src/librustc/middle/trans/datum.rs

@@ -120,11 +120,7 @@ pub fn lvalue_scratch_datum<'a, A>(bcx: &'a Block<'a>,
      */
 
     let llty = type_of::type_of(bcx.ccx(), ty);
-    let scratch = if zero {
-        alloca_zeroed(bcx, llty, name)
-    } else {
-        alloca(bcx, llty, name)
-    };
+    let scratch = alloca_maybe_zeroed(bcx, llty, name, zero);
 
     // Subtle. Populate the scratch memory *before* scheduling cleanup.
     let bcx = populate(arg, bcx, scratch);
@@ -149,7 +145,7 @@ pub fn rvalue_scratch_datum(bcx: &Block,
      */
 
     let llty = type_of::type_of(bcx.ccx(), ty);
-    let scratch = alloca(bcx, llty, name);
+    let scratch = alloca_maybe_zeroed(bcx, llty, name, false);
     Datum::new(scratch, ty, Rvalue::new(ByRef))
 }