---

yaml
---
r: 139014
b: refs/heads/try2
c: 19bb166
h: refs/heads/master
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: 387aa3668a4ff865c5554a9f3dac2d339f8ef7aa
+refs/heads/try2: 19bb16650f385755312e7d2399ce14e8253d92fa
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/RELEASES.txt

@@ -10,7 +10,8 @@ Version 0.6 (March 2013)
       * Remove `static` keyword
       * Static method syntax
       * `as Trait`
-      * `copy` removed?
+      * `copy` removed, replaced with `Clone`?
+      * `std::map` removed, replaced with `core::hashmap`
 
    * Syntax changes
       * The self type parameter in traits is now spelled `Self`
@@ -38,7 +39,8 @@ Version 0.6 (March 2013)
       * Trait implementations no longer support visibility modifiers
 
    * Semantic changes
-      * Linear types move by default, eliminating the `move` keyword
+      * Types with owned pointers or custom destructors move by default,
+        eliminating the `move` keyword
       * All foreign functions are considered unsafe
       * &mut is now unaliasable
       * Writes to borrowed @mut pointers are prevented dynamically
@@ -57,16 +59,19 @@ Version 0.6 (March 2013)
         improve inference and eliminate unsoundness
 
    * Libraries
-      * Lots of effort to organize the container API's around `core::container`
-      * `core::send_map` renamed to `core::hashmap`
       * Added big integers to `std::bigint`
       * Removed `core::oldcomm` module
       * Added pipe-based `core::comm` module
-      * Reimplemented `std::treemap`
       * Numeric traits have been reorganized under `core::num`
-      * `core::dvec` removed. Use `@mut ~[T]` or other language types
       * `vec::slice` finally returns a slice
       * `debug!` and friends don't require a format string, e.g. `debug!(Foo)`
+      * Containers reorganized around traits in `core::container`
+      * `core::dvec` removed, `~[T]` is a drop-in replacement
+      * `core::send_map` renamed to `core::hashmap`
+      * `std::treemap` reimplemented as an owned balanced tree
+      * `std::deque` and `std::smallintmap` reimplemented as owned containers
+      * `core::trie` added as a fast ordered map for integer keys
+      * Set types added to `core::hashmap`, `core::trie` and `std::treemap`
 
    * Tools
       * Replaced the 'cargo' package manager with 'rustpkg'

branches/try2/mk/rt.mk

@@ -132,7 +132,7 @@ rt/$(1)/%.o: rt/%.S  $$(MKFILE_DEPS) \
 
 rt/$(1)/arch/$$(HOST_$(1))/libmorestack.a: $$(MORESTACK_OBJ_$(1))
 	@$$(call E, link: $$@)
-	$$(Q)ar rcs $$@ $$<
+	$$(Q)$(AR_$(1)) rcs $$@ $$<
 
 rt/$(1)/$(CFG_RUNTIME_$(1)): $$(RUNTIME_OBJS_$(1)) $$(MKFILE_DEPS) \
                         $$(RUNTIME_DEF_$(1)) \

branches/try2/src/libcore/container.rs

