librustc: Disallow multiple patterns from appearing in a "let" declaration.

You can still initialize multiple variables at once with "let (x, y) = (1, 2)".

Author: pcwalton

doc/rust.md

@@ -2325,7 +2325,9 @@ An example of a for loop over the contents of a vector:
 ~~~~
 # type foo = int;
 # fn bar(f: foo) { }
-# let a = 0, b = 0, c = 0;
+# let a = 0;
+# let b = 0;
+# let c = 0;
 
 let v: &[foo] = &[a, b, c];
 
@@ -3000,7 +3002,7 @@ allocated within the stack's memory. The value is a part of the stack frame.
 
 Local variables are immutable unless declared with `let mut`.  The
 `mut` keyword applies to all local variables declared within that
-declaration (so `let mut x, y` declares two mutable variables, `x` and
+declaration (so `let mut (x, y) = ...` declares two mutable variables, `x` and
 `y`).
 
 Function parameters are immutable unless declared with `mut`. The

doc/tutorial-ffi.md

@@ -159,8 +159,8 @@ pub struct Unique<T> {
     priv ptr: *mut T
 }
 
-pub impl<T: Owned> Unique<T> {
-    fn new(value: T) -> Unique<T> {
+impl<T: Owned> Unique<T> {
+    pub fn new(value: T) -> Unique<T> {
         unsafe {
             let ptr = malloc(std::sys::size_of::<T>() as size_t) as *mut T;
             assert!(!ptr::is_null(ptr));
@@ -171,12 +171,12 @@ pub impl<T: Owned> Unique<T> {
     }
 
     // the 'r lifetime results in the same semantics as `&*x` with ~T
-    fn borrow<'r>(&'r self) -> &'r T {
+    pub fn borrow<'r>(&'r self) -> &'r T {
         unsafe { cast::copy_lifetime(self, &*self.ptr) }
     }
 
     // the 'r lifetime results in the same semantics as `&mut *x` with ~T
-    fn borrow_mut<'r>(&'r mut self) -> &'r mut T {
+    pub fn borrow_mut<'r>(&'r mut self) -> &'r mut T {
         unsafe { cast::copy_mut_lifetime(self, &mut *self.ptr) }
     }
 }

doc/tutorial-macros.md

@@ -13,7 +13,8 @@ doing nothing otherwise:
 ~~~~
 # enum t { special_a(uint), special_b(uint) };
 # fn f() -> uint {
