---

yaml
---
r: 155135
b: refs/heads/try2
c: 946654a
h: refs/heads/master
i:
  155133: e138b30
  155131: 510e8cf
  155127: cfc4c2b
  155119: 8e9d9df
  155103: c748b25
  155071: 0d2544c
  155007: a9b5006
  154879: 42cf376
  154623: 960db48
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: eafeb335a0731b4bfcd8be6203d0d29a3668cd76
+refs/heads/try2: 946654a721d6fd5eeb91e93293cdc2cba83c78b9
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/doc/guide.md

@@ -152,7 +152,7 @@ Save the file, and then type this into your terminal window:
 
 ```{bash}
 $ rustc main.rs
-$ ./hello_world # or hello_world.exe on Windows
+$ ./main # or main.exe on Windows
 Hello, world!
 ```
 
@@ -164,7 +164,7 @@ fn main() {
 }
 ```
 
-These two lines define a **function** in Rust. The `main` function is special:
+These lines define a **function** in Rust. The `main` function is special:
 it's the beginning of every Rust program. The first line says "I'm declaring a
 function named `main`, which takes no arguments and returns nothing." If there
 were arguments, they would go inside the parentheses (`(` and `)`), and because
@@ -232,10 +232,10 @@ main.exe  main.rs
 ```
 
 There are now two files: our source code, with the `.rs` extension, and the
-executable (`hello_world.exe` on Windows, `hello_world` everywhere else)
+executable (`main.exe` on Windows, `main` everywhere else)
 
 ```{bash}
-$ ./hello_world  # or hello_world.exe on Windows
+$ ./main  # or main.exe on Windows
 ```
 
 This prints out our `Hello, world!` text to our terminal.

branches/try2/src/liballoc/heap.rs

@@ -8,11 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// FIXME: #13994: port to the sized deallocation API when available
 // FIXME: #13996: mark the `allocate` and `reallocate` return value as `noalias`
-//                and `nonnull`
 
-#[cfg(not(test))] use core::raw;
+#[cfg(stage0, not(test))] use core::raw;
 #[cfg(stage0, not(test))] use util;
 
 /// Returns a pointer to `size` bytes of memory.
@@ -88,18 +86,19 @@ pub fn stats_print() {
     imp::stats_print();
 }
 
