---

yaml
---
r: 102097
b: refs/heads/master
c: ad9e26d
h: refs/heads/master
i:
  102095: 7af326b
v: v3

Author: alexcrichton

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 551da0615764853153db944063ae2e271414a71b
+refs/heads/master: ad9e26dab3ae8f5d739e89167338bc97b99905b7
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6e7f170fedd3c526a643c0b2d13863acd982be02
 refs/heads/try: a97642026c18a624ff6ea01075dd9550f8ed07ff

trunk/mk/crates.mk

@@ -69,7 +69,7 @@ DEPS_flate := std native:miniz
 DEPS_arena := std collections
 DEPS_glob := std
 DEPS_serialize := std
-DEPS_term := std collections
+DEPS_term := std
 DEPS_semver := std
 DEPS_uuid := std serialize
 DEPS_sync := std

trunk/mk/prepare.mk

@@ -16,7 +16,7 @@
 #
 # It requires the following variables to be set:
 #
-#   PREPARE_HOST - the host triple
+#   PREPARE_HOST - the host triple 
 #   PREPARE_TARGETS - the target triples, space separated
 #   PREPARE_DEST_DIR - the directory to put the image
 
@@ -172,10 +172,7 @@ prepare-target-$(2)-host-$(3)-$(1): \
         $$(if $$(findstring $(2),$$(CFG_HOST)), \
           $$(foreach crate,$$(HOST_CRATES), \
             $$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$$(crate)),)
-# Only install if this host and target combo is being prepared. Also be sure to
-# *not* install the rlibs for host crates because there's no need to statically
-# link against most of them. They just produce a large amount of extra size
-# bloat.
+# Only install if this host and target combo is being prepared
 	$$(if $$(findstring $(1), $$(PREPARE_STAGE)),\
       $$(if $$(findstring $(2), $$(PREPARE_TARGETS)),\
         $$(if $$(findstring $(3), $$(PREPARE_HOST)),\
@@ -185,7 +182,8 @@ prepare-target-$(2)-host-$(3)-$(1): \
             $$(call PREPARE_LIB,$$(call CFG_RLIB_GLOB,$$(crate))))\
           $$(if $$(findstring $(2),$$(CFG_HOST)),\
             $$(foreach crate,$$(HOST_CRATES),\
-              $$(call PREPARE_LIB,$$(call CFG_LIB_GLOB_$(2),$$(crate)))),)\
+              $$(call PREPARE_LIB,$$(call CFG_LIB_GLOB_$(2),$$(crate)))\
+              $$(call PREPARE_LIB,$$(call CFG_RLIB_GLOB,$$(crate)))),)\
           $$(call PREPARE_LIB,libmorestack.a) \
           $$(call PREPARE_LIB,libcompiler-rt.a),),),)
 endef

trunk/src/doc/rust.md

@@ -467,7 +467,7 @@ expression context, the final namespace qualifier is omitted.
 Two examples of paths with type arguments:
 
 ~~~~
-# struct HashMap<K, V>;
+# use std::hashmap::HashMap;
 # fn f() {
 # fn id<T>(t: T) -> T { t }
 type T = HashMap<int,~str>;  // Type arguments used in a type expression

trunk/src/doc/tutorial.md

@@ -1977,8 +1977,8 @@ illegal to copy and pass by value.
 Generic `type`, `struct`, and `enum` declarations follow the same pattern:
 
 ~~~~
