Address comments in lowering + parsing.

src/librustc/hir/lowering.rs

@@ -4186,7 +4186,7 @@ impl<'a> LoweringContext<'a> {
                     ParamMode::Optional,
                     ImplTraitContext::disallowed(),
                 );
-                let (pats, ddpos) = self.lower_pat_tuple(&*pats, "tuple struct");
+                let (pats, ddpos) = self.lower_pat_tuple(pats, "tuple struct");
                 hir::PatKind::TupleStruct(qpath, pats, ddpos)
             }
             PatKind::Path(ref qself, ref path) => {
@@ -4225,7 +4225,7 @@ impl<'a> LoweringContext<'a> {
                 hir::PatKind::Struct(qpath, fs, etc)
             }
             PatKind::Tuple(ref pats) => {
-                let (pats, ddpos) = self.lower_pat_tuple(&*pats, "tuple");
+                let (pats, ddpos) = self.lower_pat_tuple(pats, "tuple");
                 hir::PatKind::Tuple(pats, ddpos)
             }
             PatKind::Box(ref inner) => hir::PatKind::Box(self.lower_pat(inner)),
@@ -4246,7 +4246,7 @@ impl<'a> LoweringContext<'a> {
             PatKind::Mac(_) => panic!("Shouldn't exist here"),
         };
 
-        self.pat_bound(p, node)
+        self.pat_with_node_id_of(p, node)
     }
 
     fn lower_pat_tuple(
@@ -4292,14 +4292,14 @@ impl<'a> LoweringContext<'a> {
             match pat.node {
                 PatKind::Rest => {
                     prev_rest_span = Some(pat.span);
-                    slice = Some(self.pat_bound_wild(pat));
+                    slice = Some(self.pat_wild_with_node_id_of(pat));
                     break;
                 },
                 PatKind::Ident(ref bm, ident, Some(ref sub)) if sub.is_rest() => {
                     prev_rest_span = Some(sub.span);
-                    let lower_sub = |this: &mut Self| Some(this.pat_bound_wild(sub));
+                    let lower_sub = |this: &mut Self| Some(this.pat_wild_with_node_id_of(sub));
                     let node = self.lower_pat_ident(pat, bm, ident, lower_sub);
-                    slice = Some(self.pat_bound(pat, node));
+                    slice = Some(self.pat_with_node_id_of(pat, node));
                     break;
                 },
                 _ => {}
@@ -4315,7 +4315,7 @@ impl<'a> LoweringContext<'a> {
                 PatKind::Rest => Some(pat.span),
                 PatKind::Ident(.., Some(ref sub)) if sub.is_rest() => {
                     // The `HirValidator` is merciless; add a `_` pattern to avoid ICEs.
-                    after.push(self.pat_bound_wild(pat));
+                    after.push(self.pat_wild_with_node_id_of(pat));
                     Some(sub.span)
                 },
                 _ => None,
@@ -4363,12 +4363,12 @@ impl<'a> LoweringContext<'a> {
         }
     }
 
-    fn pat_bound_wild(&mut self, p: &Pat) -> P<hir::Pat> {
-        self.pat_bound(p, hir::PatKind::Wild)
+    fn pat_wild_with_node_id_of(&mut self, p: &Pat) -> P<hir::Pat> {
+        self.pat_with_node_id_of(p, hir::PatKind::Wild)
     }
 
     /// Construct a `Pat` with the `HirId` of `p.id` lowered.
-    fn pat_bound(&mut self, p: &Pat, node: hir::PatKind) -> P<hir::Pat> {
+    fn pat_with_node_id_of(&mut self, p: &Pat, node: hir::PatKind) -> P<hir::Pat> {
         P(hir::Pat {
             hir_id: self.lower_node_id(p.id),
             node,

src/libsyntax/parse/parser.rs

@@ -3747,8 +3747,9 @@ impl<'a> Parser<'a> {
         })
     }
 
-    /// Parse a parentesized comma separated sequence of patterns until `delim` is reached.
-    fn parse_recover_pat_list(&mut self) -> PResult<'a, ()> {
+    /// Parse and throw away a parentesized comma separated
+    /// sequence of patterns until `)` is reached.
+    fn skip_pat_list(&mut self) -> PResult<'a, ()> {
         while !self.check(&token::CloseDelim(token::Paren)) {
             self.parse_pat(None)?;
             if !self.eat(&token::Comma) {
@@ -3771,7 +3772,7 @@ impl<'a> Parser<'a> {
             // later.
             let comma_span = self.token.span;
             self.bump();
-            if let Err(mut err) = self.parse_recover_pat_list() {
+            if let Err(mut err) = self.skip_pat_list() {
                 // We didn't expect this to work anyway; we just wanted
                 // to advance to the end of the comma-sequence so we know
                 // the span to suggest parenthesizing
@@ -3876,9 +3877,11 @@ impl<'a> Parser<'a> {
                 pat = PatKind::Ref(subpat, mutbl);
             }
             token::OpenDelim(token::Paren) => {
-                // Parse `(pat, pat, pat, ...)` as tuple pattern.
+                // Parse a tuple or parenthesis pattern.
                 let (fields, trailing_comma) = self.parse_paren_comma_seq(|p| p.parse_pat(None))?;
 
+                // Here, `(pat,)` is a tuple pattern.
+                // For backward compatibility, `(..)` is a tuple pattern as well.
                 pat = if fields.len() == 1 && !(trailing_comma || fields[0].is_rest()) {
                     PatKind::Paren(fields.into_iter().nth(0).unwrap())
                 } else {