---

yaml
---
r: 58346
b: refs/heads/auto
c: 82164a1
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -14,6 +14,6 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 82f963e347fa16ac3824e81c53f5d15155fe319b
+refs/heads/auto: 82164a1e45ab8155bb9716a850a68fa3212f7fb5
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c

branches/auto/doc/tutorial.md

@@ -129,7 +129,7 @@ we have a file `hello.rs` containing this program:
 
 ~~~~
 fn main() {
-    io::println("hello?");
+    println("hello?");
 }
 ~~~~
 
@@ -139,12 +139,12 @@ Windows) which, upon running, will likely do exactly what you expect.
 
 The Rust compiler tries to provide useful information when it encounters an
 error. If you introduce an error into the program (for example, by changing
-`io::println` to some nonexistent function), and then compile it, you'll see
+`println` to some nonexistent function), and then compile it, you'll see
 an error message like this:
 
 ~~~~ {.notrust}
-hello.rs:2:4: 2:16 error: unresolved name: io::print_with_unicorns
-hello.rs:2     io::print_with_unicorns("hello?");
+hello.rs:2:4: 2:16 error: unresolved name: print_with_unicorns
+hello.rs:2     print_with_unicorns("hello?");
                ^~~~~~~~~~~~~~~~~~~~~~~
 ~~~~
 
@@ -227,7 +227,7 @@ let hi = "hi";
 let mut count = 0;
 
 while count < 10 {
-    io::println(fmt!("count: %?", count));
+    println(fmt!("count: %?", count));
     count += 1;
 }
 ~~~~
@@ -400,10 +400,10 @@ don't match the types of the arguments.
 ~~~~
 # let mystery_object = ();
 
-io::println(fmt!("%s is %d", "the answer", 43));
+println(fmt!("%s is %d", "the answer", 43));
 
 // %? will conveniently print any type
-io::println(fmt!("what is this thing: %?", mystery_object));
+println(fmt!("what is this thing: %?", mystery_object));
 ~~~~
 
 [pf]: http://en.cppreference.com/w/cpp/io/c/fprintf
@@ -422,11 +422,11 @@ compulsory, an `if` can have an optional `else` clause, and multiple
 
 ~~~~
 if false {
-    io::println("that's odd");
+    println("that's odd");
 } else if true {
-    io::println("right");
+    println("right");
 } else {
-    io::println("neither true nor false");
+    println("neither true nor false");
 }
 ~~~~
 
@@ -454,10 +454,10 @@ executes its corresponding arm.
 ~~~~
 # let my_number = 1;
 match my_number {
-  0     => io::println("zero"),
-  1 | 2 => io::println("one or two"),
-  3..10 => io::println("three to ten"),
-  _     => io::println("something else")
+  0     => println("zero"),
+  1 | 2 => println("one or two"),
+  3..10 => println("three to ten"),
+  _     => println("something else")
 }
 ~~~~
 
@@ -483,8 +483,8 @@ commas are optional.
 ~~~
 # let my_number = 1;
 match my_number {
-  0 => { io::println("zero") }
-  _ => { io::println("something else") }
+  0 => { println("zero") }
+  _ => { println("something else") }
 }
 ~~~
 
@@ -560,7 +560,7 @@ let mut x = 5;
 loop {
     x += x - 3;
     if x % 5 == 0 { break; }
-    io::println(int::to_str(x));
+    println(int::to_str(x));
 }
 ~~~~
 
@@ -614,8 +614,8 @@ origin.y += 1.0; // ERROR: assigning to immutable field
 # struct Point { x: float, y: float }
 # let mypoint = Point { x: 0.0, y: 0.0 };
 match mypoint {
-    Point { x: 0.0, y: yy } => { io::println(yy.to_str());                     }
-    Point { x: xx,  y: yy } => { io::println(xx.to_str() + " " + yy.to_str()); }
+    Point { x: 0.0, y: yy } => { println(yy.to_str());                     }
+    Point { x: xx,  y: yy } => { println(xx.to_str() + " " + yy.to_str()); }
 }
 ~~~~
 
@@ -630,7 +630,7 @@ reuses the field name as the binding name.
 # struct Point { x: float, y: float }
 # let mypoint = Point { x: 0.0, y: 0.0 };
 match mypoint {
-    Point { x, _ } => { io::println(x.to_str()) }
+    Point { x, _ } => { println(x.to_str()) }
 }
 ~~~
 
@@ -1231,7 +1231,7 @@ something silly like
 ~~~
 # struct Point { x: float, y: float }
 let point = &@~Point { x: 10f, y: 20f };
-io::println(fmt!("%f", point.x));
+println(fmt!("%f", point.x));
 ~~~
 
 The indexing operator (`[]`) also auto-dereferences.
