---

yaml
---
r: 139026
b: refs/heads/try2
c: 4ad9e5c
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: 1a6a37e01a700191f200cd1d9f1ebdf08d1dec2d
+refs/heads/try2: 4ad9e5c0c29c0ef4ea62f31679de3f072abb454f
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libcore/option.rs

@@ -46,7 +46,7 @@ use ops::Add;
 use kinds::Copy;
 use util;
 use num::Zero;
-use iter::BaseIter;
+use iter::{BaseIter, MutableIter};
 
 #[cfg(test)] use ptr;
 #[cfg(test)] use str;
@@ -323,6 +323,13 @@ 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/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/librustdoc/rustdoc.rc

@@ -116,8 +116,7 @@ fn run(config: Config) {
             // Remove things marked doc(hidden)
             prune_hidden_pass::mk_pass(),
             // Remove things that are private
-            // XXX enable this after 'export' is removed in favor of 'pub'
-            // prune_private_pass::mk_pass(),
+            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>,
         }
     };
 
-    return a_len < b_len;
+    a_len < b_len
 }
 
 impl<K: Ord + TotalOrd, V> Ord for TreeMap<K, V> {
@@ -694,22 +694,13 @@ fn remove<K: TotalOrd, V>(node: &mut Option<~TreeNode<K, V>>,
 
                 skew(save);
 
-                match save.right {
-                  Some(ref mut right) => {
+                for save.right.each_mut |right| {
                     skew(right);
-                    match right.right {
-                      Some(ref mut x) => { skew(x) },
-                      None => ()
-                    }
-                  }
-                  None => ()
+                    for right.right.each_mut |x| { skew(x) }
                 }
 
                 split(save);
-                match save.right {
-                  Some(ref mut x) => { split(x) },
-                  None => ()
-                }
+                for save.right.each_mut |x| { split(x) }
             }
 
             return removed;
@@ -718,7 +709,7 @@ fn remove<K: TotalOrd, V>(node: &mut Option<~TreeNode<K, V>>,
     }
 
     *node = None;
-    return true;
+    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) { }
+    fn encode(&self, _s: &S) { _s.emit_nil() }
 }
 
 impl<D:Decoder> Decodable<D> for span {

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

@@ -297,10 +297,9 @@ mod test {
     use std;
     use core::io;
     use core::option::None;
-    use core::str;
     use util::testing::*;
 
-    #[test] fn to_json_str (val: @Encodable<std::json::Encoder>) -> ~str {
+    #[test] fn to_json_str<E : Encodable<std::json::Encoder>>(val: @E) -> ~str {
         do io::with_str_writer |writer| {
             val.encode(~std::json::Encoder(writer));
         }
@@ -312,18 +311,18 @@ mod test {
             @~"fn foo (x : int) { x; }",
             ~[],
             new_parse_sess(None));
-        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\",[]]]]]]]]"
+        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\",[]]]]]]]]"
                    );
         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;
-  const Target *TheTarget = TargetRegistry::lookupTarget(triple, Err);
+  std::string Trip(Triple::normalize(triple));
   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_,