---

yaml
---
r: 133699
b: refs/heads/auto
c: 7caf2ab
h: refs/heads/master
i:
  133697: 221308e
  133695: c0276cf
v: v3

Author: mo

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 828e075abd8ee2f8c16f6cb1b93c0d99307e704d
+refs/heads/auto: 7caf2ab802d7cf62662b6dd63ffe81672d45f1ad
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/mk/crates.mk

@@ -59,7 +59,7 @@ CRATES := $(TARGET_CRATES) $(HOST_CRATES)
 TOOLS := compiletest rustdoc rustc
 
 DEPS_core :=
-DEPS_rlibc := core
+DEPS_rlibc :=
 DEPS_unicode := core
 DEPS_alloc := core libc native:jemalloc
 DEPS_debug := std

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

@@ -461,12 +461,11 @@ fn start(_argc: int, _argv: *const *const u8) -> int {
     0
 }
 
-// These functions and traits are used by the compiler, but not
+// These functions are invoked by the compiler, but not
 // for a bare-bones hello world. These are normally
 // provided by libstd.
 #[lang = "stack_exhausted"] extern fn stack_exhausted() {}
 #[lang = "eh_personality"] extern fn eh_personality() {}
-#[lang = "sized"] trait Sized { }
 # // fn main() {} tricked you, rustdoc!
 ```
 
@@ -489,14 +488,13 @@ pub extern fn main(argc: int, argv: *const *const u8) -> int {
 
 #[lang = "stack_exhausted"] extern fn stack_exhausted() {}
 #[lang = "eh_personality"] extern fn eh_personality() {}
-#[lang = "sized"] trait Sized { }
 # // fn main() {} tricked you, rustdoc!
 ```
 
 
 The compiler currently makes a few assumptions about symbols which are available
 in the executable to call. Normally these functions are provided by the standard
-xlibrary, but without it you must define your own.
+library, but without it you must define your own.
 
 The first of these two functions, `stack_exhausted`, is invoked whenever stack
 overflow is detected.  This function has a number of restrictions about how it
@@ -510,12 +508,6 @@ mechanisms of the compiler. This is often mapped to GCC's personality function
 information), but crates which do not trigger failure can be assured that this
 function is never called.
 
-The final item in the example is a trait called `Sized`. This a trait
-that represents data of a known static size: it is integral to the
-Rust type system, and so the compiler expects the standard library to
-provide it. Since you are not using the standard library, you have to
-provide it yourself.
-
 ## Using libcore
 
 > **Note**: the core library's structure is unstable, and it is recommended to
@@ -694,7 +686,6 @@ fn main(argc: int, argv: *const *const u8) -> int {
 
 #[lang = "stack_exhausted"] extern fn stack_exhausted() {}
 #[lang = "eh_personality"] extern fn eh_personality() {}
-#[lang = "sized"] trait Sized {}
 ```
 
 Note the use of `abort`: the `exchange_malloc` lang item is assumed to

branches/auto/src/doc/guide.md

@@ -152,7 +152,7 @@ Save the file, and then type this into your terminal window:
 
 ```{bash}
 $ rustc main.rs
-$ ./main # or main.exe on Windows
+$ ./hello_world # or hello_world.exe on Windows
 Hello, world!
 ```
 
@@ -164,7 +164,7 @@ fn main() {
 }
 ```
 
-These lines define a **function** in Rust. The `main` function is special:
+These two 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 (`main.exe` on Windows, `main` everywhere else)
+executable (`hello_world.exe` on Windows, `hello_world` everywhere else)
 
 ```{bash}
-$ ./main  # or main.exe on Windows
+$ ./hello_world  # or hello_world.exe on Windows
 ```
 
 This prints out our `Hello, world!` text to our terminal.

branches/auto/src/doc/rust.md

@@ -3698,7 +3698,7 @@ There are two varieties of pointer in Rust:
     they exist to support interoperability with foreign code,
     and writing performance-critical or low-level functions.
 
-The standard library contains addtional 'smart pointer' types beyond references
+The standard library contains additional 'smart pointer' types beyond references
 and raw pointers.
 
 ### Function types

branches/auto/src/liballoc/heap.rs

@@ -8,9 +8,11 @@
 // 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(stage0, not(test))] use core::raw;
+#[cfg(not(test))] use core::raw;
 #[cfg(stage0, not(test))] use util;
 
 /// Returns a pointer to `size` bytes of memory.
@@ -86,19 +88,18 @@ pub fn stats_print() {
     imp::stats_print();
 }
 
-/// 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 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;
 
 /// 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 *mut u8
+        &EMPTY as *const uint as *mut u8
     } else {
         allocate(size, align)
     }
