---

yaml
---
r: 151807
b: refs/heads/try2
c: 2b4cdea
h: refs/heads/master
i:
  151805: 4d06cdc
  151803: 8c429c3
  151799: bd87851
  151791: 5ed8f7a
  151775: 7803897
  151743: 9162b62
  151679: 48e32f9
  151551: 31acc76
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: 14d3dbe292dc4ac590dabd0c33fe18edb7810be9
+refs/heads/try2: 2b4cdea7f1a26f2ddb543a0650b32e1024df7985
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/mk/crates.mk

@@ -51,14 +51,15 @@
 
 TARGET_CRATES := libc std green rustuv native flate arena glob term semver \
                  uuid serialize sync getopts collections num test time rand \
-		 workcache url log regex graphviz core rlibc
+		 workcache url log regex graphviz core rlibc alloc
 HOST_CRATES := syntax rustc rustdoc fourcc hexfloat regex_macros fmt_macros
 CRATES := $(TARGET_CRATES) $(HOST_CRATES)
 TOOLS := compiletest rustdoc rustc
 
 DEPS_core :=
 DEPS_rlibc :=
-DEPS_std := core libc native:rustrt native:compiler-rt native:backtrace native:jemalloc
+DEPS_alloc := core libc native:jemalloc
+DEPS_std := core libc alloc native:rustrt native:backtrace
 DEPS_graphviz := std
 DEPS_green := std rand native:context_switch
 DEPS_rustuv := std native:uv native:uv_support
@@ -76,7 +77,7 @@ DEPS_serialize := std collections log
 DEPS_term := std collections log
 DEPS_semver := std
 DEPS_uuid := std serialize rand
-DEPS_sync := std
+DEPS_sync := std alloc
 DEPS_getopts := std
 DEPS_collections := std rand
 DEPS_fourcc := syntax std
@@ -101,6 +102,7 @@ TOOL_SOURCE_rustc := $(S)src/driver/driver.rs
 
 ONLY_RLIB_core := 1
 ONLY_RLIB_rlibc := 1
+ONLY_RLIB_alloc := 1
 
 ################################################################################
 # You should not need to edit below this line

branches/try2/src/compiletest/runtest.rs

@@ -9,7 +9,8 @@
 // except according to those terms.
 
 use common::Config;
-use common::{CompileFail, Pretty, RunFail, RunPass, DebugInfoGdb, DebugInfoLldb};
+use common::{CompileFail, Pretty, RunFail, RunPass, DebugInfoGdb};
+use common::{Codegen, DebugInfoLldb};
 use errors;
 use header::TestProps;
 use header;

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

