---

yaml
---
r: 152061
b: refs/heads/try2
c: c7fe4ff
h: refs/heads/master
i:
  152059: 76791fb
v: v3

Author: richo

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

branches/try2/src/doc/tutorial.md

@@ -1106,7 +1106,7 @@ let ys = xs;
 
 xs = Nil;
 
-// `xs` can't be used again
+// `xs` can be used again
 ~~~
 
 A destructor call will only occur for a variable that has not been moved from,

branches/try2/src/libcollections/hashmap.rs

@@ -2003,20 +2003,6 @@ mod test_map {
         assert_eq!(m1, m2);
     }
 
-    #[test]
-    fn test_show() {
-        let mut map: HashMap<int, int> = HashMap::new();
-        let empty: HashMap<int, int> = HashMap::new();
-
-        map.insert(1, 2);
-        map.insert(3, 4);
-
-        let map_str = format!("{}", map);
-
-        assert!(map_str == "{1: 2, 3: 4}".to_owned() || map_str == "{3: 4, 1: 2}".to_owned());
-        assert_eq!(format!("{}", empty), "{}".to_owned());
-    }
-
     #[test]
     fn test_expand() {
         let mut m = HashMap::new();

branches/try2/src/libcollections/treemap.rs

@@ -12,11 +12,9 @@
 //! trees. The only requirement for the types is that the key implements
 //! `TotalOrd`.
 
-use std::cmp::Ordering;
-use std::fmt::Show;
-use std::fmt;
-use std::iter::Peekable;
 use std::iter;
+use std::iter::{Peekable};
+use std::cmp::Ordering;
 use std::mem::{replace, swap};
 use std::ptr;
 
@@ -69,19 +67,6 @@ impl<K: Ord + TotalOrd, V: Ord> Ord for TreeMap<K, V> {
     fn lt(&self, other: &TreeMap<K, V>) -> bool { lt(self, other) }
 }
 
-impl<K: TotalOrd + Show, V: Show> Show for TreeMap<K, V> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        try!(write!(f, r"\{"));
-
-        for (i, (k, v)) in self.iter().enumerate() {
-            if i != 0 { try!(write!(f, ", ")); }
-            try!(write!(f, "{}: {}", *k, *v));
-        }
-
-        write!(f, r"\}")
-    }
-}
-
 impl<K: TotalOrd, V> Container for TreeMap<K, V> {
     fn len(&self) -> uint { self.length }
 }
@@ -562,19 +547,6 @@ impl<T: Ord + TotalOrd> Ord for TreeSet<T> {
     fn lt(&self, other: &TreeSet<T>) -> bool { self.map < other.map }
 }
 
-impl<T: TotalOrd + Show> Show for TreeSet<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        try!(write!(f, r"\{"));
-
-        for (i, x) in self.iter().enumerate() {
-            if i != 0 { try!(write!(f, ", ")); }
-            try!(write!(f, "{}", *x));
-        }
-
-        write!(f, r"\}")
-    }
-}
-
 impl<T: TotalOrd> Container for TreeSet<T> {
     #[inline]
     fn len(&self) -> uint { self.map.len() }
@@ -1356,20 +1328,6 @@ mod test_treemap {
         assert!(a < b && a <= b);
     }
 
-    #[test]
-    fn test_show() {
-        let mut map: TreeMap<int, int> = TreeMap::new();
-        let empty: TreeMap<int, int> = TreeMap::new();
-
-        map.insert(1, 2);
-        map.insert(3, 4);
-
-        let map_str = format!("{}", map);
-
-        assert!(map_str == "{1: 2, 3: 4}".to_owned());
-        assert_eq!(format!("{}", empty), "{}".to_owned());
-    }
-
     #[test]
     fn test_lazy_iterator() {
         let mut m = TreeMap::new();
@@ -1765,18 +1723,4 @@ mod test_set {
             assert!(set.contains(x));
         }
     }
-
-    #[test]
-    fn test_show() {
-        let mut set: TreeSet<int> = TreeSet::new();
-        let empty: TreeSet<int> = TreeSet::new();
-
-        set.insert(1);
-        set.insert(2);
-
-        let set_str = format!("{}", set);
-
-        assert!(set_str == "{1, 2}".to_owned());
-        assert_eq!(format!("{}", empty), "{}".to_owned());
-    }
 }

branches/try2/src/libgetopts/lib.rs

@@ -671,7 +671,7 @@ pub fn usage(brief: &str, opts: &[OptGroup]) -> String {
                      hasarg: hasarg,
                      ..} = (*optref).clone();
 