-extern crate collections;
-type Set<T> = collections::HashMap<T, ()>;
+use std::hashmap::HashMap;
+type Set<T> = HashMap<T, ()>;
 
 struct Stack<T> {
     elements: ~[T]
@@ -1988,7 +1988,6 @@ enum Option<T> {
     Some(T),
     None
 }
-# fn main() {}
 ~~~~
 
 These declarations can be instantiated to valid types like `Set<int>`,

trunk/src/etc/combine-tests.py

@@ -55,8 +55,6 @@ def scrub(b):
 #[crate_id=\"run_pass_stage2#0.1\"];
 #[feature(globs, macro_rules, struct_variant, managed_boxes)];
 #[allow(warnings)];
-extern crate collections;
-extern crate extra;
 """
 )
 for t in stage2_tests:

trunk/src/etc/generate-deriving-span-tests.py

@@ -119,8 +119,7 @@ def write_file(name, string):
                               ('Clone', [], 1), ('DeepClone', ['Clone'], 1),
                               ('Eq', [], 2), ('Ord', [], 8),
                               ('TotalEq', [], 1), ('TotalOrd', ['TotalEq'], 1),
-                              ('Show', [], 1),
-                              ('Hash', [], 1)]:
+                              ('Show', [], 1)]:
     traits[trait] = (ALL, supers, errs)
 
 for (trait, (types, super_traits, error_count)) in traits.items():

trunk/src/libarena/lib.rs

@@ -31,14 +31,13 @@ use std::cast::{transmute, transmute_mut, transmute_mut_region};
 use std::cast;
 use std::cell::{Cell, RefCell};
 use std::mem;
-use std::ptr::read;
 use std::cmp;
 use std::num;
 use std::kinds::marker;
 use std::rc::Rc;
 use std::rt::global_heap;
-use std::intrinsics::{TyDesc, get_tydesc};
-use std::intrinsics;
+use std::unstable::intrinsics::{TyDesc, get_tydesc};
+use std::unstable::intrinsics;
 use std::vec;
 
 // The way arena uses arrays is really deeply awful. The arrays are
@@ -346,32 +345,37 @@ pub struct TypedArena<T> {
     /// reached, a new chunk is allocated.
     priv end: *T,
 
+    /// The type descriptor of the objects in the arena. This should not be
+    /// necessary, but is until generic destructors are supported.
+    priv tydesc: *TyDesc,
+
     /// A pointer to the first arena segment.
-    priv first: Option<~TypedArenaChunk<T>>,
+    priv first: Option<~TypedArenaChunk>,
 }
 
-struct TypedArenaChunk<T> {
+struct TypedArenaChunk {
     /// Pointer to the next arena segment.
-    next: Option<~TypedArenaChunk<T>>,
+    next: Option<~TypedArenaChunk>,
 
     /// The number of elements that this chunk can hold.
     capacity: uint,
 
     // Objects follow here, suitably aligned.
 }
 
-impl<T> TypedArenaChunk<T> {
+impl TypedArenaChunk {
     #[inline]
-    fn new(next: Option<~TypedArenaChunk<T>>, capacity: uint) -> ~TypedArenaChunk<T> {
-        let mut size = mem::size_of::<TypedArenaChunk<T>>();
+    fn new<T>(next: Option<~TypedArenaChunk>, capacity: uint)
+           -> ~TypedArenaChunk {
+        let mut size = mem::size_of::<TypedArenaChunk>();
         size = round_up(size, mem::min_align_of::<T>());
         let elem_size = mem::size_of::<T>();
         let elems_size = elem_size.checked_mul(&capacity).unwrap();
         size = size.checked_add(&elems_size).unwrap();
 
         let mut chunk = unsafe {
             let chunk = global_heap::exchange_malloc(size);
-            let mut chunk: ~TypedArenaChunk<T> = cast::transmute(chunk);
+            let mut chunk: ~TypedArenaChunk = cast::transmute(chunk);
             mem::move_val_init(&mut chunk.next, next);
             chunk
         };
@@ -383,13 +387,16 @@ impl<T> TypedArenaChunk<T> {
     /// Destroys this arena chunk. If the type descriptor is supplied, the
     /// drop glue is called; otherwise, drop glue is not called.
     #[inline]
-    unsafe fn destroy(&mut self, len: uint) {
+    unsafe fn destroy(&mut self, len: uint, opt_tydesc: Option<*TyDesc>) {
         // Destroy all the allocated objects.
-        if intrinsics::needs_drop::<T>() {
-            let mut start = self.start();
-            for _ in range(0, len) {
-                read(start as *T); // run the destructor on the pointer
-                start = start.offset(mem::size_of::<T>() as int)
+        match opt_tydesc {
+            None => {}
+            Some(tydesc) => {
+                let mut start = self.start(tydesc);
+                for _ in range(0, len) {
+                    ((*tydesc).drop_glue)(start as *i8);
+                    start = start.offset((*tydesc).size as int)
+                }
             }
         }
 
@@ -399,26 +406,26 @@ impl<T> TypedArenaChunk<T> {
             None => {}
             Some(mut next) => {
                 // We assume that the next chunk is completely filled.
-                next.destroy(next.capacity)
+                next.destroy(next.capacity, opt_tydesc)
             }
         }
     }
 
     // Returns a pointer to the first allocated object.
     #[inline]
-    fn start(&self) -> *u8 {
-        let this: *TypedArenaChunk<T> = self;
+    fn start(&self, tydesc: *TyDesc) -> *u8 {
+        let this: *TypedArenaChunk = self;
         unsafe {
-            cast::transmute(round_up(this.offset(1) as uint, mem::min_align_of::<T>()))
+            cast::transmute(round_up(this.offset(1) as uint, (*tydesc).align))
         }
     }
 
     // Returns a pointer to the end of the allocated space.
     #[inline]
-    fn end(&self) -> *u8 {
+    fn end(&self, tydesc: *TyDesc) -> *u8 {
         unsafe {
-            let size = mem::size_of::<T>().checked_mul(&self.capacity).unwrap();
-            self.start().offset(size as int)
+            let size = (*tydesc).size.checked_mul(&self.capacity).unwrap();
+            self.start(tydesc).offset(size as int)
         }
     }
 }
@@ -434,10 +441,14 @@ impl<T> TypedArena<T> {
     /// objects.
     #[inline]
     pub fn with_capacity(capacity: uint) -> TypedArena<T> {
-        let chunk = TypedArenaChunk::<T>::new(None, capacity);
+        let chunk = TypedArenaChunk::new::<T>(None, capacity);
+        let tydesc = unsafe {
+            intrinsics::get_tydesc::<T>()
+        };
         TypedArena {
-            ptr: chunk.start() as *T,
-            end: chunk.end() as *T,
+            ptr: chunk.start(tydesc) as *T,
+            end: chunk.end(tydesc) as *T,
+            tydesc: tydesc,
             first: Some(chunk),
         }
     }
@@ -464,9 +475,9 @@ impl<T> TypedArena<T> {
     fn grow(&mut self) {
         let chunk = self.first.take_unwrap();
         let new_capacity = chunk.capacity.checked_mul(&2).unwrap();
-        let chunk = TypedArenaChunk::<T>::new(Some(chunk), new_capacity);
-        self.ptr = chunk.start() as *T;
-        self.end = chunk.end() as *T;
+        let chunk = TypedArenaChunk::new::<T>(Some(chunk), new_capacity);
+        self.ptr = chunk.start(self.tydesc) as *T;
+        self.end = chunk.end(self.tydesc) as *T;
         self.first = Some(chunk)
     }
 }
@@ -475,13 +486,18 @@ impl<T> TypedArena<T> {
 impl<T> Drop for TypedArena<T> {
     fn drop(&mut self) {
         // Determine how much was filled.
-        let start = self.first.get_ref().start() as uint;
+        let start = self.first.get_ref().start(self.tydesc) as uint;
         let end = self.ptr as uint;
         let diff = (end - start) / mem::size_of::<T>();
 
         // Pass that to the `destroy` method.
         unsafe {
-            self.first.get_mut_ref().destroy(diff)
+            let opt_tydesc = if intrinsics::needs_drop::<T>() {
+                Some(self.tydesc)
+            } else {
+                None
+            };
+            self.first.get_mut_ref().destroy(diff, opt_tydesc)
         }
     }
 }

trunk/src/libcollections/lib.rs

@@ -27,25 +27,21 @@ pub use btree::BTree;
 pub use deque::Deque;
 pub use dlist::DList;
 pub use enum_set::EnumSet;
-pub use hashmap::{HashMap, HashSet};
 pub use list::List;
 pub use lru_cache::LruCache;
 pub use priority_queue::PriorityQueue;
 pub use ringbuf::RingBuf;
 pub use smallintmap::SmallIntMap;
 pub use treemap::{TreeMap, TreeSet};
-pub use trie::{TrieMap, TrieSet};
 
 pub mod bitv;
 pub mod btree;
 pub mod deque;
 pub mod dlist;
 pub mod enum_set;
-pub mod hashmap;
 pub mod list;
 pub mod lru_cache;
 pub mod priority_queue;
 pub mod ringbuf;
 pub mod smallintmap;
 pub mod treemap;
-pub mod trie;

trunk/src/libcollections/lru_cache.rs

@@ -38,12 +38,11 @@
 //! ```
 
 use std::container::Container;
+use std::hashmap::HashMap;
 use std::to_bytes::Cb;
 use std::ptr;
 use std::cast;
 
-use HashMap;
-
 struct KeyRef<K> { k: *K }
 
 struct LruEntry<K, V> {

trunk/src/libextra/json.rs

@@ -235,7 +235,7 @@ fn main() {
 
 use std::char;
 use std::f64;
-use collections::HashMap;
+use std::hashmap::HashMap;
 use std::io;
 use std::io::MemWriter;
 use std::num;

trunk/src/libextra/stats.rs

@@ -11,11 +11,10 @@
 #[allow(missing_doc)];
 
 use std::cmp;
-use std::hash_old::Hash;
+use std::hashmap;
 use std::io;
 use std::mem;
 use std::num;
-use collections::hashmap;
 
 // NB: this can probably be rewritten in terms of num::Num
 // to be less f64-specific.

trunk/src/libextra/url.rs

@@ -14,7 +14,7 @@
 
 use std::io::BufReader;
 use std::cmp::Eq;
-use collections::HashMap;
+use std::hashmap::HashMap;
 use std::to_bytes;
 use std::uint;
 
@@ -957,7 +957,7 @@ mod tests {
 
     use super::*;
 
-    use collections::HashMap;
+    use std::hashmap::HashMap;
 
     #[test]
     fn test_url_parse() {

trunk/src/libgreen/context.rs

@@ -12,8 +12,8 @@ use std::uint;
 use std::cast::{transmute, transmute_mut_unsafe,
                 transmute_region, transmute_mut_region};
 use stack::Stack;
-use std::rt::stack;
-use std::raw;
+use std::unstable::stack;
+use std::unstable::raw;
 
 // FIXME #7761: Registers is boxed so that it is 16-byte aligned, for storing
 // SSE regs.  It would be marginally better not to do this. In C++ we

trunk/src/libgreen/macros.rs

@@ -124,7 +124,7 @@ memory and partly incapable of presentation to others.",
     abort();
 
     fn abort() -> ! {
-        use std::intrinsics;
+        use std::unstable::intrinsics;
         unsafe { intrinsics::abort() }
     }
 }

trunk/src/libgreen/sched.rs

@@ -16,7 +16,7 @@ use std::rt::task::BlockedTask;
 use std::rt::task::Task;
 use std::sync::deque;
 use std::unstable::mutex::NativeMutex;
-use std::raw;
+use std::unstable::raw;
 
 use TaskState;
 use context::Context;

trunk/src/libgreen/task.rs

@@ -26,7 +26,7 @@ use std::rt::rtio;
 use std::rt::task::{Task, BlockedTask, SendMessage};
 use std::task::TaskOpts;
 use std::unstable::mutex::NativeMutex;
-use std::raw;
+use std::unstable::raw;
 
 use context::Context;
 use coroutine::Coroutine;

trunk/src/libnative/io/pipe_unix.rs

@@ -15,7 +15,7 @@ use std::libc;
 use std::mem;
 use std::rt::rtio;
 use std::sync::arc::UnsafeArc;
-use std::intrinsics;
+use std::unstable::intrinsics;
 
 use super::{IoResult, retry};
 use super::file::{keep_going, fd_t};