@@ -32,7 +32,7 @@ fn main() {
 And now I get an error:
 
 ~~~ {.notrust}
-error: mismatched types: expected `&int` but found `<VI0>` (expected &-ptr but found integral variable)
+error: mismatched types: expected `&int` but found `<generic integer #0>` (expected &-ptr but found integral variable)
 ~~~
 
 What gives? It needs a pointer! Therefore I have to use pointers!"
@@ -73,7 +73,7 @@ However.
 Here are the use-cases for pointers. I've prefixed them with the name of the
 pointer that satisfies that use-case:
 
-1. Owned: ~Trait must be a pointer, because you don't know the size of the
+1. Owned: `Box<Trait>` must be a pointer, because you don't know the size of the
 object, so indirection is mandatory.
 2. Owned: You need a recursive data structure. These can be infinite sized, so
 indirection is mandatory.

branches/try2/src/libsync/arc.rs renamed to branches/try2/src/liballoc/arc.rs

@@ -13,11 +13,16 @@
  * between tasks.
  */
 
-use std::mem;
-use std::ptr;
-use std::rt::heap::deallocate;
-use std::sync::atomics;
-use std::mem::{min_align_of, size_of};
+use core::atomics;
+use core::clone::Clone;
+use core::kinds::{Share, Send};
+use core::mem::{min_align_of, size_of, drop};
+use core::mem;
+use core::ops::{Drop, Deref};
+use core::option::{Some, None, Option};
+use core::ptr;
+use core::ptr::RawPtr;
+use heap::deallocate;
 
 /// An atomically reference counted wrapper for shared state.
 ///
@@ -28,6 +33,8 @@ use std::mem::{min_align_of, size_of};
 /// task.
 ///
 /// ```rust
+/// extern crate sync;
+///
 /// use sync::Arc;
 ///
 /// fn main() {
@@ -251,10 +258,16 @@ impl<T: Share + Send> Drop for Weak<T> {
 #[cfg(test)]
 #[allow(experimental)]
 mod tests {
-    use super::{Arc, Weak};
+    use std::clone::Clone;
+    use std::comm::channel;
+    use std::mem::drop;
+    use std::ops::{Drop, Deref, DerefMut};
+    use std::option::{Option, Some, None};
     use std::sync::atomics;
     use std::task;
-    use Mutex;
+    use std::vec::Vec;
+    use super::{Arc, Weak};
+    use sync::Mutex;
 
     struct Canary(*mut atomics::AtomicUint);
 

branches/try2/src/libstd/rt/heap.rs renamed to branches/try2/src/liballoc/heap.rs

@@ -11,10 +11,13 @@
 // FIXME: #13994: port to the sized deallocation API when available
 // FIXME: #13996: need a way to mark the `allocate` and `reallocate` return values as `noalias`
 
-use intrinsics::{abort, cttz32};
+use core::intrinsics::{abort, cttz32};
+use core::option::{None, Option};
+use core::ptr::{RawPtr, mut_null, null};
 use libc::{c_char, c_int, c_void, size_t};
-use ptr::{RawPtr, mut_null, null};
-use option::{None, Option};
+
+#[cfg(not(test))] use core::raw;
+#[cfg(not(test))] use util;
 
 #[link(name = "jemalloc", kind = "static")]
 extern {
@@ -148,11 +151,12 @@ unsafe fn exchange_free(ptr: *mut u8) {
 #[cfg(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 total_size = ::rt::util::get_box_size(size, align);
+    let total_size = util::get_box_size(size, align);
     let p = allocate(total_size, 8);
 
-    let alloc = p as *mut ::raw::Box<()>;
+    let alloc = p as *mut raw::Box<()>;
     (*alloc).drop_glue = drop_glue;
 
     alloc as *mut u8

branches/try2/src/liballoc/lib.rs

@@ -0,0 +1,101 @@
+// 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.
+
+//! Rust's core allocation library
+//!
+//! This is the lowest level library through which allocation in Rust can be
+//! performed where the allocation is assumed to succeed. This library will
+//! trigger a task failure when allocation fails.
+//!
+//! This library, like libcore, is not intended for general usage, but rather as
+//! a building block of other libraries. The types and interfaces in this
+//! library are reexported through the [standard library](../std/index.html),
+//! and should not be used through this library.
+//!
+//! Currently, there are four major definitions in this library.
+//!
+//! ## Owned pointers
+//!
+//! The [`Box`](owned/index.html) type is the core owned pointer type in rust.
+//! There can only be one owner of a `Box`, and the owner can decide to mutate
+//! the contents.
+//!
+//! This type can be sent among tasks efficiently as the size of a `Box` value
+//! is just a pointer. Tree-like data structures are often built on owned
+//! pointers because each node often has only one owner, the parent.
+//!
+//! ## Reference counted pointers
+//!
+//! The [`Rc`](rc/index.html) type is a non-threadsafe reference-counted pointer
+//! type intended for sharing memory within a task. An `Rc` pointer wraps a
+//! type, `T`, and only allows access to `&T`, a shared reference.
+//!
+//! This type is useful when inherited mutability is too constraining for an
+//! application (such as using `Box`), and is often paired with the `Cell` or
+//! `RefCell` types in order to allow mutation.
+//!
+//! ## Atomically reference counted pointers
+//!
+//! The [`Arc`](arc/index.html) type is the threadsafe equivalent of the `Rc`
+//! type. It provides all the same functionality of `Rc`, except it requires
+//! that the contained type `T` is shareable. Additionally, `Arc<T>` is itself
+//! sendable while `Rc<T>` is not.
+//!
+//! This types allows for shared access to the contained data, and is often
+//! paired with synchronization primitives such as mutexes to allow mutation of
+//! shared resources.
+//!
+//! ## Heap interfaces
+//!
+//! The [`heap`](heap/index.html) and [`libc_heap`](libc_heap/index.html)
+//! modules are the unsafe interfaces to the underlying allocation systems. The
+//! `heap` module is considered the default heap, and is not necessarily backed
+//! by libc malloc/free.  The `libc_heap` module is defined to be wired up to
+//! the system malloc/free.
+
+#![crate_id = "alloc#0.11.0-pre"]
+#![license = "MIT/ASL2"]
+#![crate_type = "rlib"]
+#![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
+       html_favicon_url = "http://www.rust-lang.org/favicon.ico",
+       html_root_url = "http://static.rust-lang.org/doc/master")]
+
+#![no_std]
+#![feature(phase)]
+
+#[phase(syntax, link)]
+extern crate core;
+extern crate libc;
+
+// Allow testing this library
+
+#[cfg(test)] extern crate sync;
+#[cfg(test)] extern crate native;
+#[cfg(test)] #[phase(syntax, link)] extern crate std;
+#[cfg(test)] #[phase(syntax, link)] extern crate log;
+
+// Heaps provided for low-level allocation strategies
+
+pub mod heap;
+pub mod libc_heap;
+pub mod util;
+
+// Primitive types using the heaps above
+
+#[cfg(not(test))]
+pub mod owned;
+pub mod arc;
+pub mod rc;
+
+#[cfg(not(test))]
+mod std {
+    pub use core::fmt;
+    pub use core::option;
+}

branches/try2/src/libstd/rt/libc_heap.rs renamed to branches/try2/src/liballoc/libc_heap.rs

@@ -12,8 +12,8 @@
 //! The global (exchange) heap.
 
 use libc::{c_void, size_t, free, malloc, realloc};
-use ptr::{RawPtr, mut_null};
-use intrinsics::abort;
+use core::ptr::{RawPtr, mut_null};
+use core::intrinsics::abort;
 
 /// A wrapper around libc::malloc, aborting on out-of-memory
 #[inline]

branches/try2/src/libstd/owned.rs renamed to branches/try2/src/liballoc/owned.rs

@@ -8,17 +8,17 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! Operations on unique pointer types
+//! A unique pointer type
 
-use any::{Any, AnyRefExt};
-use clone::Clone;
-use cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering};
-use default::Default;
-use fmt;
-use intrinsics;
-use mem;
-use raw::TraitObject;
-use result::{Ok, Err, Result};
+use core::any::{Any, AnyRefExt};
+use core::clone::Clone;
+use core::cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering};
+use core::default::Default;
+use core::fmt;
+use core::intrinsics;
+use core::mem;
+use core::raw::TraitObject;
+use core::result::{Ok, Err, Result};
 
 /// A value that represents the global exchange heap. This is the default
 /// place that the `box` keyword allocates into when no place is supplied.
@@ -107,7 +107,6 @@ impl<T: fmt::Show> fmt::Show for Box<T> {
     }
 }
 