-# let input_1 = special_a(0), input_2 = special_a(0);
+# let input_1 = special_a(0);
+# let input_2 = special_a(0);
 match input_1 {
     special_a(x) => { return x; }
     _ => {}
@@ -38,7 +39,8 @@ the pattern in the above code:
 ~~~~
 # enum t { special_a(uint), special_b(uint) };
 # fn f() -> uint {
-# let input_1 = special_a(0), input_2 = special_a(0);
+# let input_1 = special_a(0);
+# let input_2 = special_a(0);
 macro_rules! early_return(
     ($inp:expr $sp:ident) => ( // invoke it like `(input_5 special_e)`
         match $inp {
@@ -155,7 +157,8 @@ instead of `*` to mean "at least one".
 ~~~~
 # enum t { special_a(uint),special_b(uint),special_c(uint),special_d(uint)};
 # fn f() -> uint {
-# let input_1 = special_a(0), input_2 = special_a(0);
+# let input_1 = special_a(0);
+# let input_2 = special_a(0);
 macro_rules! early_return(
     ($inp:expr, [ $($sp:ident)|+ ]) => (
         match $inp {

src/libextra/arena.rs

@@ -134,7 +134,7 @@ unsafe fn destroy_chunk(chunk: &Chunk) {
     while idx < fill {
         let tydesc_data: *uint = transmute(ptr::offset(buf, idx));
         let (tydesc, is_done) = un_bitpack_tydesc_ptr(*tydesc_data);
-        let size = (*tydesc).size, align = (*tydesc).align;
+        let (size, align) = ((*tydesc).size, (*tydesc).align);
 
         let after_tydesc = idx + sys::size_of::<*TypeDesc>();
 

src/libextra/fileinput.rs

@@ -194,8 +194,8 @@ impl FileInput {
     arguments. `"-"` represents `stdin`.
     */
     pub fn from_args() -> FileInput {
-        let args = os::args(),
-            pathed = pathify(args.tail(), true);
+        let args = os::args();
+        let pathed = pathify(args.tail(), true);
         FileInput::from_vec(pathed)
     }
 
@@ -222,11 +222,11 @@ impl FileInput {
             return false;
         }
 
-        let path_option = self.fi.files.shift(),
-            file = match path_option {
-                None => io::stdin(),
-                Some(ref path) => io::file_reader(path).get()
-            };
+        let path_option = self.fi.files.shift();
+        let file = match path_option {
+            None => io::stdin(),
+            Some(ref path) => io::file_reader(path).get()
+        };
 
         self.fi.current_reader = Some(file);
         self.fi.state.current_path = path_option;
@@ -431,8 +431,8 @@ mod test {
     #[test]
     fn test_pathify() {
         let strs = [~"some/path",
-                    ~"some/other/path"],
-            paths = ~[Some(Path("some/path")),
+                    ~"some/other/path"];
+        let paths = ~[Some(Path("some/path")),
                       Some(Path("some/other/path"))];
 
         assert_eq!(pathify(strs, true), copy paths);
@@ -561,8 +561,10 @@ mod test {
 
     #[test]
     fn test_no_trailing_newline() {
-        let f1 = Some(Path("tmp/lib-fileinput-test-no-trailing-newline-1.tmp")),
-            f2 = Some(Path("tmp/lib-fileinput-test-no-trailing-newline-2.tmp"));
+        let f1 =
+            Some(Path("tmp/lib-fileinput-test-no-trailing-newline-1.tmp"));
+        let f2 =
+            Some(Path("tmp/lib-fileinput-test-no-trailing-newline-2.tmp"));
 
         let wr = io::file_writer(f1.get_ref(), [io::Create, io::Truncate]).get();
         wr.write_str("1\n2");

src/libextra/md4.rs

@@ -58,9 +58,9 @@ pub fn md4(msg: &[u8]) -> Quad {
     let e = msg.len();
     let mut x = vec::from_elem(16u, 0u32);
     while i < e {
-        let aa = a, bb = b, cc = c, dd = d;
+        let (aa, bb, cc, dd) = (a, b, c, d);
 
-        let mut j = 0u, base = i;
+        let mut (j, base) = (0u, i);
         while j < 16u {
             x[j] = (msg[base] as u32) + (msg[base + 1u] as u32 << 8u32) +
                 (msg[base + 2u] as u32 << 16u32) +

src/libextra/net_url.rs

@@ -416,7 +416,7 @@ fn get_authority(rawurl: &str) ->
     let mut port = None;
 
     let mut colon_count = 0;
-    let mut pos = 0, begin = 2, end = len;
+    let mut (pos, begin, end) = (0, 2, len);
 
     for str::each_chari(rawurl) |i,c| {
         if i < 2 { loop; } // ignore the leading //

src/libextra/num/bigint.rs

@@ -125,7 +125,7 @@ impl Ord for BigUint {
 impl TotalOrd for BigUint {
 
     fn cmp(&self, other: &BigUint) -> Ordering {
-        let s_len = self.data.len(), o_len = other.data.len();
+        let (s_len, o_len) = (self.data.len(), other.data.len());
         if s_len < o_len { return Less; }
         if s_len > o_len { return Greater;  }
 
@@ -255,7 +255,7 @@ impl Mul<BigUint, BigUint> for BigUint {
     fn mul(&self, other: &BigUint) -> BigUint {
         if self.is_zero() || other.is_zero() { return Zero::zero(); }
 
-        let s_len = self.data.len(), o_len = other.data.len();
+        let (s_len, o_len) = (self.data.len(), other.data.len());
         if s_len == 1 { return mul_digit(other, self.data[0]);  }
         if o_len == 1 { return mul_digit(self,  other.data[0]); }
 
@@ -447,7 +447,7 @@ impl Integer for BigUint {
 
     fn gcd(&self, other: &BigUint) -> BigUint {
         // Use Euclid's algorithm
-        let mut m = copy *self, n = copy *other;
+        let mut (m, n) = (copy *self, copy *other);
         while !m.is_zero() {
             let temp = m;
             m = n % temp;
@@ -1002,8 +1002,8 @@ impl Integer for BigInt {
     fn div_mod_floor(&self, other: &BigInt) -> (BigInt, BigInt) {
         // m.sign == other.sign
         let (d_ui, m_ui) = self.data.div_rem(&other.data);
-        let d = BigInt::from_biguint(Plus, d_ui),
-            m = BigInt::from_biguint(Plus, m_ui);
+        let d = BigInt::from_biguint(Plus, d_ui);
+        let m = BigInt::from_biguint(Plus, m_ui);
         match (self.sign, other.sign) {
             (_,    Zero)   => fail!(),
             (Plus, Plus)  | (Zero, Plus)  => (d, m),

src/libextra/terminfo/parser/compiled.rs

@@ -160,7 +160,9 @@ pub static stringnames: &'static[&'static str] = &'static[ "cbt", "_", "cr", "cs
 
 /// Parse a compiled terminfo entry, using long capability names if `longnames` is true
 pub fn parse(file: @Reader, longnames: bool) -> Result<~TermInfo, ~str> {
-    let bnames, snames, nnames;
+    let bnames;
+    let snames;
+    let nnames;
 
     if longnames {
         bnames = boolfnames;

src/librustc/front/config.rs

@@ -140,9 +140,18 @@ fn fold_block(
         b.stmts.filter_mapped(|a| filter_stmt(cx, *a));
     let filtered_view_items =
         b.view_items.filter_mapped(|a| filter_view_item(cx, *a));
+    let filtered_view_items =
+        filtered_view_items.map(|x| fld.fold_view_item(*x));
+    let mut resulting_stmts = ~[];
+    for filtered_stmts.each |stmt| {
+        match fld.fold_stmt(*stmt) {
+            None => {}
+            Some(stmt) => resulting_stmts.push(stmt),
+        }
+    }
     ast::blk_ {
-        view_items: vec::map(filtered_view_items, |x| fld.fold_view_item(*x)),
-        stmts: vec::map(filtered_stmts, |x| fld.fold_stmt(*x)),
+        view_items: filtered_view_items,
+        stmts: resulting_stmts,
         expr: b.expr.map(|x| fld.fold_expr(*x)),
         id: b.id,
         rules: b.rules,