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

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

4 files changed, 27 insertions, 11 deletions

diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs
index 001a693d1ae..2f166ae89ef 100644
--- a/src/libsyntax/parse/comments.rs
+++ b/src/libsyntax/parse/comments.rs
@@ -58,7 +58,8 @@ pub fn strip_doc_comment_decoration(comment: &str) -> ~str {
 
     /// remove whitespace-only lines from the start/end of lines
     fn vertical_trim(lines: ~[~str]) -> ~[~str] {
-        let mut i = 0u, j = lines.len();
+        let mut i = 0u;
+        let mut j = lines.len();
         while i < j && lines[i].trim().is_empty() {
             i += 1u;
         }
diff --git a/src/libsyntax/parse/lexer.rs b/src/libsyntax/parse/lexer.rs
index 0e04e719020..0eb933e6c3a 100644
--- a/src/libsyntax/parse/lexer.rs
+++ b/src/libsyntax/parse/lexer.rs
@@ -387,7 +387,10 @@ fn scan_digits(rdr: @mut StringReader, radix: uint) -> ~str {
 }
 
 fn scan_number(c: char, rdr: @mut StringReader) -> token::Token {
-    let mut num_str, base = 10u, c = c, n = nextch(rdr);
+    let mut num_str;
+    let mut base = 10u;
+    let mut c = c;
+    let mut n = nextch(rdr);
     if c == '0' && n == 'x' {
         bump(rdr);
         bump(rdr);
@@ -510,7 +513,8 @@ fn scan_number(c: char, rdr: @mut StringReader) -> token::Token {
 }
 
 fn scan_numeric_escape(rdr: @mut StringReader, n_hex_digits: uint) -> char {
-    let mut accum_int = 0, i = n_hex_digits;
+    let mut accum_int = 0;
+    let mut i = n_hex_digits;
     while i != 0u {
         let n = rdr.curr;
         bump(rdr);
diff --git a/src/libsyntax/parse/obsolete.rs b/src/libsyntax/parse/obsolete.rs
index f37b430b480..61b7f1403e6 100644
--- a/src/libsyntax/parse/obsolete.rs
+++ b/src/libsyntax/parse/obsolete.rs
@@ -64,6 +64,7 @@ pub enum ObsoleteSyntax {
     ObsoleteConstItem,
     ObsoleteFixedLengthVectorType,
     ObsoleteNamedExternModule,
+    ObsoleteMultipleLocalDecl,
 }
 
 impl to_bytes::IterBytes for ObsoleteSyntax {
@@ -224,6 +225,11 @@ impl Parser {
                 "instead of `extern mod foo { ... }`, write `mod foo { \
                  extern { ... } }`"
             ),
+            ObsoleteMultipleLocalDecl => (
+                "declaration of multiple locals at once",
+                "instead of e.g. `let a = 1, b = 2`, write \
+                 `let (a, b) = (1, 2)`."
+            ),
         };
 
         self.report(sp, kind, kind_str, desc);
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index dd966815ad2..23e3f145398 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -84,7 +84,7 @@ use parse::obsolete::ObsoleteMode;
 use parse::obsolete::{ObsoleteLifetimeNotation, ObsoleteConstManagedPointer};
 use parse::obsolete::{ObsoletePurity, ObsoleteStaticMethod};
 use parse::obsolete::{ObsoleteConstItem, ObsoleteFixedLengthVectorType};
-use parse::obsolete::{ObsoleteNamedExternModule};
+use parse::obsolete::{ObsoleteNamedExternModule, ObsoleteMultipleLocalDecl};
 use parse::token::{can_begin_expr, is_ident, is_ident_or_path};
 use parse::token::{is_plain_ident, INTERPOLATED, keywords, special_idents, token_to_binop};
 use parse::token;
@@ -2573,11 +2573,12 @@ impl Parser {
     fn parse_let(&self) -> @decl {
         let is_mutbl = self.eat_keyword(keywords::Mut);
         let lo = self.span.lo;
-        let mut locals = ~[self.parse_local(is_mutbl)];
+        let mut local = self.parse_local(is_mutbl);
         while self.eat(&token::COMMA) {
-            locals.push(self.parse_local(is_mutbl));
+            let _ = self.parse_local(is_mutbl);
+            self.obsolete(*self.span, ObsoleteMultipleLocalDecl);
         }
-        return @spanned(lo, self.last_span.hi, decl_local(locals));
+        return @spanned(lo, self.last_span.hi, decl_local(local));
     }
 
     // parse a structure field
@@ -3840,15 +3841,18 @@ impl Parser {
     // parse the part of an "enum" decl following the '{'
     fn parse_enum_def(&self, _generics: &ast::Generics) -> enum_def {
         let mut variants = ~[];
-        let mut all_nullary = true, have_disr = false;
+        let mut all_nullary = true;
+        let mut have_disr = false;
         while *self.token != token::RBRACE {
             let variant_attrs = self.parse_outer_attributes();
             let vlo = self.span.lo;
 
             let vis = self.parse_visibility();
 
-            let ident, kind;
-            let mut args = ~[], disr_expr = None;
+            let ident;
+            let kind;
+            let mut args = ~[];
+            let mut disr_expr = None;
             ident = self.parse_ident();
             if self.eat(&token::LBRACE) {
                 // Parse a struct variant.
@@ -4352,7 +4356,8 @@ impl Parser {
     }
 
     fn is_view_item(&self) -> bool {
-        let tok, next_tok;
+        let tok;
+        let next_tok;
         if !self.is_keyword(keywords::Pub) && !self.is_keyword(keywords::Priv) {
             tok = copy *self.token;
             next_tok = self.look_ahead(1);