---

yaml
---
r: 139023
b: refs/heads/try2
c: 38ac809
h: refs/heads/master
i:
  139021: 974c259
  139019: 02b2696
  139015: 7242e93
  139007: ec0376a
v: v3

Author: brson

[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: e75a843efa66fbcbe7db8473c3ee8f26fa2230ff
+refs/heads/try2: 38ac809cc7f0d4da8cc16951f8a9852f4b052c1f
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libcore/core.rc

@@ -56,7 +56,6 @@ 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"]
@@ -253,7 +252,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)]
+#[doc(hidden)] // FIXME #3538
 pub mod core {
     #[cfg(stage0)]
     pub const error : u32 = 1_u32;

branches/try2/src/libcore/iter.rs

@@ -31,10 +31,6 @@ 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/option.rs

@@ -46,7 +46,7 @@ use ops::Add;
 use kinds::Copy;
 use util;
 use num::Zero;
-use iter::{BaseIter, MutableIter};
+use iter::BaseIter;
 
 #[cfg(test)] use ptr;
 #[cfg(test)] use str;
@@ -323,13 +323,6 @@ impl<T> BaseIter<T> for Option<T> {
     }
 }
 
-impl<T> MutableIter<T> for Option<T> {
-    #[inline(always)]
-    fn each_mut(&mut self, f: &fn(&'self mut T) -> bool) {
-        match *self { None => (), Some(ref mut t) => { f(t); } }
-    }
-}
-
 pub impl<T> Option<T> {
     /// Returns true if the option equals `none`
     #[inline(always)]

branches/try2/src/libcore/prelude.rs

@@ -27,9 +27,8 @@ 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, MutableIter, ExtendedIter, EqIter};
-pub use iter::{CopyableIter, CopyableOrderedIter, CopyableNonstrictIter};
-pub use iter::Times;
+pub use iter::{BaseIter, ReverseIter, ExtendedIter, EqIter, CopyableIter};
+pub use iter::{CopyableOrderedIter, CopyableNonstrictIter, Times};
 pub use num::NumCast;
 pub use path::GenericPath;
 pub use path::Path;
@@ -44,10 +43,6 @@ 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/str.rs

@@ -2273,6 +2273,7 @@ pub trait StrSlice {
     pure fn to_owned(&self) -> ~str;
     pure fn to_managed(&self) -> @str;
     pure fn char_at(&self, i: uint) -> char;
+    fn to_bytes(&self) -> ~[u8];
 }
 
 /// Extension methods for strings
@@ -2416,6 +2417,8 @@ impl StrSlice for &self/str {
 
     #[inline]
     pure fn char_at(&self, i: uint) -> char { char_at(*self, i) }
+
+    fn to_bytes(&self) -> ~[u8] { to_bytes(*self) }
 }
 
 pub trait OwnedStr {

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: &'r mut [T], f: &fn(elem: &'r mut T) -> bool) {
+pub fn each_mut<T>(v: &mut [T], f: &fn(elem: &mut T) -> bool) {
     let mut i = 0;
     let n = v.len();
     while i < n {
@@ -2280,9 +2280,11 @@ pub mod bytes {
 // ___________________________________________________________________________
 // ITERATION TRAIT METHODS
 
-impl<A> iter::BaseIter<A> for &'self [A] {
+impl<A> iter::BaseIter<A> for &self/[A] {
     #[inline(always)]
-    pure fn each(&self, blk: &fn(v: &'self A) -> bool) { each(*self, blk) }
+    pub 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()) }
 }
@@ -2303,29 +2305,6 @@ 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/librustdoc/rustdoc.rc

@@ -116,7 +116,8 @@ fn run(config: Config) {
             // Remove things marked doc(hidden)
             prune_hidden_pass::mk_pass(),
             // Remove things that are private
-            prune_private_pass::mk_pass(),
+            // XXX enable this after 'export' is removed in favor of 'pub'
+            // prune_private_pass::mk_pass(),
             // Extract brief documentation from the full descriptions
             desc_to_brief_pass::mk_pass(),
             // Massage the text to remove extra indentation

branches/try2/src/libstd/treemap.rs

@@ -72,7 +72,7 @@ pure fn lt<K: Ord + TotalOrd, V>(a: &TreeMap<K, V>,
         }
     };
 
-    a_len < b_len
+    return a_len < b_len;
 }
 
 impl<K: Ord + TotalOrd, V> Ord for TreeMap<K, V> {
@@ -694,13 +694,22 @@ fn remove<K: TotalOrd, V>(node: &mut Option<~TreeNode<K, V>>,
 
                 skew(save);
 
-                for save.right.each_mut |right| {
+                match save.right {
+                  Some(ref mut right) => {
                     skew(right);
-                    for right.right.each_mut |x| { skew(x) }
+                    match right.right {
+                      Some(ref mut x) => { skew(x) },
+                      None => ()
+                    }
+                  }
+                  None => ()
                 }
 
                 split(save);
-                for save.right.each_mut |x| { split(x) }
+                match save.right {
+                  Some(ref mut x) => { split(x) },
+                  None => ()
+                }
             }
 
             return removed;
@@ -709,7 +718,7 @@ fn remove<K: TotalOrd, V>(node: &mut Option<~TreeNode<K, V>>,
     }
 
     *node = None;
-    true
+    return true;
 }
 
 #[cfg(test)]

branches/try2/src/libsyntax/codemap.rs

@@ -140,7 +140,7 @@ impl cmp::Eq for span {
 
 impl<S:Encoder> Encodable<S> for span {
     /* Note #1972 -- spans are encoded but not decoded */
-    fn encode(&self, _s: &S) { _s.emit_nil() }
+    fn encode(&self, _s: &S) { }
 }
 
 impl<D:Decoder> Decodable<D> for span {

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

@@ -297,9 +297,10 @@ mod test {
     use std;
     use core::io;
     use core::option::None;
+    use core::str;
     use util::testing::*;
 
-    #[test] fn to_json_str<E : Encodable<std::json::Encoder>>(val: @E) -> ~str {
+    #[test] fn to_json_str (val: @Encodable<std::json::Encoder>) -> ~str {
         do io::with_str_writer |writer| {
             val.encode(~std::json::Encoder(writer));
         }
@@ -311,18 +312,18 @@ mod test {
             @~"fn foo (x : int) { x; }",
             ~[],
             new_parse_sess(None));
-        check_equal(to_json_str(@tts),
-                    ~"[[\"tt_tok\",[null,[\"IDENT\",[\"fn\",false]]]],\
-                      [\"tt_tok\",[null,[\"IDENT\",[\"foo\",false]]]],\
-                      [\"tt_delim\",[[[\"tt_tok\",[null,[\"LPAREN\",[]]]],\
-                      [\"tt_tok\",[null,[\"IDENT\",[\"x\",false]]]],\
-                      [\"tt_tok\",[null,[\"COLON\",[]]]],\
-                      [\"tt_tok\",[null,[\"IDENT\",[\"int\",false]]]],\
-                      [\"tt_tok\",[null,[\"RPAREN\",[]]]]]]],\
-                      [\"tt_delim\",[[[\"tt_tok\",[null,[\"LBRACE\",[]]]],\
-                      [\"tt_tok\",[null,[\"IDENT\",[\"x\",false]]]],\
-                      [\"tt_tok\",[null,[\"SEMI\",[]]]],\
-                      [\"tt_tok\",[null,[\"RBRACE\",[]]]]]]]]"
+        check_equal(to_json_str(@tts as @Encodable<std::json::Encoder>),
+                    ~"[[\"tt_tok\",[,[\"IDENT\",[\"fn\",false]]]],\
+                      [\"tt_tok\",[,[\"IDENT\",[\"foo\",false]]]],\
+                      [\"tt_delim\",[[[\"tt_tok\",[,[\"LPAREN\",[]]]],\
+                      [\"tt_tok\",[,[\"IDENT\",[\"x\",false]]]],\
+                      [\"tt_tok\",[,[\"COLON\",[]]]],\
+                      [\"tt_tok\",[,[\"IDENT\",[\"int\",false]]]],\
+                      [\"tt_tok\",[,[\"RPAREN\",[]]]]]]],\
+                      [\"tt_delim\",[[[\"tt_tok\",[,[\"LBRACE\",[]]]],\
+                      [\"tt_tok\",[,[\"IDENT\",[\"x\",false]]]],\
+                      [\"tt_tok\",[,[\"SEMI\",[]]]],\
+                      [\"tt_tok\",[,[\"RBRACE\",[]]]]]]]]"
                    );
         let ast1 = new_parser_from_tts(new_parse_sess(None),~[],tts)
             .parse_item(~[]);

branches/try2/src/rustllvm/RustWrapper.cpp

@@ -433,10 +433,10 @@ LLVMRustWriteOutputFile(LLVMPassManagerRef PMR,
   Options.EnableSegmentedStacks = EnableSegmentedStacks;
 
   std::string Err;
-  std::string Trip(Triple::normalize(triple));
+  const Target *TheTarget = TargetRegistry::lookupTarget(triple, Err);
   std::string FeaturesStr;
+  std::string Trip(triple);
   std::string CPUStr("generic");
-  const Target *TheTarget = TargetRegistry::lookupTarget(Trip, Err);
   TargetMachine *Target =
     TheTarget->createTargetMachine(Trip, CPUStr, FeaturesStr,
 				   Options, Reloc::PIC_,