-#[cfg(not(stage0))]
 impl fmt::Show for Box<Any> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.pad("Box<Any>")

branches/try2/src/libstd/rc.rs renamed to branches/try2/src/liballoc/rc.rs

@@ -23,17 +23,18 @@ pointers, and then storing the parent pointers as `Weak` pointers.
 
 */
 
-use mem::transmute;
-use cell::Cell;
-use clone::Clone;
-use cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering};
-use kinds::marker;
-use ops::{Deref, Drop};
-use option::{Option, Some, None};
-use ptr;
-use ptr::RawPtr;
-use mem::{min_align_of, size_of};
-use rt::heap::deallocate;
+use core::mem::transmute;
+use core::cell::Cell;
+use core::clone::Clone;
+use core::cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering};
+use core::kinds::marker;
+use core::ops::{Deref, Drop};
+use core::option::{Option, Some, None};
+use core::ptr;
+use core::ptr::RawPtr;
+use core::mem::{min_align_of, size_of};
+
+use heap::deallocate;
 
 struct RcBox<T> {
     value: T,
@@ -230,9 +231,11 @@ impl<T> RcBoxPtr<T> for Weak<T> {
 
 #[cfg(test)]
 mod tests {
-    use prelude::*;
-    use super::*;
-    use cell::RefCell;
+    use super::{Rc, Weak};
+    use std::cell::RefCell;
+    use std::option::{Option, Some, None};
+    use std::mem::drop;
+    use std::clone::Clone;
 
     #[test]
     fn test_clone() {
@@ -280,7 +283,7 @@ mod tests {
     #[test]
     fn gc_inside() {
         // see issue #11532
-        use gc::Gc;
+        use std::gc::Gc;
         let a = Rc::new(RefCell::new(Gc::new(1)));
         assert!(a.try_borrow_mut().is_some());
     }

branches/try2/src/liballoc/util.rs

@@ -0,0 +1,30 @@
+// Copyright 2013 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.
+
+#![doc(hidden)]
+
+use core::mem;
+use core::raw;
+
+#[inline]
+#[deprecated]
+pub fn get_box_size(body_size: uint, body_align: uint) -> uint {
+    let header_size = mem::size_of::<raw::Box<()>>();
+    let total_size = align_to(header_size, body_align) + body_size;
+    total_size
+}
+
+// Rounds size to the next alignment. Alignment is required to be a power of
+// two.
+#[inline]
+fn align_to(size: uint, align: uint) -> uint {
+    assert!(align != 0);
+    (size + align - 1) & !(align - 1)
+}

branches/try2/src/libcollections/trie.rs

@@ -634,7 +634,7 @@ impl<'a> Iterator<uint> for SetItems<'a> {
 
 #[cfg(test)]
 mod test_map {
-    use super::{TrieMap, TrieNode, Internal, External};
+    use super::{TrieMap, TrieNode, Internal, External, Nothing};
     use std::iter::range_step;
     use std::uint;