Use '..' as multi-field wildcard in enums and structs.

diff --git a/src/libsyntax/parse/obsolete.rs b/src/libsyntax/parse/obsolete.rs
index 20ad13dace61cac672a05f330d7519b7ed8d32a9..8fb96a3e07ae97da1e8362840c80140c8541408c 100644 (file)
--- a/src/libsyntax/parse/obsolete.rs
+++ b/src/libsyntax/parse/obsolete.rs
@@ -39,6 +39,8 @@ pub enum ObsoleteSyntax {
     ObsoleteConstPointer,
     ObsoleteEmptyImpl,
     ObsoleteLoopAsContinue,
+    ObsoleteEnumWildcard,
+    ObsoleteStructWildcard
 }
 
 impl to_bytes::IterBytes for ObsoleteSyntax {
@@ -113,6 +115,14 @@ fn obsolete(&self, sp: Span, kind: ObsoleteSyntax) {
                 "`loop` is now only used for loops and `continue` is used for \
                  skipping iterations"
             ),
+            ObsoleteEnumWildcard => (
+                "enum wildcard",
+                "use `..` instead of `*` for matching all enum fields"
+            ),
+            ObsoleteStructWildcard => (
+                "struct wildcard",
+                "use `..` instead of `_` for matching trailing struct fields"
+            ),
         };
 
         self.report(sp, kind, kind_str, desc);

diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index ad5da0b9289365667507715481097da9ef461adf..ea861305d9fcc3dca233c5f39e4e33e69a16a44b 100644 (file)
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -2755,7 +2755,12 @@ fn parse_pat_fields(&self) -> (~[ast::FieldPat], bool) {
             if first { first = false; }
             else { self.expect(&token::COMMA); }
 
+            etc = *self.token == token::UNDERSCORE || *self.token == token::DOTDOT;
             if *self.token == token::UNDERSCORE {
+                // FIXME #5830 activate after snapshot
+                // self.obsolete(*self.span, ObsoleteStructWildcard);
+            }
+            if etc {
                 self.bump();
                 if *self.token != token::RBRACE {
                     self.fatal(
@@ -3016,9 +3021,19 @@ pub fn parse_pat(&self) -> @Pat {
                                     _ => false,
                                 }
                             };
-                            if is_star {
+                            let is_dotdot = do self.look_ahead(1) |t| {
+                                match *t {
+                                    token::DOTDOT => true,
+                                    _ => false,
+                                }
+                            };
+                            if is_star | is_dotdot {
                                 // This is a "top constructor only" pat
                                 self.bump();
+                                if is_star {
+                                    // FIXME #5830 activate after snapshot
+                                    // self.obsolete(*self.span, ObsoleteEnumWildcard);
+                                }
                                 self.bump();
                                 self.expect(&token::RPAREN);
                                 pat = PatEnum(enum_path, None);

diff --git a/src/test/run-pass/ignore-all-the-things.rs b/src/test/run-pass/ignore-all-the-things.rs
new file mode 100644 (file)
index 0000000..b71f139
--- /dev/null
+++ b/src/test/run-pass/ignore-all-the-things.rs
@@ -0,0 +1,44 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+struct Foo(int, int, int, int);
+struct Bar{a: int, b: int, c: int, d: int}
+
+pub fn main() {
+    let Foo(..) = Foo(5, 5, 5, 5);
+    let Foo(*) = Foo(5, 5, 5, 5);
+    let Bar{..} = Bar{a: 5, b: 5, c: 5, d: 5};
+    let Bar{_} = Bar{a: 5, b: 5, c: 5, d: 5};
+    //let (..) = (5, 5, 5, 5);
+    //let Foo(a, b, ..) = Foo(5, 5, 5, 5);
+    //let Foo(.., d) = Foo(5, 5, 5, 5);
+    //let (a, b, ..) = (5, 5, 5, 5);
+    //let (.., c, d) = (5, 5, 5, 5);
+    let Bar{b: b, ..} = Bar{a: 5, b: 5, c: 5, d: 5};
+    let Bar{b: b, _} = Bar{a: 5, b: 5, c: 5, d: 5};
+    /*match [5, 5, 5, 5] {
+        [a, ..] => { }
+    }*/
+    /*match [5, 5, 5, 5] {
+        [.., b] => { }
+    }*/
+    /*match [5, 5, 5, 5] {
+        [a, .., b] => { }
+    }*/
+    match [5, 5, 5] {
+        [a, .._] => { }
+    }
+    match [5, 5, 5] {
+        [.._, a] => { }
+    }
+    match [5, 5, 5] {
+        [a, .._, b] => { }
+    }
+}