-        let mut row = String::from_owned_str(" ".repeat(4));
+        let mut row = " ".repeat(4);
 
         // short option
         match short_name.len() {

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

@@ -863,18 +863,9 @@ fn default(cx: &MatchCheckCtxt, r: &[@Pat]) -> Option<Vec<@Pat> > {
 
 fn check_local(cx: &mut MatchCheckCtxt, loc: &Local) {
     visit::walk_local(cx, loc, ());
-
-    let name = match loc.source {
-        LocalLet => "local",
-        LocalFor => "`for` loop"
-    };
-
-    let mut spans = vec![];
-    find_refutable(cx, loc.pat, &mut spans);
-
-    for span in spans.iter() {
-        cx.tcx.sess.span_err(*span,
-                             format!("refutable pattern in {} binding", name).as_slice());
+    if is_refutable(cx, loc.pat) {
+        cx.tcx.sess.span_err(loc.pat.span,
+                             "refutable pattern in local binding");
     }
 
     // Check legality of move bindings.
@@ -888,65 +879,53 @@ fn check_fn(cx: &mut MatchCheckCtxt,
             sp: Span) {
     visit::walk_fn(cx, kind, decl, body, sp, ());
     for input in decl.inputs.iter() {
-        let mut spans = vec![];
-        find_refutable(cx, input.pat, &mut spans);
-
-        for span in spans.iter() {
-            cx.tcx.sess.span_err(*span,
+        if is_refutable(cx, input.pat) {
+            cx.tcx.sess.span_err(input.pat.span,
                                  "refutable pattern in function argument");
         }
     }
 }
 
-fn find_refutable(cx: &MatchCheckCtxt, pat: &Pat, spans: &mut Vec<Span>) {
-    macro_rules! this_pattern {
-        () => {
-            {
-                spans.push(pat.span);
-                return
-            }
-        }
-    }
+fn is_refutable(cx: &MatchCheckCtxt, pat: &Pat) -> bool {
     let opt_def = cx.tcx.def_map.borrow().find_copy(&pat.id);
     match opt_def {
       Some(DefVariant(enum_id, _, _)) => {
         if ty::enum_variants(cx.tcx, enum_id).len() != 1u {
-            this_pattern!()
+            return true;
         }
       }
-      Some(DefStatic(..)) => this_pattern!(),
+      Some(DefStatic(..)) => return true,
       _ => ()
     }
 
     match pat.node {
       PatUniq(sub) | PatRegion(sub) | PatIdent(_, _, Some(sub)) => {
-        find_refutable(cx, sub, spans)
+        is_refutable(cx, sub)
       }
-      PatWild | PatWildMulti | PatIdent(_, _, None) => {}
+      PatWild | PatWildMulti | PatIdent(_, _, None) => { false }
       PatLit(lit) => {
           match lit.node {
             ExprLit(lit) => {
                 match lit.node {
-                    LitNil => {}    // `()`
-                    _ => this_pattern!(),
+                    LitNil => false,    // `()`
+                    _ => true,
                 }
             }
-            _ => this_pattern!(),
+            _ => true,
           }
       }
-      PatRange(_, _) => { this_pattern!() }
+      PatRange(_, _) => { true }
       PatStruct(_, ref fields, _) => {
-          for f in fields.iter() {
-              find_refutable(cx, f.pat, spans);
-          }
+        fields.iter().any(|f| is_refutable(cx, f.pat))
       }
-      PatTup(ref elts) | PatEnum(_, Some(ref elts))=> {
-          for elt in elts.iter() {
-              find_refutable(cx, *elt, spans)
-          }
+      PatTup(ref elts) => {
+        elts.iter().any(|elt| is_refutable(cx, *elt))
+      }
+      PatEnum(_, Some(ref args)) => {
+        args.iter().any(|a| is_refutable(cx, *a))
       }
-      PatEnum(_,_) => {}
-      PatVec(..) => { this_pattern!() }
+      PatEnum(_,_) => { false }
+      PatVec(..) => { true }
     }
 }
 

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

@@ -297,23 +297,6 @@ impl<'a> Visitor<()> for EmbargoVisitor<'a> {
                 }
             }
 
-            ast::ItemTy(ref ty, _) if public_first => {
-                match ty.node {
-                    ast::TyPath(_, _, id) => {
-                        match self.tcx.def_map.borrow().get_copy(&id) {
-                            ast::DefPrimTy(..) => {},
-                            def => {
-                                let did = def_id_of_def(def);
-                                if is_local(did) {
-                                    self.exported_items.insert(did.node);
-                                }
-                            }
-                        }
-                    }
-                    _ => {}
-                }
-            }
-
             _ => {}
         }
 

branches/try2/src/libserialize/json.rs

@@ -1434,6 +1434,36 @@ impl<T: Iterator<char>> Parser<T> {
                         },
                     },
                     _ => return self.error(InvalidEscape),
+/*=======
+                    'u' => {
+                        // Parse \u1234.
+                        let mut i = 0u;
+                        let mut n = 0u;
+                        while i < 4u && !self.eof() {
+                            self.bump();
+                            n = match self.ch_or_null() {
+                                c @ '0' .. '9' => n * 16u + (c as uint) - ('0' as uint),
+                                'a' | 'A' => n * 16u + 10u,
+                                'b' | 'B' => n * 16u + 11u,
+                                'c' | 'C' => n * 16u + 12u,
+                                'd' | 'D' => n * 16u + 13u,
+                                'e' | 'E' => n * 16u + 14u,
+                                'f' | 'F' => n * 16u + 15u,
+                                _ => return self.error(UnrecognizedHex)
+                            };
+
+                            i += 1u;
+                        }
+
+                        // Error out if we didn't parse 4 digits.
+                        if i != 4u {
+                            return self.error(NotFourDigit);
+                        }
+
+                        res.push_char(char::from_u32(n as u32).unwrap());
+                    }
+                    _ => return self.error(InvalidEscape),
+>>>>>>> Add a streaming parser to serialize::json.*/
                 }
                 escape = false;
             } else if self.ch_is('\\') {

branches/try2/src/libstd/str.rs

@@ -16,25 +16,24 @@ Unicode string manipulation (`str` type)
 
 Rust's string type is one of the core primitive types of the language. While
 represented by the name `str`, the name `str` is not actually a valid type in
-Rust. Each string must also be decorated with a pointer. `String` is used
-for an owned string, so there is only one commonly-used `str` type in Rust:
-`&str`.
+Rust. Each string must also be decorated with its ownership. This means that
+there is one common kind of string in Rust:
 
-`&str` is the borrowed string type. This type of string can only be created
-from other strings, unless it is a static string (see below). As the word
-"borrowed" implies, this type of string is owned elsewhere, and this string
-cannot be moved out of.
+* `&str` - This is the borrowed string type. This type of string can only be
+           created from the other kind of string. As the name "borrowed"
+           implies, this type of string is owned elsewhere, and this string
+           cannot be moved out of.
 
-As an example, here's some code that uses a string.
+As an example, here's the one kind of string.
 
 ```rust
 fn main() {
     let borrowed_string = "This string is borrowed with the 'static lifetime";
 }
 ```
 
-From the example above, you can see that Rust's string literals have the
-`'static` lifetime. This is akin to C's concept of a static string.
+From the example above, you can see that Rust has 1 different kind of string
+literal. The "borrowed literal" is akin to C's concept of a static string.
 
 String literals are allocated statically in the rodata of the
 executable/library. The string then has the type `&'static str` meaning that
@@ -510,7 +509,7 @@ pub fn from_utf8_lossy<'a>(v: &'a [u8]) -> MaybeOwned<'a> {
 Section: MaybeOwned
 */
 
-/// A `MaybeOwned` is a string that can hold either a `String` or a `&str`.
+/// A MaybeOwned is a string that can hold either a String or a &str.
 /// This can be useful as an optimization when an allocation is sometimes
 /// needed but not always.
 pub enum MaybeOwned<'a> {
@@ -520,7 +519,7 @@ pub enum MaybeOwned<'a> {
     Owned(String)
 }
 
-/// `SendStr` is a specialization of `MaybeOwned` to be sendable
+/// SendStr is a specialization of `MaybeOwned` to be sendable
 pub type SendStr = MaybeOwned<'static>;
 
 impl<'a> MaybeOwned<'a> {
@@ -911,10 +910,9 @@ impl OwnedStr for String {
     }
 
     #[inline]
-    fn append(self, rhs: &str) -> String {
-        let mut new_str = String::from_owned_str(self);
-        new_str.push_str(rhs);
-        new_str
+    fn append(mut self, rhs: &str) -> String {
+        self.push_str(rhs);
+        self
     }
 }
 

branches/try2/src/libstd/string.rs

@@ -68,7 +68,8 @@ impl String {
         }
     }
 
-    /// Creates a new string buffer from the given owned string, taking care not to copy it.
+    #[allow(missing_doc)]
+    #[deprecated = "obsoleted by the removal of ~str"]
     #[inline]
     pub fn from_owned_str(string: String) -> String {
         string