---

yaml
---
r: 44628
b: refs/heads/master
c: 8ee2d58
h: refs/heads/master
v: v3

Author: Kimundi

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: a782efc4f16fed52f1f82af5869bfb5285bbc3f4
+refs/heads/master: 8ee2d58683cd2dfe981b4c84b7538f44c7ec9cd2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d9689399d091c3265f00434a69c551a61c28dc
 refs/heads/try: ef355f6332f83371e4acf04fc4eb940ab41d78d3

trunk/doc/tutorial.md

@@ -114,8 +114,9 @@ for more information on them.
 
 When complete, `make install` will place several programs into
 `/usr/local/bin`: `rustc`, the Rust compiler; `rustdoc`, the
-API-documentation tool; `cargo`, the Rust package manager;
-and `rusti`, the Rust REPL.
+API-documentation tool; `rustpkg`, the Rust package manager;
+`rusti`, the Rust REPL; and `rust`, a tool which acts both as a unified
+interface for them, and for a few common command line scenarios.
 
 [wiki-start]: https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust
 [tarball]: http://static.rust-lang.org/dist/rust-0.5.tar.gz
@@ -154,6 +155,25 @@ declaration to appear at the top level of the file: all statements must
 live inside a function.  Rust programs can also be compiled as
 libraries, and included in other programs.
 
+## Using the rust tool
+
+While using `rustc` directly to generate your executables, and then
+running them manually is a perfectly valid way to test your code,
+for smaller projects, prototypes, or if you're a beginner, it might be
+more convenient to use the `rust` tool.
+
+You use it by calling it with one of the supported commands, followed by
+arguments for that command. For example `rust build foo.rs` calls the
+`build` command with the argument `foo.rs`.
+
+The commands are:
+  - `build`, `doc`, `pkg` and `sketch`, which simply forward all arguments
+     to the included programs `rustc`, `rustdoc`, `rustpkg` and `rusti`.
+  - `run` and `test`, which both accept one source file and, using `rustc`,
+    produce either a normal or a test executable in the current working
+    directory and run it.
+  - `help`, which prints out the usage text of one of the commands.
+
 ## Editing Rust code
 
 There are vim highlighting and indentation scripts in the Rust source
@@ -2184,7 +2204,7 @@ impl Circle for CircleStruct {
 }
 impl Shape for CircleStruct {
     fn area(&self) -> float { pi * square(self.radius) }
-}   
+}
 ~~~~
 
 Notice that methods of `Circle` can call methods on `Shape`, as our

trunk/src/libcore/to_str.rs

@@ -43,8 +43,6 @@ impl ToStr for @str {
     pure fn to_str(&self) -> ~str { ::str::from_slice(*self) }
 }
 
