---

yaml
---
r: 120496
b: refs/heads/dist-snap
c: b991bbe
h: refs/heads/master
v: v3

Author: lilyball

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 1813e5aa1a03b0596b8de7abd1af31edf5d6098f
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: ec8ec54192cdc47a22f4fec8b636354e8db0b6a7
+refs/heads/dist-snap: b991bbe2d0f148d25d00a8c17bfa6304d1b1ae5a
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/libcollections/bitv.rs

@@ -486,13 +486,17 @@ impl Bitv {
         !self.none()
     }
 
+    pub fn init_to_vec(&self, i: uint) -> uint {
+      return if self.get(i) { 1 } else { 0 };
+    }
+
     /**
      * Converts `self` to a vector of `uint` with the same length.
      *
      * Each `uint` in the resulting vector has either value `0u` or `1u`.
      */
     pub fn to_vec(&self) -> Vec<uint> {
-        Vec::from_fn(self.nbits, |i| if self.get(i) { 1 } else { 0 })
+        Vec::from_fn(self.nbits, |x| self.init_to_vec(x))
     }
 
     /**

branches/dist-snap/src/libcore/iter.rs

@@ -2184,7 +2184,7 @@ pub mod order {
     use super::Iterator;
 
     /// Compare `a` and `b` for equality using `TotalEq`
-    pub fn equals<A: TotalEq, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool {
+    pub fn equals<A: TotalEq, T: Iterator<A>>(mut a: T, mut b: T) -> bool {
         loop {
             match (a.next(), b.next()) {
                 (None, None) => return true,
@@ -2195,7 +2195,7 @@ pub mod order {
     }
 
     /// Order `a` and `b` lexicographically using `TotalOrd`
-    pub fn cmp<A: TotalOrd, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> cmp::Ordering {
+    pub fn cmp<A: TotalOrd, T: Iterator<A>>(mut a: T, mut b: T) -> cmp::Ordering {
         loop {
             match (a.next(), b.next()) {
                 (None, None) => return cmp::Equal,
@@ -2210,7 +2210,7 @@ pub mod order {
     }
 
     /// Compare `a` and `b` for equality (Using partial equality, `Eq`)
-    pub fn eq<A: Eq, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool {
+    pub fn eq<A: Eq, T: Iterator<A>>(mut a: T, mut b: T) -> bool {
         loop {
             match (a.next(), b.next()) {
                 (None, None) => return true,
@@ -2221,7 +2221,7 @@ pub mod order {
     }
 
     /// Compare `a` and `b` for nonequality (Using partial equality, `Eq`)
-    pub fn ne<A: Eq, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool {
+    pub fn ne<A: Eq, T: Iterator<A>>(mut a: T, mut b: T) -> bool {
         loop {
             match (a.next(), b.next()) {
                 (None, None) => return false,
@@ -2232,7 +2232,7 @@ pub mod order {
     }
 
     /// Return `a` < `b` lexicographically (Using partial order, `Ord`)
-    pub fn lt<A: Ord, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool {
+    pub fn lt<A: Ord, T: Iterator<A>>(mut a: T, mut b: T) -> bool {
         loop {
             match (a.next(), b.next()) {
                 (None, None) => return false,
@@ -2244,7 +2244,7 @@ pub mod order {
     }
 
     /// Return `a` <= `b` lexicographically (Using partial order, `Ord`)
-    pub fn le<A: Ord, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool {
+    pub fn le<A: Ord, T: Iterator<A>>(mut a: T, mut b: T) -> bool {
         loop {
             match (a.next(), b.next()) {
                 (None, None) => return true,
@@ -2256,7 +2256,7 @@ pub mod order {
     }
 
     /// Return `a` > `b` lexicographically (Using partial order, `Ord`)
-    pub fn gt<A: Ord, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool {
+    pub fn gt<A: Ord, T: Iterator<A>>(mut a: T, mut b: T) -> bool {
         loop {
             match (a.next(), b.next()) {
                 (None, None) => return false,
@@ -2268,7 +2268,7 @@ pub mod order {
     }
 
     /// Return `a` >= `b` lexicographically (Using partial order, `Ord`)
-    pub fn ge<A: Ord, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool {
+    pub fn ge<A: Ord, T: Iterator<A>>(mut a: T, mut b: T) -> bool {
         loop {
             match (a.next(), b.next()) {
                 (None, None) => return true,
@@ -2325,16 +2325,6 @@ pub mod order {
         assert!(gt(c.iter(), b.iter()) == (c[0] >  b[0]));
         assert!(ge(c.iter(), b.iter()) == (c[0] >= b[0]));
     }
-
-    #[test]
-    fn test_multi_iter() {
-        use slice::ImmutableVector;
-        use iter::DoubleEndedIterator;
-        let xs = [1i,2,3,4];
-        let ys = [4i,3,2,1];
-        assert!(eq(xs.iter(), ys.iter().rev()));
-        assert!(lt(xs.iter(), xs.iter().skip(2)));
-    }
 }
 
 #[cfg(test)]

branches/dist-snap/src/libcore/lib.rs

@@ -17,7 +17,7 @@
 //!
 //! * `memcpy`, `memcmp`, `memset` - These are core memory routines which are
 //!   often generated by LLVM. Additionally, this library can make explicit
-//!   calls to these functions. Their signatures are the same as found in C.
+//!   calls to these funcitons. Their signatures are the same as found in C.
 //!   These functions are often provided by the system libc, but can also be
 //!   provided by `librlibc` which is distributed with the standard rust
 //!   distribution.

branches/dist-snap/src/libcore/result.rs

@@ -508,19 +508,12 @@ impl<T, E> Result<T, E> {
     /// Unwraps a result, yielding the content of an `Ok`.
     /// If the value is an `Err` then it calls `op` with its value.
     #[inline]
-    pub fn unwrap_or_else(self, op: |E| -> T) -> T {
+    pub fn unwrap_or_handle(self, op: |E| -> T) -> T {
         match self {
             Ok(t) => t,
             Err(e) => op(e)
         }
     }
-
-    /// Deprecated name for `unwrap_or_else()`.
-    #[deprecated = "replaced by .unwrap_or_else()"]
-    #[inline]
-    pub fn unwrap_or_handle(self, op: |E| -> T) -> T {
-        self.unwrap_or_else(op)
-    }
 }
 
 impl<T, E: Show> Result<T, E> {
@@ -765,8 +758,8 @@ mod tests {
         let ok: Result<int, ~str> = Ok(100);
         let ok_err: Result<int, ~str> = Err("I got this.".to_owned());
 
-        assert_eq!(ok.unwrap_or_else(handler), 100);
-        assert_eq!(ok_err.unwrap_or_else(handler), 50);
+        assert_eq!(ok.unwrap_or_handle(handler), 100);
+        assert_eq!(ok_err.unwrap_or_handle(handler), 50);
     }
 
     #[test]
@@ -781,6 +774,6 @@ mod tests {
         }
 
         let bad_err: Result<int, ~str> = Err("Unrecoverable mess.".to_owned());
-        let _ : int = bad_err.unwrap_or_else(handler);
+        let _ : int = bad_err.unwrap_or_handle(handler);
     }
 }

branches/dist-snap/src/librustc/middle/resolve.rs

@@ -4891,25 +4891,6 @@ impl<'a> Resolver<'a> {
     }
 
     fn find_fallback_in_self_type(&mut self, name: Name) -> FallbackSuggestion {
-        #[deriving(Eq)]
-        enum FallbackChecks {
-            Everything,
-            OnlyTraitAndStatics
-        }
-
-        fn extract_path_and_node_id(t: &Ty, allow: FallbackChecks)
-                                                    -> Option<(Path, NodeId, FallbackChecks)> {
-            match t.node {
-                TyPath(ref path, _, node_id) => Some((path.clone(), node_id, allow)),
-                TyPtr(mut_ty) => extract_path_and_node_id(mut_ty.ty, OnlyTraitAndStatics),
-                TyRptr(_, mut_ty) => extract_path_and_node_id(mut_ty.ty, allow),
-                // This doesn't handle the remaining `Ty` variants as they are not
-                // that commonly the self_type, it might be interesting to provide
-                // support for those in future.
-                _ => None,
-            }
-        }
-
         fn get_module(this: &mut Resolver, span: Span, ident_path: &[ast::Ident])
                             -> Option<Rc<Module>> {
             let root = this.current_module.clone();
@@ -4937,29 +4918,27 @@ impl<'a> Resolver<'a> {
             }
         }
 
-        let (path, node_id, allowed) = match self.current_self_type {
-            Some(ref ty) => match extract_path_and_node_id(ty, Everything) {
-                Some(x) => x,
-                None => return NoSuggestion,
+        let (path, node_id) = match self.current_self_type {
+            Some(ref ty) => match ty.node {
+                TyPath(ref path, _, node_id) => (path.clone(), node_id),
+                _ => unreachable!(),
             },
             None => return NoSuggestion,
         };
 
-        if allowed == Everything {
-            // Look for a field with the same name in the current self_type.
-            match self.def_map.borrow().find(&node_id) {
-                 Some(&DefTy(did))
-                | Some(&DefStruct(did))
-                | Some(&DefVariant(_, did, _)) => match self.structs.find(&did) {
-                    None => {}
-                    Some(fields) => {
-                        if fields.iter().any(|&field_name| name == field_name) {
-                            return Field;
-                        }
+        // Look for a field with the same name in the current self_type.
+        match self.def_map.borrow().find(&node_id) {
+             Some(&DefTy(did))
+            | Some(&DefStruct(did))
+            | Some(&DefVariant(_, did, _)) => match self.structs.find(&did) {
+                None => {}
+                Some(fields) => {
+                    if fields.iter().any(|&field_name| name == field_name) {
+                        return Field;
                     }
-                },
-                _ => {} // Self type didn't resolve properly
-            }
+                }
+            },
+            _ => {} // Self type didn't resolve properly
         }
 
         let ident_path = path.segments.iter().map(|seg| seg.identifier).collect::<Vec<_>>();
@@ -4976,8 +4955,8 @@ impl<'a> Resolver<'a> {
                                 FromTrait(_) => unreachable!()
                             }
                         }
-                        Some(DefMethod(_, None)) if allowed == Everything => return Method,
-                        Some(DefMethod(_, Some(_))) => return TraitMethod,
+                        Some(DefMethod(_, None)) => return Method,
+                        Some(DefMethod(_, _)) => return TraitMethod,
                         _ => ()
                     }
                 }

branches/dist-snap/src/libsyntax/diagnostic.rs

@@ -232,8 +232,27 @@ fn print_maybe_styled(w: &mut EmitterWriter,
     match w.dst {
         Terminal(ref mut t) => {
             try!(t.attr(color));
-            try!(t.write_str(msg));
-            try!(t.reset());
+            // If `msg` ends in a newline, we need to reset the color before
+            // the newline. We're making the assumption that we end up writing
+            // to a `LineBufferedWriter`, which means that emitting the reset
+            // after the newline ends up buffering the reset until we print
+            // another line or exit. Buffering the reset is a problem if we're
+            // sharing the terminal with any other programs (e.g. other rustc
+            // instances via `make -jN`).
+            //
+            // Note that if `msg` contains any internal newlines, this will
+            // result in the `LineBufferedWriter` flushing twice instead of
+            // once, which still leaves the opportunity for interleaved output
+            // to be miscolored. We assume this is rare enough that we don't
+            // have to worry about it.
+            if msg.ends_with("\n") {
+                try!(t.write_str(msg.slice_to(msg.len()-1)));
+                try!(t.reset());
+                try!(t.write_str("\n"));
+            } else {
+                try!(t.write_str(msg));
+                try!(t.reset());
+            }
             Ok(())
         }
         Raw(ref mut w) => {