@@ -35,6 +35,9 @@ pub trait Map<K, V>: Mutable {
     /// Visit all values
     pure fn each_value(&self, f: &fn(&V) -> bool);
 
+    /// Iterate over the map and mutate the contained values
+    fn mutate_values(&mut self, f: &fn(&K, &mut V) -> bool);
+
     /// Return the value corresponding to the key in the map
     pure fn find(&self, key: &K) -> Option<&self/V>;
 

branches/try2/src/libcore/core.rc

@@ -56,6 +56,7 @@ Implicitly, all crates behave as if they included the following prologue:
 
 // On Linux, link to the runtime with -lrt.
 #[cfg(target_os = "linux")]
+#[doc(hidden)]
 pub mod linkhack {
     #[link_args="-lrustrt -lrt"]
     #[link_args = "-lpthread"]
@@ -252,7 +253,7 @@ pub mod rt;
 // A curious inner-module that's not exported that contains the binding
 // 'core' so that macro-expanded references to core::error and such
 // can be resolved within libcore.
-#[doc(hidden)] // FIXME #3538
+#[doc(hidden)]
 pub mod core {
     #[cfg(stage0)]
     pub const error : u32 = 1_u32;

branches/try2/src/libcore/hashmap.rs

@@ -325,6 +325,19 @@ pub mod linear {
             self.each(|&(_, v)| blk(v))
         }
 
+        /// Iterate over the map and mutate the contained values
+        fn mutate_values(&mut self, blk: &fn(&'self K,
+                              &'self mut V) -> bool) {
+            for uint::range(0, self.buckets.len()) |i| {
+                match self.buckets[i] {
+                  Some(Bucket{key: ref key, value: ref mut value, _}) => {
+                    if !blk(key, value) { return }
+                  }
+                  None => ()
+                }
+            }
+        }
+
         /// Return the value corresponding to the key in the map
         pure fn find(&self, k: &K) -> Option<&self/V> {
             match self.bucket_for_key(k) {

branches/try2/src/libcore/iter.rs

@@ -31,6 +31,10 @@ pub trait ReverseIter<A>: BaseIter<A> {
     pure fn each_reverse(&self, blk: &fn(&A) -> bool);
 }
 
+pub trait MutableIter<A>: BaseIter<A> {
+    fn each_mut(&mut self, blk: &fn(&mut A) -> bool);
+}
+
 pub trait ExtendedIter<A> {
     pure fn eachi(&self, blk: &fn(uint, v: &A) -> bool);
     pure fn all(&self, blk: &fn(&A) -> bool) -> bool;

branches/try2/src/libcore/prelude.rs

@@ -27,8 +27,9 @@ pub use clone::Clone;
 pub use cmp::{Eq, Ord, TotalOrd, Ordering, Less, Equal, Greater};
 pub use container::{Container, Mutable, Map, Set};
 pub use hash::Hash;
-pub use iter::{BaseIter, ReverseIter, ExtendedIter, EqIter, CopyableIter};
-pub use iter::{CopyableOrderedIter, CopyableNonstrictIter, Times};
+pub use iter::{BaseIter, ReverseIter, MutableIter, ExtendedIter, EqIter};
+pub use iter::{CopyableIter, CopyableOrderedIter, CopyableNonstrictIter};
+pub use iter::Times;
 pub use num::NumCast;
 pub use path::GenericPath;
 pub use path::Path;
@@ -43,6 +44,10 @@ pub use vec::{CopyableVector, ImmutableVector};
 pub use vec::{ImmutableEqVector, ImmutableCopyableVector};
 pub use vec::{OwnedVector, OwnedCopyableVector};
 
+/* Reexported runtime types */
+pub use comm::{stream, Port, Chan, GenericChan, GenericSmartChan, GenericPort, Peekable};
+pub use task::spawn;
+
 /* Reexported modules */
 
 pub use at_vec;

branches/try2/src/libcore/trie.rs

@@ -81,11 +81,16 @@ impl<T> Map<uint, T> for TrieMap<T> {
 
     /// Visit all values in order
     #[inline(always)]
-    pure fn each_value(&self,
-                       f: &fn(&T) -> bool) {
+    pure fn each_value(&self, f: &fn(&T) -> bool) {
         self.each(|&(_, v)| f(v))
     }
 
+    /// Iterate over the map and mutate the contained values
+    #[inline(always)]
+    fn mutate_values(&mut self, f: &fn(&uint, &mut T) -> bool) {
+        self.root.mutate_values(f);
+    }
+
     /// Return the value corresponding to the key in the map
     #[inline(hint)]
     pure fn find(&self, key: &uint) -> Option<&self/T> {
@@ -150,11 +155,6 @@ impl<T> TrieMap<T> {
     pure fn each_value_reverse(&self, f: &fn(&T) -> bool) {
         self.each_reverse(|&(_, v)| f(v))
     }
-
-    /// Iterate over the map and mutate the contained values
-    fn mutate_values(&mut self, f: &fn(uint, &mut T) -> bool) {
-        self.root.mutate_values(f);
-    }
 }
 
 pub struct TrieSet {
@@ -248,13 +248,13 @@ impl<T> TrieNode<T> {
         true
     }
 
-    fn mutate_values(&mut self, f: &fn(uint, &mut T) -> bool) -> bool {
+    fn mutate_values(&mut self, f: &fn(&uint, &mut T) -> bool) -> bool {
         for vec::each_mut(self.children) |child| {
             match *child {
                 Internal(ref mut x) => if !x.mutate_values(f) {
                     return false
                 },
-                External(k, ref mut v) => if !f(k, v) { return false },
+                External(k, ref mut v) => if !f(&k, v) { return false },
                 Nothing => ()
             }
         }
@@ -269,8 +269,8 @@ pure fn chunk(n: uint, idx: uint) -> uint {
     (n >> (SHIFT * real_idx)) & MASK
 }
 
-fn insert<T>(count: &mut uint, child: &mut Child<T>, key: uint,
-                   value: T, idx: uint) -> bool {
+fn insert<T>(count: &mut uint, child: &mut Child<T>, key: uint, value: T,
+             idx: uint) -> bool {
     let mut tmp = Nothing;
     tmp <-> *child;
     let mut added = false;

branches/try2/src/libcore/vec.rs

@@ -1357,7 +1357,7 @@ pub pure fn each<T>(v: &r/[T], f: &fn(&r/T) -> bool) {
 /// a vector with mutable contents and you would like
 /// to mutate the contents as you iterate.
 #[inline(always)]
-pub fn each_mut<T>(v: &mut [T], f: &fn(elem: &mut T) -> bool) {
+pub fn each_mut<T>(v: &'r mut [T], f: &fn(elem: &'r mut T) -> bool) {
     let mut i = 0;
     let n = v.len();
     while i < n {
@@ -2280,11 +2280,9 @@ pub mod bytes {
 // ___________________________________________________________________________
 // ITERATION TRAIT METHODS
 
-impl<A> iter::BaseIter<A> for &self/[A] {
+impl<A> iter::BaseIter<A> for &'self [A] {
     #[inline(always)]
-    pub pure fn each(&self, blk: &fn(v: &'self A) -> bool) {
-        each(*self, blk)
-    }
+    pure fn each(&self, blk: &fn(v: &'self A) -> bool) { each(*self, blk) }
     #[inline(always)]
     pure fn size_hint(&self) -> Option<uint> { Some(self.len()) }
 }
@@ -2305,6 +2303,29 @@ impl<A> iter::BaseIter<A> for @[A] {
     pure fn size_hint(&self) -> Option<uint> { Some(self.len()) }
 }
 
+impl<A> iter::MutableIter<A> for &'self mut [A] {
+    #[inline(always)]
+    fn each_mut(&mut self, blk: &fn(v: &'self mut A) -> bool) {
+        each_mut(*self, blk)
+    }
+}
+
+// FIXME(#4148): This should be redundant
+impl<A> iter::MutableIter<A> for ~[A] {
+    #[inline(always)]
+    fn each_mut(&mut self, blk: &fn(v: &'self mut A) -> bool) {
+        each_mut(*self, blk)
+    }
+}
+
+// FIXME(#4148): This should be redundant
+impl<A> iter::MutableIter<A> for @mut [A] {
+    #[inline(always)]
+    fn each_mut(&mut self, blk: &fn(v: &mut A) -> bool) {
+        each_mut(*self, blk)
+    }
+}
+
 impl<A> iter::ExtendedIter<A> for &self/[A] {
     pub pure fn eachi(&self, blk: &fn(uint, v: &A) -> bool) {
         iter::eachi(self, blk)

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

@@ -1203,8 +1203,8 @@ impl fake_ext_ctxt for fake_session {
 }
 
 #[cfg(test)]
-fn mk_ctxt() -> fake_ext_ctxt {
-    @parse::new_parse_sess(None) as fake_ext_ctxt
+fn mk_ctxt() -> @fake_ext_ctxt {
+    @parse::new_parse_sess(None) as @fake_ext_ctxt
 }
 
 #[cfg(test)]

branches/try2/src/libstd/smallintmap.rs

@@ -85,7 +85,17 @@ impl<V> Map<uint, V> for SmallIntMap<V> {
         self.each(|&(_, v)| blk(v))
     }
 
-    /// Return the value corresponding to the key in the map
+    /// Visit all key-value pairs in order
+    fn mutate_values(&mut self, it: &fn(&uint, &'self mut V) -> bool) {
+        for uint::range(0, self.v.len()) |i| {
+            match self.v[i] {
+              Some(ref mut elt) => if !it(&i, elt) { break },
+              None => ()
+            }
+        }
+    }
+
+    /// Iterate over the map and mutate the contained values
     pure fn find(&self, key: &uint) -> Option<&self/V> {
         if *key < self.v.len() {
             match self.v[*key] {

branches/try2/src/libstd/treemap.rs

@@ -134,6 +134,11 @@ impl<K: TotalOrd, V> Map<K, V> for TreeMap<K, V> {
         self.each(|&(_, v)| f(v))
     }
 
+    /// Iterate over the map and mutate the contained values
+    fn mutate_values(&mut self, f: &fn(&'self K, &'self mut V) -> bool) {
+        mutate_values(&mut self.root, f);
+    }
+
     /// Return the value corresponding to the key in the map
     pure fn find(&self, key: &K) -> Option<&self/V> {
         let mut current: &self/Option<~TreeNode<K, V>> = &self.root;
@@ -558,6 +563,20 @@ pure fn each_reverse<K: TotalOrd, V>(node: &r/Option<~TreeNode<K, V>>,
     }
 }
 
+fn mutate_values<K: TotalOrd, V>(node: &'r mut Option<~TreeNode<K, V>>,
+                                 f: &fn(&'r K, &'r mut V) -> bool) -> bool {
+    match *node {
+      Some(~TreeNode{key: ref key, value: ref mut value, left: ref mut left,
+                     right: ref mut right, _}) => {
+        if !mutate_values(left, f) { return false }
+        if !f(key, value) { return false }
+        if !mutate_values(right, f) { return false }
+      }
+      None => return false
+    }
+    true
+}
+
 // Remove left horizontal link by rotating right
 fn skew<K: TotalOrd, V>(node: &mut ~TreeNode<K, V>) {
     if node.left.map_default(false, |x| x.level == node.level) {

branches/try2/src/libsyntax/parse/mod.rs

@@ -300,7 +300,7 @@ mod test {
     use core::str;
     use util::testing::*;
 
-    #[test] fn to_json_str (val: Encodable<std::json::Encoder>) -> ~str {
+    #[test] fn to_json_str (val: @Encodable<std::json::Encoder>) -> ~str {
         do io::with_str_writer |writer| {
             val.encode(~std::json::Encoder(writer));
         }

branches/try2/src/rt/rust_builtin.cpp

@@ -321,7 +321,7 @@ get_time(int64_t *sec, int32_t *nsec) {
     ul.HighPart = fileTime.dwHighDateTime;
     uint64_t ns_since_1601 = ul.QuadPart / 10;
 
-    const uint64_t NANOSECONDS_FROM_1601_TO_1970 = 11644473600000000u;
+    const uint64_t NANOSECONDS_FROM_1601_TO_1970 = 11644473600000000ull;
     uint64_t ns_since_1970 = ns_since_1601 - NANOSECONDS_FROM_1601_TO_1970;
     *sec = ns_since_1970 / 1000000;
     *nsec = (ns_since_1970 % 1000000) * 1000;

branches/try2/src/test/bench/core-std.rs

@@ -17,6 +17,7 @@ use std::oldmap;
 use std::oldmap::{Map, HashMap};
 
 use core::io::{Reader, ReaderUtil};
+use core::rand::RngUtil;
 
 macro_rules! bench (
     ($id:ident) => (maybe_run_test(argv, stringify!($id).to_owned(), $id))

branches/try2/src/test/bench/graph500-bfs.rs

@@ -29,6 +29,7 @@ use std::deque::Deque;
 use std::par;
 use core::io::WriterUtil;
 use core::int::abs;
+use core::rand::RngUtil;
 
 type node_id = i64;
 type graph = ~[~[node_id]];
@@ -37,7 +38,7 @@ type bfs_result = ~[node_id];
 fn make_edges(scale: uint, edgefactor: uint) -> ~[(node_id, node_id)] {
     let r = rand::xorshift();
 
-    fn choose_edge(i: node_id, j: node_id, scale: uint, r: rand::Rng)
+    fn choose_edge(i: node_id, j: node_id, scale: uint, r: @rand::Rng)
         -> (node_id, node_id) {
 
         let A = 0.57;

branches/try2/src/test/bench/noise.rs

@@ -1,5 +1,7 @@
 // Perlin noise benchmark from https://gist.github.com/1170424
 
+use core::rand::RngUtil;
+
 struct Vec2 {
     x: f32,
     y: f32,
@@ -8,7 +10,7 @@ struct Vec2 {
 fn lerp(a: f32, b: f32, v: f32) -> f32  { a * (1.0 - v) + b * v }
 fn smooth(v: f32) -> f32                { v * v * (3.0 - 2.0 * v) }
 
-fn random_gradient(r: rand::Rng) -> Vec2 {
+fn random_gradient(r: @rand::Rng) -> Vec2 {
     let v = r.gen_float() * float::consts::pi * 2.0;
     Vec2{
         x: float::cos(v) as f32,

branches/try2/src/test/bench/shootout-fasta.rs

@@ -57,7 +57,11 @@ fn select_random(r: u32, genelist: ~[AminoAcids]) -> char {
     return bisect(copy genelist, 0, vec::len::<AminoAcids>(genelist) - 1, r);
 }
 
-fn make_random_fasta(wr: io::Writer, id: ~str, desc: ~str, genelist: ~[AminoAcids], n: int) {
+fn make_random_fasta(wr: @io::Writer,
+                     id: ~str,
+                     desc: ~str,
+                     genelist: ~[AminoAcids],
+                     n: int) {
     wr.write_line(~">" + id + ~" " + desc);
     let rng = @mut MyRandom {last: rand::Rng().next()};
     let mut op: ~str = ~"";
@@ -72,7 +76,7 @@ fn make_random_fasta(wr: io::Writer, id: ~str, desc: ~str, genelist: ~[AminoAcid
     if str::len(op) > 0u { wr.write_line(op); }
 }
 
-fn make_repeat_fasta(wr: io::Writer, id: ~str, desc: ~str, s: ~str, n: int) {
+fn make_repeat_fasta(wr: @io::Writer, id: ~str, desc: ~str, s: ~str, n: int) {
     unsafe {
         wr.write_line(~">" + id + ~" " + desc);
         let mut op: ~str = ~"";