-// FIXME #4898: impl for one-tuples
-
 impl<A: ToStr, B: ToStr> ToStr for (A, B) {
     #[inline(always)]
     pure fn to_str(&self) -> ~str {

trunk/src/libcore/tuple.rs

@@ -111,8 +111,6 @@ impl<A: Copy, B: Copy> ExtendedTupleOps<A,B> for (~[A], ~[B]) {
     }
 }
 
-// FIXME #4898: impl for one-tuples
-
 #[cfg(notest)]
 impl<A: Eq, B: Eq> Eq for (A, B) {
     #[inline(always)]

trunk/src/librustc/middle/typeck/check/mod.rs

@@ -1198,7 +1198,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
 
                     tcx.sess.span_err(sp, msg);
 
-                    vec::from_fn(supplied_arg_count, |_| ty::mk_err(tcx))
+                    vec::from_fn(expected_arg_count, |_| ty::mk_err(tcx))
                 };
 
                 sig.output

trunk/src/libsyntax/parse/parser.rs

@@ -576,21 +576,12 @@ pub impl Parser {
                 self.bump();
                 ty_nil
             } else {
-                // (t) is a parenthesized ty
-                // (t,) is the type of a tuple with only one field,
-                // of type t
                 let mut ts = ~[self.parse_ty(false)];
-                let mut one_tuple = false;
                 while self.token == token::COMMA {
                     self.bump();
-                    if self.token != token::RPAREN {
-                        ts.push(self.parse_ty(false));
-                    }
-                    else {
-                        one_tuple = true;
-                    }
+                    ts.push(self.parse_ty(false));
                 }
-                let t = if ts.len() == 1 && !one_tuple { ts[0].node }
+                let t = if vec::len(ts) == 1u { ts[0].node }
                 else { ty_tup(ts) };
                 self.expect(token::RPAREN);
                 t
@@ -1070,9 +1061,6 @@ pub impl Parser {
 
         if self.token == token::LPAREN {
             self.bump();
-            // (e) is parenthesized e
-            // (e,) is a tuple with only one field, e
-            let mut one_tuple = false;
             if self.token == token::RPAREN {
                 hi = self.span.hi;
                 self.bump();
@@ -1081,18 +1069,12 @@ pub impl Parser {
             }
             let mut es = ~[self.parse_expr()];
             while self.token == token::COMMA {
-                self.bump();
-                if self.token != token::RPAREN {
-                    es.push(self.parse_expr());
-                }
-                else {
-                    one_tuple = true;
-                }
+                self.bump(); es.push(self.parse_expr());
             }
             hi = self.span.hi;
             self.expect(token::RPAREN);
 
-            return if es.len() == 1 && !one_tuple {
+            return if es.len() == 1 {
                 self.mk_expr(lo, self.span.hi, expr_paren(es[0]))
             }
             else {
@@ -2176,13 +2158,11 @@ pub impl Parser {
                 pat = pat_lit(expr);
             } else {
                 let mut fields = ~[self.parse_pat(refutable)];
-                if self.look_ahead(1) != token::RPAREN {
-                    while self.token == token::COMMA {
-                        self.bump();
-                        fields.push(self.parse_pat(refutable));
-                    }
+                while self.token == token::COMMA {
+                    self.bump();
+                    fields.push(self.parse_pat(refutable));
                 }
-                if fields.len() == 1 { self.expect(token::COMMA); }
+                if vec::len(fields) == 1u { self.expect(token::COMMA); }
                 hi = self.span.hi;
                 self.expect(token::RPAREN);
                 pat = pat_tup(fields);

trunk/src/libsyntax/print/pprust.rs

@@ -414,9 +414,6 @@ pub fn print_type_ex(s: @ps, &&ty: @ast::Ty, print_colons: bool) {
       ast::ty_tup(elts) => {
         popen(s);
         commasep(s, inconsistent, elts, print_type);
-        if elts.len() == 1 {
-            word(s.s, ~",");
-        }
         pclose(s);
       }
       ast::ty_bare_fn(f) => {
@@ -1202,9 +1199,6 @@ pub fn print_expr(s: @ps, &&expr: @ast::expr) {
       ast::expr_tup(exprs) => {
         popen(s);
         commasep_exprs(s, inconsistent, exprs);
-        if exprs.len() == 1 {
-            word(s.s, ~",");
-        }
         pclose(s);
       }
       ast::expr_call(func, args, sugar) => {
@@ -1640,9 +1634,6 @@ pub fn print_pat(s: @ps, &&pat: @ast::pat, refutable: bool) {
       ast::pat_tup(elts) => {
         popen(s);
         commasep(s, inconsistent, elts, |s, p| print_pat(s, p, refutable));
-        if elts.len() == 1 {
-            word(s.s, ~",");
-        }
         pclose(s);
       }
       ast::pat_box(inner) => {

trunk/src/test/bench/core-map.rs

@@ -302,26 +302,26 @@ fn main() {
         }
     };
 
-    let seed = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    let seed = ~[1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 
     {
-        let rng = rand::seeded_rng(seed);
+        let rng = rand::seeded_rng(&seed);
         let mut results = empty_results();
         old_int_benchmarks(rng, num_keys, &mut results);
         old_str_benchmarks(rng, num_keys, &mut results);
         write_results("std::oldmap::HashMap", &results);
     }
 
     {
-        let rng = rand::seeded_rng(seed);
+        let rng = rand::seeded_rng(&seed);
         let mut results = empty_results();
         linear_int_benchmarks(rng, num_keys, &mut results);
         linear_str_benchmarks(rng, num_keys, &mut results);
         write_results("core::hashmap::linear::LinearMap", &results);
     }
 
     {
-        let rng = rand::seeded_rng(seed);
+        let rng = rand::seeded_rng(&seed);
         let mut results = empty_results();
         tree_int_benchmarks(rng, num_keys, &mut results);
         tree_str_benchmarks(rng, num_keys, &mut results);

trunk/src/test/bench/core-set.rs

@@ -152,27 +152,27 @@ fn main() {
         }
     };
 
-    let seed = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    let seed = ~[1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
     let max = 200000;
 
     {
-        let rng = rand::seeded_rng(seed);
+        let rng = rand::seeded_rng(&seed);
         let mut results = empty_results();
         results.bench_int(rng, num_keys, max, || LinearSet::new::<uint>());
         results.bench_str(rng, num_keys, || LinearSet::new::<~str>());
         write_results("core::hashmap::LinearSet", &results);
     }
 
     {
-        let rng = rand::seeded_rng(seed);
+        let rng = rand::seeded_rng(&seed);
         let mut results = empty_results();
         results.bench_int(rng, num_keys, max, || TreeSet::new::<uint>());
         results.bench_str(rng, num_keys, || TreeSet::new::<~str>());
         write_results("std::treemap::TreeSet", &results);
     }
 
     {
-        let rng = rand::seeded_rng(seed);
+        let rng = rand::seeded_rng(&seed);
         let mut results = empty_results();
         results.bench_int(rng, num_keys, max, || BitvSet::new());
         write_results("std::bitv::BitvSet", &results);

trunk/src/test/compile-fail/issue-4935.rs

@@ -636,12 +636,11 @@ struct Triple { x: int, y: int, z: int }
 
 pub fn main() {
     unsafe {
-        let r = (1,2,3,true,false, Triple {x:5,y:4,z:3}, (12,));
+        let r = (1,2,3,true,false, Triple {x:5,y:4,z:3});
         let p = ptr::addr_of(&r) as *c_void;
         let u = my_visitor(@Stuff {mut ptr1: p,
                              mut ptr2: p,
-                             mut vals: ~[]
-                                  });
+                             mut vals: ~[]});
         let v = ptr_visit_adaptor(Inner {inner: u});
         let td = get_tydesc_for(r);
         unsafe { error!("tydesc sz: %u, align: %u",
@@ -654,7 +653,7 @@ pub fn main() {
         }
         error!("%?", copy u.vals);
         assert u.vals == ~[
-            ~"1", ~"2", ~"3", ~"true", ~"false", ~"5", ~"4", ~"3", ~"12"
+            ~"1", ~"2", ~"3", ~"true", ~"false", ~"5", ~"4", ~"3"
         ];
     }
  }