auto merge of #10709 : alexcrichton/rust/snapshot, r=pcwalton

4 files changed, 66 insertions, 69 deletions

diff --git a/src/libsyntax/parse/attr.rs b/src/libsyntax/parse/attr.rs
index 9030b4394e4..18e45a20fed 100644
--- a/src/libsyntax/parse/attr.rs
+++ b/src/libsyntax/parse/attr.rs
@@ -35,7 +35,7 @@ impl parser_attr for Parser {
             debug!("parse_outer_attributes: self.token={:?}",
                    self.token);
             match *self.token {
-              token::INTERPOLATED(token::nt_attr(*)) => {
+              token::INTERPOLATED(token::nt_attr(..)) => {
                 attrs.push(self.parse_attribute(false));
               }
               token::POUND => {
@@ -121,7 +121,7 @@ impl parser_attr for Parser {
         let mut next_outer_attrs: ~[ast::Attribute] = ~[];
         loop {
             let attr = match *self.token {
-                token::INTERPOLATED(token::nt_attr(*)) => {
+                token::INTERPOLATED(token::nt_attr(..)) => {
                     self.parse_attribute(true)
                 }
                 token::POUND => {
@@ -164,7 +164,7 @@ impl parser_attr for Parser {
                 // FIXME #623 Non-string meta items are not serialized correctly;
                 // just forbid them for now
                 match lit.node {
-                    ast::lit_str(*) => (),
+                    ast::lit_str(..) => (),
                     _ => {
                         self.span_err(
                             lit.span,
diff --git a/src/libsyntax/parse/classify.rs b/src/libsyntax/parse/classify.rs
index a4df5f4a5fc..81b98e537f4 100644
--- a/src/libsyntax/parse/classify.rs
+++ b/src/libsyntax/parse/classify.rs
@@ -23,12 +23,12 @@ use ast;
 // isn't parsed as (if true {...} else {...} | x) | 5
 pub fn expr_requires_semi_to_be_stmt(e: @ast::Expr) -> bool {
     match e.node {
-      ast::ExprIf(*)
-      | ast::ExprMatch(*)
+      ast::ExprIf(..)
+      | ast::ExprMatch(..)
       | ast::ExprBlock(_)
-      | ast::ExprWhile(*)
-      | ast::ExprLoop(*)
-      | ast::ExprForLoop(*)
+      | ast::ExprWhile(..)
+      | ast::ExprLoop(..)
+      | ast::ExprForLoop(..)
       | ast::ExprCall(_, _, ast::DoSugar)
       | ast::ExprCall(_, _, ast::ForSugar)
       | ast::ExprMethodCall(_, _, _, _, _, ast::DoSugar)
@@ -40,7 +40,7 @@ pub fn expr_requires_semi_to_be_stmt(e: @ast::Expr) -> bool {
 pub fn expr_is_simple_block(e: @ast::Expr) -> bool {
     match e.node {
         ast::ExprBlock(
-            ast::Block { rules: ast::DefaultBlock, _ }
+            ast::Block { rules: ast::DefaultBlock, .. }
         ) => true,
       _ => false
     }
@@ -58,7 +58,7 @@ pub fn stmt_ends_with_semi(stmt: &ast::Stmt) -> bool {
             }
         }
         ast::StmtExpr(e, _) => { expr_requires_semi_to_be_stmt(e) }
-        ast::StmtSemi(*) => { false }
-        ast::StmtMac(*) => { false }
+        ast::StmtSemi(..) => { false }
+        ast::StmtMac(..) => { false }
     }
 }
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index fab0de4179e..3e4a421cfba 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -447,7 +447,7 @@ impl Parser {
     pub fn commit_expr(&self, e: @Expr, edible: &[token::Token], inedible: &[token::Token]) {
         debug!("commit_expr {:?}", e);
         match e.node {
-            ExprPath(*) => {
+            ExprPath(..) => {
                 // might be unit-struct construction; check for recoverableinput error.
                 let expected = vec::append(edible.to_owned(), inedible);
                 self.check_for_erroneous_unit_struct_expecting(expected);
@@ -486,7 +486,7 @@ impl Parser {
                 self.bump();
                 i
             }
-            token::INTERPOLATED(token::nt_ident(*)) => {
+            token::INTERPOLATED(token::nt_ident(..)) => {
                 self.bug("ident interpolation not converted to real token");
             }
             _ => {
@@ -835,7 +835,7 @@ impl Parser {
 
     pub fn token_is_lifetime(&self, tok: &token::Token) -> bool {
         match *tok {
-            token::LIFETIME(*) => true,
+            token::LIFETIME(..) => true,
             _ => false,
         }
     }
@@ -1280,13 +1280,13 @@ impl Parser {
                                      -> ty_ {
         // ~'foo fn() or ~fn() are parsed directly as obsolete fn types:
         match *self.token {
-            token::LIFETIME(*) => {
+            token::LIFETIME(..) => {
                 let lifetime = self.parse_lifetime();
                 self.obsolete(*self.last_span, ObsoleteBoxedClosure);
                 return self.parse_ty_closure(Some(sigil), Some(lifetime));
             }
 
-            token::IDENT(*) => {
+            token::IDENT(..) => {
                 if self.token_is_old_style_closure_keyword() {
                     self.obsolete(*self.last_span, ObsoleteBoxedClosure);
                     return self.parse_ty_closure(Some(sigil), None);
@@ -1574,7 +1574,7 @@ impl Parser {
     /// parses 0 or 1 lifetime
     pub fn parse_opt_lifetime(&self) -> Option<ast::Lifetime> {
         match *self.token {
-            token::LIFETIME(*) => {
+            token::LIFETIME(..) => {
                 Some(self.parse_lifetime())
             }
             _ => {
@@ -2108,7 +2108,7 @@ impl Parser {
                     );
                     let (s, z) = p.parse_sep_and_zerok();
                     let seq = match seq {
-                        Spanned { node, _ } => node,
+                        Spanned { node, .. } => node,
                     };
                     tt_seq(
                         mk_sp(sp.lo, p.span.hi),
@@ -2274,13 +2274,13 @@ impl Parser {
                 hi = e.span.hi;
                 // HACK: turn &[...] into a &-evec
                 ex = match e.node {
-                  ExprVec(*) | ExprLit(@codemap::Spanned {
-                    node: lit_str(*), span: _
+                  ExprVec(..) | ExprLit(@codemap::Spanned {
+                    node: lit_str(..), span: _
                   })
                   if m == MutImmutable => {
                     ExprVstore(e, ExprVstoreSlice)
                   }
-                  ExprVec(*) if m == MutMutable => {
+                  ExprVec(..) if m == MutMutable => {
                     ExprVstore(e, ExprVstoreMutSlice)
                   }
                   _ => ExprAddrOf(m, e)
@@ -2296,11 +2296,11 @@ impl Parser {
             hi = e.span.hi;
             // HACK: turn @[...] into a @-evec
             ex = match e.node {
-              ExprVec(*) | ExprRepeat(*) if m == MutMutable =>
+              ExprVec(..) | ExprRepeat(..) if m == MutMutable =>
                 ExprVstore(e, ExprVstoreMutBox),
-              ExprVec(*) |
-              ExprLit(@codemap::Spanned { node: lit_str(*), span: _}) |
-              ExprRepeat(*) if m == MutImmutable => ExprVstore(e, ExprVstoreBox),
+              ExprVec(..) |
+              ExprLit(@codemap::Spanned { node: lit_str(..), span: _}) |
+              ExprRepeat(..) if m == MutImmutable => ExprVstore(e, ExprVstoreBox),
               _ => self.mk_unary(UnBox(m), e)
             };
           }
@@ -2311,9 +2311,9 @@ impl Parser {
             hi = e.span.hi;
             // HACK: turn ~[...] into a ~-evec
             ex = match e.node {
-              ExprVec(*) |
-              ExprLit(@codemap::Spanned { node: lit_str(*), span: _}) |
-              ExprRepeat(*) => ExprVstore(e, ExprVstoreUniq),
+              ExprVec(..) |
+              ExprLit(@codemap::Spanned { node: lit_str(..), span: _}) |
+              ExprRepeat(..) => ExprVstore(e, ExprVstoreUniq),
               _ => self.mk_unary(UnUniq, e)
             };
           }
@@ -2564,8 +2564,8 @@ impl Parser {
                                                  ~[last_arg],
                                                  sugar))
             }
-            ExprPath(*) | ExprCall(*) | ExprMethodCall(*) |
-                ExprParen(*) => {
+            ExprPath(..) | ExprCall(..) | ExprMethodCall(..) |
+                ExprParen(..) => {
                 let block = self.parse_lambda_block_expr();
                 let last_arg = self.mk_expr(block.span.lo, block.span.hi,
                                             ctor(block));
@@ -2742,18 +2742,17 @@ impl Parser {
                     let subpat = self.parse_pat();
                     match subpat {
                         @ast::Pat { id, node: PatWild, span } => {
-                            // NOTE #5830 activate after snapshot
-                            // self.obsolete(*self.span, ObsoleteVecDotDotWildcard);
+                            self.obsolete(*self.span, ObsoleteVecDotDotWildcard);
                             slice = Some(@ast::Pat {
                                 id: id,
                                 node: PatWildMulti,
                                 span: span
                             })
                         },
-                        @ast::Pat { node: PatIdent(_, _, _), _ } => {
+                        @ast::Pat { node: PatIdent(_, _, _), .. } => {
                             slice = Some(subpat);
                         }
-                        @ast::Pat { span, _ } => self.span_fatal(
+                        @ast::Pat { span, .. } => self.span_fatal(
                             span, "expected an identifier or nothing"
                         )
                     }
@@ -2782,8 +2781,7 @@ impl Parser {
 
             etc = *self.token == token::UNDERSCORE || *self.token == token::DOTDOT;
             if *self.token == token::UNDERSCORE {
-                // NOTE #5830 activate after snapshot
-                // self.obsolete(*self.span, ObsoleteStructWildcard);
+                self.obsolete(*self.span, ObsoleteStructWildcard);
             }
             if etc {
                 self.bump();
@@ -2848,8 +2846,8 @@ impl Parser {
             pat = match sub.node {
               PatLit(e@@Expr {
                 node: ExprLit(@codemap::Spanned {
-                    node: lit_str(*),
-                    span: _}), _
+                    node: lit_str(..),
+                    span: _}), ..
               }) => {
                 let vst = @Expr {
                     id: ast::DUMMY_NODE_ID,
@@ -2876,8 +2874,8 @@ impl Parser {
             pat = match sub.node {
               PatLit(e@@Expr {
                 node: ExprLit(@codemap::Spanned {
-                    node: lit_str(*),
-                    span: _}), _
+                    node: lit_str(..),
+                    span: _}), ..
               }) => {
                 let vst = @Expr {
                     id: ast::DUMMY_NODE_ID,
@@ -2904,8 +2902,8 @@ impl Parser {
               // HACK: parse &"..." as a literal of a borrowed str
               pat = match sub.node {
                   PatLit(e@@Expr {
-                      node: ExprLit(@codemap::Spanned {
-                            node: lit_str(*), span: _}), _
+                      node: ExprLit(@codemap::Spanned{ node: lit_str(..), .. }),
+                      ..
                   }) => {
                       let vst = @Expr {
                           id: ast::DUMMY_NODE_ID,
@@ -3056,8 +3054,7 @@ impl Parser {
                                 // This is a "top constructor only" pat
                                 self.bump();
                                 if is_star {
-                                    // NOTE #5830 activate after snapshot
-                                    // self.obsolete(*self.span, ObsoleteEnumWildcard);
+                                    self.obsolete(*self.span, ObsoleteEnumWildcard);
                                 }
                                 self.bump();
                                 self.expect(&token::RPAREN);
@@ -3330,7 +3327,7 @@ impl Parser {
             attrs_remaining: attrs_remaining,
             view_items: view_items,
             items: items,
-            _
+            ..
         } = self.parse_items_and_view_items(first_item_attrs,
                                             false, false);
 
@@ -3478,7 +3475,7 @@ impl Parser {
                     }
                     self.bump();
                 }
-                token::MOD_SEP | token::IDENT(*) => {
+                token::MOD_SEP | token::IDENT(..) => {
                     let tref = self.parse_trait_ref();
                     result.push(TraitTyParamBound(tref));
                 }
@@ -3702,7 +3699,7 @@ impl Parser {
                 sty_uniq(MutImmutable)
             }, self)
           }
-          token::IDENT(*) if self.is_self_ident() => {
+          token::IDENT(..) if self.is_self_ident() => {
             self.bump();
             sty_value(MutImmutable)
           }
@@ -3952,7 +3949,7 @@ impl Parser {
                         ref_id: node_id
                     })
                 }
-                ty_path(*) => {
+                ty_path(..) => {
                     self.span_err(ty.span,
                                   "bounded traits are only valid in type position");
                     None
@@ -4129,7 +4126,7 @@ impl Parser {
             attrs_remaining: attrs_remaining,
             view_items: view_items,
             items: starting_items,
-            _
+            ..
         } = self.parse_items_and_view_items(first_item_attrs, true, true);
         let mut items: ~[@item] = starting_items;
         let attrs_remaining_len = attrs_remaining.len();
@@ -4386,7 +4383,7 @@ impl Parser {
         }
 
         let (named, maybe_path, ident) = match *self.token {
-            token::IDENT(*) => {
+            token::IDENT(..) => {
                 let the_ident = self.parse_ident();
                 let path = if *self.token == token::EQ {
                     self.bump();
@@ -5046,16 +5043,16 @@ impl Parser {
                 }
                 iovi_view_item(view_item) => {
                     match view_item.node {
-                        view_item_use(*) => {
+                        view_item_use(..) => {
                             // `extern mod` must precede `use`.
                             extern_mod_allowed = false;
                         }
-                        view_item_extern_mod(*)
+                        view_item_extern_mod(..)
                         if !extern_mod_allowed => {
                             self.span_err(view_item.span,
                                           "\"extern mod\" declarations are not allowed here");
                         }
-                        view_item_extern_mod(*) => {}
+                        view_item_extern_mod(..) => {}
                     }
                     view_items.push(view_item);
                 }
diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs
index 4ad2c9a32c9..8f8b956315f 100644
--- a/src/libsyntax/parse/token.rs
+++ b/src/libsyntax/parse/token.rs
@@ -217,17 +217,17 @@ pub fn to_str(input: @ident_interner, t: &Token) -> ~str {
             _ => {
                 ~"an interpolated " +
                     match (*nt) {
-                      nt_item(*) => ~"item",
-                      nt_block(*) => ~"block",
-                      nt_stmt(*) => ~"statement",
-                      nt_pat(*) => ~"pattern",
-                      nt_attr(*) => fail!("should have been handled"),
-                      nt_expr(*) => fail!("should have been handled above"),
-                      nt_ty(*) => ~"type",
-                      nt_ident(*) => ~"identifier",
-                      nt_path(*) => ~"path",
-                      nt_tt(*) => ~"tt",
-                      nt_matchers(*) => ~"matcher sequence"
+                      nt_item(..) => ~"item",
+                      nt_block(..) => ~"block",
+                      nt_stmt(..) => ~"statement",
+                      nt_pat(..) => ~"pattern",
+                      nt_attr(..) => fail!("should have been handled"),
+                      nt_expr(..) => fail!("should have been handled above"),
+                      nt_ty(..) => ~"type",
+                      nt_ident(..) => ~"identifier",
+                      nt_path(..) => ~"path",
+                      nt_tt(..) => ~"tt",
+                      nt_matchers(..) => ~"matcher sequence"
                     }
             }
         }
@@ -260,10 +260,10 @@ pub fn can_begin_expr(t: &Token) -> bool {
       BINOP(OR) => true, // in lambda syntax
       OROR => true, // in lambda syntax
       MOD_SEP => true,
-      INTERPOLATED(nt_expr(*))
-      | INTERPOLATED(nt_ident(*))
-      | INTERPOLATED(nt_block(*))
-      | INTERPOLATED(nt_path(*)) => true,
+      INTERPOLATED(nt_expr(..))
+      | INTERPOLATED(nt_ident(..))
+      | INTERPOLATED(nt_block(..))
+      | INTERPOLATED(nt_path(..)) => true,
       _ => false
     }
 }
@@ -303,7 +303,7 @@ pub fn is_ident(t: &Token) -> bool {
 
 pub fn is_ident_or_path(t: &Token) -> bool {
     match *t {
-      IDENT(_, _) | INTERPOLATED(nt_path(*)) => true,
+      IDENT(_, _) | INTERPOLATED(nt_path(..)) => true,
       _ => false
     }
 }