-// The compiler never calls `exchange_free` on Box<ZeroSizeType>, so zero-size
-// allocations can point to this `static`. It would be incorrect to use a null
-// pointer, due to enums assuming types like unique pointers are never null.
-pub static mut EMPTY: uint = 12345;
+/// An arbitrary non-null address to represent zero-size allocations.
+///
+/// This preserves the non-null invariant for types like `Box<T>`. The address may overlap with
+/// non-zero-size memory allocations.
+pub static EMPTY: *mut () = 0x1 as *mut ();
 
 /// The allocator for unique pointers.
 #[cfg(not(test))]
 #[lang="exchange_malloc"]
 #[inline]
 unsafe fn exchange_malloc(size: uint, align: uint) -> *mut u8 {
     if size == 0 {
-        &EMPTY as *const uint as *mut u8
+        EMPTY as *mut u8
     } else {
         allocate(size, align)
     }
@@ -112,7 +111,6 @@ unsafe fn exchange_free(ptr: *mut u8, size: uint, align: uint) {
     deallocate(ptr, size, align);
 }
 
-// FIXME: #7496
 #[cfg(stage0, not(test))]
 #[lang="closure_exchange_malloc"]
 #[inline]
@@ -128,21 +126,6 @@ unsafe fn closure_exchange_malloc(drop_glue: fn(*mut u8), size: uint,
     alloc as *mut u8
 }
 
-// FIXME: #7496
-#[cfg(not(stage0), not(test))]
-#[lang="closure_exchange_malloc"]
-#[inline]
-#[allow(deprecated)]
-unsafe fn closure_exchange_malloc(drop_glue: fn(*mut u8), size: uint,
-                                  align: uint) -> *mut u8 {
-    let p = allocate(size, align);
-
-    let alloc = p as *mut raw::Box<()>;
-    (*alloc).drop_glue = drop_glue;
-
-    alloc as *mut u8
-}
-
 // The minimum alignment guaranteed by the architecture. This value is used to
 // add fast paths for low alignment values. In practice, the alignment is a
 // constant at the call site and the branch will be optimized out.

branches/try2/src/libcollections/enum_set.rs

@@ -14,15 +14,31 @@
 //! representation to hold C-like enum variants.
 
 use core::prelude::*;
+use core::fmt;
 
-#[deriving(Clone, PartialEq, Eq, Hash, Show)]
+#[deriving(Clone, PartialEq, Eq, Hash)]
 /// A specialized `Set` implementation to use enum types.
 pub struct EnumSet<E> {
     // We must maintain the invariant that no bits are set
     // for which no variant exists
     bits: uint
 }
 
+impl<E:CLike+fmt::Show> fmt::Show for EnumSet<E> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        try!(write!(fmt, "{{"));
+        let mut first = true;
+        for e in self.iter() {
+            if !first {
+                try!(write!(fmt, ", "));
+            }
+            try!(write!(fmt, "{}", e));
+            first = false;
+        }
+        write!(fmt, "}}")
+    }
+}
+
 /// An interface for casting C-like enum to uint and back.
 pub trait CLike {
     /// Converts a C-like enum to a `uint`.
@@ -165,6 +181,16 @@ mod test {
         assert!(e.is_empty());
     }
 
+    #[test]
+    fn test_show() {
+        let mut e = EnumSet::empty();
+        assert_eq!("{}", e.to_string().as_slice());
+        e.add(A);
+        assert_eq!("{A}", e.to_string().as_slice());
+        e.add(C);
+        assert_eq!("{A, C}", e.to_string().as_slice());
+    }
+
     ///////////////////////////////////////////////////////////////////////////
     // intersect
 

branches/try2/src/libcollections/vec.rs

@@ -14,7 +14,7 @@
 
 use core::prelude::*;
 
-use alloc::heap::{allocate, reallocate, deallocate};
+use alloc::heap::{EMPTY, allocate, reallocate, deallocate};
 use core::cmp::max;
 use core::default::Default;
 use core::fmt;
@@ -28,10 +28,6 @@ use {Mutable, MutableSeq};
 use slice::{MutableOrdSlice, MutableSliceAllocating, CloneableVector};
 use slice::{Items, MutItems};
 
-
-#[doc(hidden)]
-pub static PTR_MARKER: u8 = 0;
-
 /// An owned, growable vector.
 ///
 /// # Examples
@@ -124,7 +120,7 @@ impl<T> Vec<T> {
         // non-null value which is fine since we never call deallocate on the ptr
         // if cap is 0. The reason for this is because the pointer of a slice
         // being NULL would break the null pointer optimization for enums.
-        Vec { len: 0, cap: 0, ptr: &PTR_MARKER as *const _ as *mut T }
+        Vec { len: 0, cap: 0, ptr: EMPTY as *mut T }
     }
 
     /// Constructs a new, empty `Vec` with the specified capacity.
@@ -157,7 +153,7 @@ impl<T> Vec<T> {
     #[inline]
     pub fn with_capacity(capacity: uint) -> Vec<T> {
         if mem::size_of::<T>() == 0 {
-            Vec { len: 0, cap: uint::MAX, ptr: &PTR_MARKER as *const _ as *mut T }
+            Vec { len: 0, cap: uint::MAX, ptr: EMPTY as *mut T }
         } else if capacity == 0 {
             Vec::new()
         } else {

branches/try2/src/librustc/middle/lang_items.rs

@@ -276,7 +276,6 @@ lets_do_this! {
     BeginUnwindLangItem,             "begin_unwind",            begin_unwind;
 
     ExchangeMallocFnLangItem,        "exchange_malloc",         exchange_malloc_fn;
-    ClosureExchangeMallocFnLangItem, "closure_exchange_malloc", closure_exchange_malloc_fn;
     ExchangeFreeFnLangItem,          "exchange_free",           exchange_free_fn;
     MallocFnLangItem,                "malloc",                  malloc_fn;
     FreeFnLangItem,                  "free",                    free_fn;

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

@@ -382,14 +382,10 @@ pub fn malloc_raw_dyn<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
     Result::new(r.bcx, PointerCast(r.bcx, r.val, llty_ptr))
 }
 
-pub fn malloc_raw_dyn_proc<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
-                                       t: ty::t, alloc_fn: LangItem)
-                                       -> Result<'blk, 'tcx> {
+pub fn malloc_raw_dyn_proc<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, t: ty::t) -> Result<'blk, 'tcx> {
     let _icx = push_ctxt("malloc_raw_dyn_proc");
     let ccx = bcx.ccx();
 
-    let langcall = require_alloc_fn(bcx, t, alloc_fn);
-
     // Grab the TypeRef type of ptr_ty.
     let ptr_ty = ty::mk_uniq(bcx.tcx(), t);
     let ptr_llty = type_of(ccx, ptr_ty);
@@ -398,18 +394,15 @@ pub fn malloc_raw_dyn_proc<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
     let size = llsize_of(bcx.ccx(), llty);
     let llalign = C_uint(ccx, llalign_of_min(bcx.ccx(), llty) as uint);
 
-    // Allocate space:
-    let drop_glue = glue::get_drop_glue(ccx, ty::mk_uniq(bcx.tcx(), t));
-    let r = callee::trans_lang_call(
-        bcx,
-        langcall,
-        [
-            PointerCast(bcx, drop_glue, Type::glue_fn(ccx, Type::i8p(ccx)).ptr_to()),
-            size,
-            llalign
-        ],
-        None);
-    Result::new(r.bcx, PointerCast(r.bcx, r.val, ptr_llty))
+    // Allocate space and store the destructor pointer:
+    let Result {bcx: bcx, val: llbox} = malloc_raw_dyn(bcx, ptr_llty, t, size, llalign);
+    let dtor_ptr = GEPi(bcx, llbox, [0u, abi::box_field_drop_glue]);
+    let drop_glue_field_ty = type_of(ccx, ty::mk_nil_ptr(bcx.tcx()));
+    let drop_glue = PointerCast(bcx, glue::get_drop_glue(ccx, ty::mk_uniq(bcx.tcx(), t)),
+                                drop_glue_field_ty);
+    Store(bcx, drop_glue, dtor_ptr);
+
+    Result::new(bcx, llbox)
 }
 
 

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

@@ -15,7 +15,6 @@ use driver::config::FullDebugInfo;
 use llvm::ValueRef;
 use middle::def;
 use middle::freevars;
-use middle::lang_items::ClosureExchangeMallocFnLangItem;
 use middle::trans::adt;
 use middle::trans::base::*;
 use middle::trans::build::*;
@@ -146,7 +145,7 @@ fn allocate_cbox<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
     let cbox_ty = tuplify_box_ty(tcx, cdata_ty);
     match store {
         ty::UniqTraitStore => {
-            malloc_raw_dyn_proc(bcx, cbox_ty, ClosureExchangeMallocFnLangItem)
+            malloc_raw_dyn_proc(bcx, cbox_ty)
         }
         ty::RegionTraitStore(..) => {
             let llbox = alloc_ty(bcx, cbox_ty, "__closure");

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

@@ -519,7 +519,7 @@ fn make_drop_glue<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, v0: ValueRef, t: ty::t)
             let env_ptr_ty = Type::at_box(bcx.ccx(), Type::i8(bcx.ccx())).ptr_to();
             let env = PointerCast(bcx, env, env_ptr_ty);
             with_cond(bcx, IsNotNull(bcx, env), |bcx| {
-                let dtor_ptr = GEPi(bcx, env, [0u, abi::box_field_tydesc]);
+                let dtor_ptr = GEPi(bcx, env, [0u, abi::box_field_drop_glue]);
                 let dtor = Load(bcx, dtor_ptr);
                 Call(bcx, dtor, [PointerCast(bcx, box_cell_v, Type::i8p(bcx.ccx()))], None);
                 bcx

branches/try2/src/librustc_back/abi.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 pub static box_field_refcnt: uint = 0u;
-pub static box_field_tydesc: uint = 1u;
+pub static box_field_drop_glue: uint = 1u;
 pub static box_field_body: uint = 4u;
 
 pub static tydesc_field_visit_glue: uint = 3u;

branches/try2/src/libsyntax/owned_slice.rs

@@ -12,6 +12,7 @@ use std::fmt;
 use std::default::Default;
 use std::hash;
 use std::{mem, raw, ptr, slice, vec};
+use std::rt::heap::EMPTY;
 use serialize::{Encodable, Decodable, Encoder, Decoder};
 
 /// A non-growable owned slice. This would preferably become `~[T]`
@@ -81,10 +82,9 @@ impl<T> OwnedSlice<T> {
     }
 
     pub fn as_slice<'a>(&'a self) -> &'a [T] {
-        static PTR_MARKER: u8 = 0;
         let ptr = if self.data.is_null() {
             // length zero, i.e. this will never be read as a T.
-            &PTR_MARKER as *const u8 as *const T
+            EMPTY as *const T
         } else {
             self.data as *const T
         };

branches/try2/src/libsyntax/util/interner.rs

@@ -19,7 +19,6 @@ use std::cell::RefCell;
 use std::cmp::Equiv;
 use std::fmt;
 use std::hash::Hash;
-use std::mem;
 use std::rc::Rc;
 
 pub struct Interner<T> {
@@ -192,16 +191,6 @@ impl StrInterner {
         (*self.vect.borrow().get(idx.uint())).clone()
     }
 
-    /// Returns this string with lifetime tied to the interner. Since
-    /// strings may never be removed from the interner, this is safe.
-    pub fn get_ref<'a>(&'a self, idx: Name) -> &'a str {
-        let vect = self.vect.borrow();
-        let s: &str = vect.get(idx.uint()).as_slice();
-        unsafe {
-            mem::transmute(s)
-        }
-    }
-
     pub fn len(&self) -> uint {
         self.vect.borrow().len()
     }

branches/try2/src/snapshots.txt

@@ -1,7 +1,7 @@
 S 2014-09-10 6faa4f3
   winnt-x86_64 939eb546469cb936441cff3b6f2478f562f77c46
   winnt-i386 cfe4f8b519bb9d62588f9310a8f94bc919d5423b
-  linux-x86_64 72c92895fa9a1dba7880073f2b2b5d0e3e1a2ab6
+  linux-x86_64 40e2ab1b67d0a2859f7da15e13bfd2748b50f0c7
   linux-i386 6f5464c9ab191d93bfea0894ca7c6f90c3506f2b
   freebsd-x86_64 648f35800ba98f1121d418b6d0c13c63b7a8951b
   macos-i386 545fc45a0071142714639c6be377e6d308c3a4e1

branches/try2/src/test/compile-fail/issue-11374.rs

@@ -0,0 +1,37 @@
+// Copyright 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.
+
+use std::io;
+use std::vec;
+
+pub struct Container<'a> {
+    reader: &'a mut Reader //~ ERROR explicit lifetime bound required
+}
+
+impl<'a> Container<'a> {
+    pub fn wrap<'s>(reader: &'s mut Reader) -> Container<'s> {
+        Container { reader: reader }
+    }
+
+    pub fn read_to(&mut self, vec: &mut [u8]) {
+        self.reader.read(vec);
+    }
+}
+
+pub fn for_stdin<'a>() -> Container<'a> {
+    let mut r = io::stdin();
+    Container::wrap(&mut r as &mut Reader)
+}
+
+fn main() {
+    let mut c = for_stdin();
+    let mut v = vec::Vec::from_elem(10, 0u8);
+    c.read_to(v.as_mut_slice());
+}

branches/try2/src/test/compile-fail/issue-11714.rs

@@ -0,0 +1,17 @@
+// Copyright 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.
+
+fn blah() -> int { //~ ERROR not all control paths return a value
+    1i
+
+    ; //~ NOTE consider removing this semicolon:
+}
+
+fn main() { }