@@ -111,6 +112,7 @@ 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]
@@ -126,6 +128,21 @@ 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.
@@ -238,6 +255,7 @@ mod imp {
 #[cfg(not(jemalloc), unix)]
 mod imp {
     use core::cmp;
+    use core::mem;
     use core::ptr;
     use libc;
     use libc_heap;

branches/auto/src/libcollections/enum_set.rs

@@ -14,31 +14,15 @@
 //! representation to hold C-like enum variants.
 
 use core::prelude::*;
-use core::fmt;
 
-#[deriving(Clone, PartialEq, Eq, Hash)]
+#[deriving(Clone, PartialEq, Eq, Hash, Show)]
 /// 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`.
@@ -181,16 +165,6 @@ 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/auto/src/libcollections/vec.rs

@@ -14,7 +14,7 @@
 
 use core::prelude::*;
 
-use alloc::heap::{EMPTY, allocate, reallocate, deallocate};
+use alloc::heap::{allocate, reallocate, deallocate};
 use core::cmp::max;
 use core::default::Default;
 use core::fmt;
@@ -28,6 +28,10 @@ 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
@@ -120,7 +124,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: EMPTY as *mut T }
+        Vec { len: 0, cap: 0, ptr: &PTR_MARKER as *const _ as *mut T }
     }
 
     /// Constructs a new, empty `Vec` with the specified capacity.
@@ -153,7 +157,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: EMPTY as *mut T }
+            Vec { len: 0, cap: uint::MAX, ptr: &PTR_MARKER as *const _ as *mut T }
         } else if capacity == 0 {
             Vec::new()
         } else {
@@ -1660,8 +1664,6 @@ impl<T> DoubleEndedIterator<T> for MoveItems<T> {
     }
 }
 
-impl<T> ExactSize<T> for MoveItems<T> {}
-
 #[unsafe_destructor]
 impl<T> Drop for MoveItems<T> {
     fn drop(&mut self) {

branches/auto/src/librlibc/lib.rs

@@ -35,13 +35,12 @@
 // LLVM to optimize these function calls to themselves!
 #![no_builtins]
 
-#[phase(plugin, link)] extern crate core;
-
 #[cfg(test)] extern crate native;
 #[cfg(test)] extern crate test;
 #[cfg(test)] extern crate debug;
 
 #[cfg(test)] #[phase(plugin, link)] extern crate std;
+#[cfg(test)] #[phase(plugin, link)] extern crate core;
 
 // Require the offset intrinsics for LLVM to properly optimize the
 // implementations below. If pointer arithmetic is done through integers the

branches/auto/src/librustc/lib.rs

@@ -108,7 +108,6 @@ pub mod middle {
     pub mod save;
     pub mod stability;
     pub mod subst;
-    pub mod traits;
     pub mod trans;
     pub mod ty;
     pub mod ty_fold;

branches/auto/src/librustc/lint/builtin.rs

@@ -1470,17 +1470,17 @@ impl LintPass for Stability {
                                 def_id
                             }
                             typeck::MethodParam(typeck::MethodParam {
-                                trait_ref: ref trait_ref,
+                                trait_id: trait_id,
                                 method_num: index,
                                 ..
-                            }) |
-                            typeck::MethodObject(typeck::MethodObject {
-                                trait_ref: ref trait_ref,
+                            })
+                            | typeck::MethodObject(typeck::MethodObject {
+                                trait_id: trait_id,
                                 method_num: index,
                                 ..
                             }) => {
                                 match ty::trait_item(cx.tcx,
-                                                     trait_ref.def_id,
+                                                     trait_id,
                                                      index) {
                                     ty::MethodTraitItem(method) => {
                                         method.def_id

branches/auto/src/librustc/metadata/common.rs

@@ -140,10 +140,9 @@ pub enum astencode_tag { // Reserves 0x40 -- 0x5f
     tag_table_unboxed_closures = 0x54,
     tag_table_upvar_borrow_map = 0x55,
     tag_table_capture_modes = 0x56,
-    tag_table_object_cast_map = 0x57,
 }
 static first_astencode_tag: uint = tag_ast as uint;
-static last_astencode_tag: uint = tag_table_object_cast_map as uint;
+static last_astencode_tag: uint = tag_table_capture_modes as uint;
 impl astencode_tag {
     pub fn from_uint(value : uint) -> Option<astencode_tag> {
         let is_a_tag = first_astencode_tag <= value && value <= last_astencode_tag;