@@ -1373,7 +1373,6 @@ and [`core::str`]. Here are some examples.
 [`core::str`]: core/str.html
 
 ~~~
-# use core::io::println;
 # enum Crayon {
 #     Almond, AntiqueBrass, Apricot,
 #     Aquamarine, Asparagus, AtomicTangerine,
@@ -1428,7 +1427,6 @@ Rust also supports _closures_, functions that can access variables in
 the enclosing scope.
 
 ~~~~
-# use println = core::io::println;
 fn call_closure_with_ten(b: &fn(int)) { b(10); }
 
 let captured_var = 20;
@@ -1490,7 +1488,7 @@ fn mk_appender(suffix: ~str) -> @fn(~str) -> ~str {
 
 fn main() {
     let shout = mk_appender(~"!");
-    io::println(shout(~"hey ho, let's go"));
+    println(shout(~"hey ho, let's go"));
 }
 ~~~~
 
@@ -1632,7 +1630,6 @@ And using this function to iterate over a vector:
 
 ~~~~
 # use each = core::vec::each;
-# use println = core::io::println;
 each([2, 4, 8, 5, 16], |n| {
     if *n % 2 != 0 {
         println("found odd number!");
@@ -1649,7 +1646,6 @@ to the next iteration, write `loop`.
 
 ~~~~
 # use each = core::vec::each;
-# use println = core::io::println;
 for each([2, 4, 8, 5, 16]) |n| {
     if *n % 2 != 0 {
         println("found odd number!");
@@ -1982,7 +1978,7 @@ struct TimeBomb {
 impl Drop for TimeBomb {
     fn finalize(&self) {
         for old_iter::repeat(self.explosivity) {
-            io::println("blam!");
+            println("blam!");
         }
     }
 }
@@ -2014,11 +2010,11 @@ and `~str`.
 ~~~~
 # trait Printable { fn print(&self); }
 impl Printable for int {
-    fn print(&self) { io::println(fmt!("%d", *self)) }
+    fn print(&self) { println(fmt!("%d", *self)) }
 }
 
 impl Printable for ~str {
-    fn print(&self) { io::println(*self) }
+    fn print(&self) { println(*self) }
 }
 
 # 1.print();
@@ -2307,7 +2303,7 @@ mod farm {
 }
 
 fn main() {
-    io::println(farm::chicken());
+    println(farm::chicken());
 }
 ~~~~
 
@@ -2507,7 +2503,7 @@ pub fn explore() -> &str { "world" }
 ~~~~ {.xfail-test}
 // main.rs
 extern mod world;
-fn main() { io::println(~"hello " + world::explore()); }
+fn main() { println(~"hello " + world::explore()); }
 ~~~~
 
 Now compile and run like this (adjust to your platform if necessary):

branches/auto/src/libcore/old_iter.rs

@@ -93,7 +93,7 @@ pub trait CopyableNonstrictIter<A:Copy> {
     // Like "each", but copies out the value. If the receiver is mutated while
     // iterating over it, the semantics must not be memory-unsafe but are
     // otherwise undefined.
-    fn each_val(&const self, f: &fn(A) -> bool) -> bool;
+    fn each_val(&const self, f: &fn(A) -> bool);
 }
 
 // A trait for sequences that can be built by imperatively pushing elements

branches/auto/src/libcore/vec.rs

@@ -2945,37 +2945,34 @@ impl<A:Copy + Ord> old_iter::CopyableOrderedIter<A> for @[A] {
 }
 
 impl<'self,A:Copy> old_iter::CopyableNonstrictIter<A> for &'self [A] {
-    fn each_val(&const self, f: &fn(A) -> bool) -> bool {
+    fn each_val(&const self, f: &fn(A) -> bool) {
         let mut i = 0;
         while i < self.len() {
-            if !f(copy self[i]) { return false; }
+            if !f(copy self[i]) { break; }
             i += 1;
         }
-        return true;
     }
 }
 
 // FIXME(#4148): This should be redundant
 impl<A:Copy> old_iter::CopyableNonstrictIter<A> for ~[A] {
-    fn each_val(&const self, f: &fn(A) -> bool) -> bool {
+    fn each_val(&const self, f: &fn(A) -> bool) {
         let mut i = 0;
         while i < uniq_len(self) {
-            if !f(copy self[i]) { return false; }
+            if !f(copy self[i]) { break; }
             i += 1;
         }
-        return true;
     }
 }
 
 // FIXME(#4148): This should be redundant
 impl<A:Copy> old_iter::CopyableNonstrictIter<A> for @[A] {
-    fn each_val(&const self, f: &fn(A) -> bool) -> bool {
+    fn each_val(&const self, f: &fn(A) -> bool) {
         let mut i = 0;
         while i < self.len() {
-            if !f(copy self[i]) { return false; }
+            if !f(copy self[i]) { break; }
             i += 1;
         }
-        return true;
     }
 }
 
@@ -4691,14 +4688,4 @@ mod tests {
             i += 1;
         }
     }
-
-    #[test]
-    fn test_each_val() {
-        use old_iter::CopyableNonstrictIter;
-        let mut i = 0;
-        for [1, 2, 3].each_val |v| {
-            i += v;
-        }
-        assert!(i == 6);
-    }
 }

branches/auto/src/librustc/middle/resolve.rs

@@ -1007,7 +1007,7 @@ pub impl Resolver {
                     let ns = namespace_for_duplicate_checking_mode(
                         duplicate_checking_mode);
                     self.session.span_err(sp,
-                        fmt!("duplicate definition of %s %s",
+                        fmt!("duplicate definition of %s `%s`",
                              namespace_to_str(ns),
                              *self.session.str_of(name)));
                     for child.span_for_namespace(ns).each |sp| {
@@ -1959,7 +1959,7 @@ pub impl Resolver {
             match self.resolve_import_for_module(module, import_directive) {
                 Failed => {
                     // We presumably emitted an error. Continue.
-                    let msg = fmt!("failed to resolve import: %s",
+                    let msg = fmt!("failed to resolve import `%s`",
                                    *self.import_path_to_str(
                                        import_directive.module_path,
                                        *import_directive.subclass));
@@ -2488,7 +2488,7 @@ pub impl Resolver {
                         self.session.span_err(span {lo: span.lo, hi: span.lo +
                                               BytePos(str::len(*segment_name)), expn_info:
                                               span.expn_info}, fmt!("unresolved import. maybe \
-                                                                    a missing 'extern mod %s'?",
+                                                                    a missing `extern mod %s`?",
                                                                     *segment_name));
                         return Failed;
                     }
@@ -2511,7 +2511,7 @@ pub impl Resolver {
                                     // Not a module.
                                     self.session.span_err(span,
                                                           fmt!("not a \
-                                                                module: %s",
+                                                                module `%s`",
                                                                *self.session.
                                                                    str_of(
                                                                     name)));
@@ -2525,7 +2525,7 @@ pub impl Resolver {
                         None => {
                             // There are no type bindings at all.
                             self.session.span_err(span,
-                                                  fmt!("not a module: %s",
+                                                  fmt!("not a module `%s`",
                                                        *self.session.str_of(
                                                             name)));
                             return Failed;
@@ -2976,7 +2976,7 @@ pub impl Resolver {
         }
 
         // We're out of luck.
-        debug!("(resolving name in module) failed to resolve %s",
+        debug!("(resolving name in module) failed to resolve `%s`",
                *self.session.str_of(name));
         return Failed;
     }
@@ -4158,7 +4158,7 @@ pub impl Resolver {
                                       // in the same disjunct, which is an
                                       // error
                                      self.session.span_err(pattern.span,
-                                       fmt!("Identifier %s is bound more \
+                                       fmt!("Identifier `%s` is bound more \
                                              than once in the same pattern",
                                             path_to_str(path, self.session
                                                         .intr())));
@@ -4199,7 +4199,7 @@ pub impl Resolver {
                         Some(_) => {
                             self.session.span_err(
                                 path.span,
-                                fmt!("not an enum variant or constant: %s",
+                                fmt!("`%s` is not an enum variant or constant",
                                      *self.session.str_of(
                                          *path.idents.last())));
                         }
@@ -4227,7 +4227,7 @@ pub impl Resolver {
                         Some(_) => {
                             self.session.span_err(
                                 path.span,
-                                fmt!("not an enum variant, struct or const: %s",
+                                fmt!("`%s` is not an enum variant, struct or const",
                                      *self.session.str_of(
                                          *path.idents.last())));
                         }
@@ -4723,8 +4723,8 @@ pub impl Resolver {
                             path.idents);
                         if self.name_exists_in_scope_struct(wrong_name) {
                             self.session.span_err(expr.span,
-                                        fmt!("unresolved name: `%s`. \
-                                            Did you mean: `self.%s`?",
+                                        fmt!("unresolved name `%s`. \
+                                            Did you mean `self.%s`?",
                                         wrong_name,
                                         wrong_name));
                         }
@@ -4734,13 +4734,13 @@ pub impl Resolver {
                             match self.find_best_match_for_name(wrong_name, 5) {
                                 Some(m) => {
                                     self.session.span_err(expr.span,
-                                            fmt!("unresolved name: `%s`. \
-                                                Did you mean: `%s`?",
+                                            fmt!("unresolved name `%s`. \
+                                                Did you mean `%s`?",
                                                 wrong_name, m));
                                 }
                                 None => {
                                     self.session.span_err(expr.span,
-                                            fmt!("unresolved name: `%s`.",
+                                            fmt!("unresolved name `%s`.",
                                                 wrong_name));
                                 }
                             }