Use '..' as slice wildcard in vectors

diff --git a/src/librustc/middle/cfg/construct.rs b/src/librustc/middle/cfg/construct.rs
index fce318f173e09e7f91eb0b32be3a46321a444f57..e014f41edcd9a23c63542e1d252ca976cd3868d9 100644 (file)
--- a/src/librustc/middle/cfg/construct.rs
+++ b/src/librustc/middle/cfg/construct.rs
@@ -97,7 +97,7 @@ fn pat(&mut self, pat: @ast::Pat, pred: CFGIndex) -> CFGIndex {
             ast::PatEnum(_, None) |
             ast::PatLit(*) |
             ast::PatRange(*) |
-            ast::PatWild => {
+            ast::PatWild | ast::PatWildMulti => {
                 self.add_node(pat.id, [pred])
             }
 

diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs
index 482ba43ae259ddbba93ea3ba8f7aee7a4eadbb99..3885ebfc4b65275d9024b1cd036ec93123f80a75 100644 (file)
--- a/src/librustc/middle/check_match.rs
+++ b/src/librustc/middle/check_match.rs
@@ -333,7 +333,7 @@ fn is_useful_specialized(cx: &MatchCheckCtxt,
 fn pat_ctor_id(cx: &MatchCheckCtxt, p: @Pat) -> Option<ctor> {
     let pat = raw_pat(p);
     match pat.node {
-      PatWild => { None }
+      PatWild | PatWildMulti => { None }
       PatIdent(_, _, _) | PatEnum(_, _) => {
         match cx.tcx.def_map.find(&pat.id) {
           Some(&DefVariant(_, id, _)) => Some(variant(id)),
@@ -369,7 +369,7 @@ fn pat_ctor_id(cx: &MatchCheckCtxt, p: @Pat) -> Option<ctor> {
 fn is_wild(cx: &MatchCheckCtxt, p: @Pat) -> bool {
     let pat = raw_pat(p);
     match pat.node {
-      PatWild => { true }
+      PatWild | PatWildMulti => { true }
       PatIdent(_, _, _) => {
         match cx.tcx.def_map.find(&pat.id) {
           Some(&DefVariant(_, _, _)) | Some(&DefStatic(*)) => { false }
@@ -532,6 +532,10 @@ fn wild() -> @Pat {
     @Pat {id: 0, node: PatWild, span: dummy_sp()}
 }
 
+fn wild_multi() -> @Pat {
+    @Pat {id: 0, node: PatWildMulti, span: dummy_sp()}
+}
+
 fn specialize(cx: &MatchCheckCtxt,
                   r: &[@Pat],
                   ctor_id: &ctor,
@@ -546,6 +550,9 @@ fn specialize(cx: &MatchCheckCtxt,
             PatWild => {
                 Some(vec::append(vec::from_elem(arity, wild()), r.tail()))
             }
+            PatWildMulti => {
+                Some(vec::append(vec::from_elem(arity, wild_multi()), r.tail()))
+            }
             PatIdent(_, _, _) => {
                 match cx.tcx.def_map.find(&pat_id) {
                     Some(&DefVariant(_, id, _)) => {
@@ -849,7 +856,7 @@ fn is_refutable(cx: &MatchCheckCtxt, pat: &Pat) -> bool {
       PatIdent(_, _, Some(sub)) => {
         is_refutable(cx, sub)
       }
-      PatWild | PatIdent(_, _, None) => { false }
+      PatWild | PatWildMulti | PatIdent(_, _, None) => { false }
       PatLit(@Expr {node: ExprLit(@Spanned { node: lit_nil, _}), _}) => {
         // "()"
         false

diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs
index bd2f69a1d03e6f2283eab0760c366d3f0f8a2cf2..d8f66419379136abbbfd3b08b1ade87a60353750 100644 (file)
--- a/src/librustc/middle/mem_categorization.rs
+++ b/src/librustc/middle/mem_categorization.rs
@@ -876,7 +876,7 @@ pub fn cat_pattern(&self,
         op(cmt, pat);
 
         match pat.node {
-          ast::PatWild => {
+          ast::PatWild | ast::PatWildMulti => {
             // _
           }
 

diff --git a/src/librustc/middle/pat_util.rs b/src/librustc/middle/pat_util.rs
index acdadacc083e23aaeb09ef725f841d493cfb97a8..878f0876918f0566ede34a6eb276dd275e1422f9 100644 (file)
--- a/src/librustc/middle/pat_util.rs
+++ b/src/librustc/middle/pat_util.rs
@@ -65,7 +65,7 @@ pub fn pat_is_binding(dm: resolve::DefMap, pat: @Pat) -> bool {
 pub fn pat_is_binding_or_wild(dm: resolve::DefMap, pat: @Pat) -> bool {
     match pat.node {
         PatIdent(*) => pat_is_binding(dm, pat),
-        PatWild => true,
+        PatWild | PatWildMulti => true,
         _ => false
     }
 }

diff --git a/src/librustc/middle/trans/_match.rs b/src/librustc/middle/trans/_match.rs
index 9dddf96e34d576580b5e2d3c69fa09f1a1b26ac8..b48260de766a7a44a981fed790f873e7f646b5fc 100644 (file)
--- a/src/librustc/middle/trans/_match.rs
+++ b/src/librustc/middle/trans/_match.rs
@@ -545,7 +545,7 @@ fn enter_default<'r>(bcx: @mut Block,
     // Collect all of the matches that can match against anything.
     let matches = do enter_match(bcx, dm, m, col, val) |p| {
         match p.node {
-          ast::PatWild | ast::PatTup(_) => Some(~[]),
+          ast::PatWild | ast::PatWildMulti | ast::PatTup(_) => Some(~[]),
           ast::PatIdent(_, _, None) if pat_is_binding(dm, p) => Some(~[]),
           _ => None
         }
@@ -2234,7 +2234,7 @@ fn bind_irrefutable_pat(bcx: @mut Block,
                 pat.span,
                 format!("vector patterns are never irrefutable!"));
         }
-        ast::PatWild | ast::PatLit(_) | ast::PatRange(_, _) => ()
+        ast::PatWild | ast::PatWildMulti | ast::PatLit(_) | ast::PatRange(_, _) => ()
     }
     return bcx;
 }

diff --git a/src/librustc/middle/trans/debuginfo.rs b/src/librustc/middle/trans/debuginfo.rs
index c6a33864620ad3f0756e8d426fc44c577baa8232..6c010e4f85b2f8f9b622222abca99cbdff2ae7da 100644 (file)
--- a/src/librustc/middle/trans/debuginfo.rs
+++ b/src/librustc/middle/trans/debuginfo.rs
@@ -2418,7 +2418,7 @@ fn walk_pattern(cx: &mut CrateContext,
                 }
             }
 
-            ast::PatWild => {
+            ast::PatWild | ast::PatWildMulti => {
                 scope_map.insert(pat.id, scope_stack.last().scope_metadata);
             }
 

diff --git a/src/librustc/middle/typeck/check/_match.rs b/src/librustc/middle/typeck/check/_match.rs
index 93c3d94f5dc69b7a661d47e4b1f448d3fac4f137..63f439e43e31119f97cc5d261dab6afafed28ad0 100644 (file)
--- a/src/librustc/middle/typeck/check/_match.rs
+++ b/src/librustc/middle/typeck/check/_match.rs
@@ -414,7 +414,7 @@ pub fn check_pat(pcx: &pat_ctxt, pat: @ast::Pat, expected: ty::t) {
     let tcx = pcx.fcx.ccx.tcx;
 
     match pat.node {
-      ast::PatWild => {
+      ast::PatWild | ast::PatWildMulti => {
         fcx.write_ty(pat.id, expected);
       }
       ast::PatLit(lt) => {

diff --git a/src/librustc/middle/typeck/check/regionck.rs b/src/librustc/middle/typeck/check/regionck.rs
index b21d36777c293e8515772dad4f2455fec1439d71..c3827037f15eec37793552d467b1e0605db2a9e9 100644 (file)
--- a/src/librustc/middle/typeck/check/regionck.rs
+++ b/src/librustc/middle/typeck/check/regionck.rs
@@ -1219,7 +1219,7 @@ fn link_ref_bindings_in_pat(
                rcx.fcx.pat_to_str(pat), guarantor);
 
         match pat.node {
-            ast::PatWild => {}
+            ast::PatWild | ast::PatWildMulti => {}
             ast::PatIdent(ast::BindByRef(_), _, opt_p) => {
                 link(rcx, pat.span, pat.id, guarantor);
 

diff --git a/src/librustdoc/clean.rs b/src/librustdoc/clean.rs
index f48ad25712d1226cd129f13637f6a1433f22406e..f0f2ca2db3350337be552335be8d76c90324f623 100644 (file)
--- a/src/librustdoc/clean.rs
+++ b/src/librustdoc/clean.rs
@@ -1137,6 +1137,7 @@ fn name_from_pat(p: &ast::Pat) -> ~str {
     use syntax::ast::*;
     match p.node {
         PatWild => ~"_",
+        PatWildMulti => ~"..",
         PatIdent(_, ref p, _) => path_to_str(p),
         PatEnum(ref p, _) => path_to_str(p),
         PatStruct(*) => fail!("tried to get argument name from pat_struct, \

diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index 88a8bbf7cf28f104fecda06bdb0e76c1796cf51a..79cf52d8da79d228a70c38b7c8a7c694bb43e97a 100644 (file)
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -337,6 +337,7 @@ pub enum BindingMode {
 #[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
 pub enum Pat_ {
     PatWild,
+    PatWildMulti,
     // A pat_ident may either be a new bound variable,
     // or a nullary enum (in which case the second field
     // is None).

diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
index ccae25dc012ac8866a643cf3850c17a5335e2543..fb50a890c43f5efbb1619d974603706d1fa2c719 100644 (file)
--- a/src/libsyntax/ast_util.rs
+++ b/src/libsyntax/ast_util.rs
@@ -657,7 +657,7 @@ pub fn walk_pat(pat: @Pat, it: &fn(@Pat) -> bool) -> bool {
                 slice.iter().advance(|&p| walk_pat(p, |p| it(p))) &&
                 after.iter().advance(|&p| walk_pat(p, |p| it(p)))
         }
-        PatWild | PatLit(_) | PatRange(_, _) | PatIdent(_, _, _) |
+        PatWild | PatWildMulti | PatLit(_) | PatRange(_, _) | PatIdent(_, _, _) |
         PatEnum(_, _) => {
             true
         }

diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index ea0ab95a45105358ce4aa269870049cdab3c8c2d..bd99f58cde9d14c06988fdd5392fae664da9e4af 100644 (file)
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -174,6 +174,7 @@ fn fold_arm(&self, a: &Arm) -> Arm {
     fn fold_pat(&self, p: @Pat) -> @Pat {
         let node = match p.node {
             PatWild => PatWild,
+            PatWildMulti => PatWildMulti,
             PatIdent(binding_mode, ref pth, ref sub) => {
                 PatIdent(binding_mode,
                          self.fold_path(pth),

diff --git a/src/libsyntax/parse/obsolete.rs b/src/libsyntax/parse/obsolete.rs
index 8fb96a3e07ae97da1e8362840c80140c8541408c..2af6d141aa17829b442e00e5b4ac7d5e0a030b51 100644 (file)
--- a/src/libsyntax/parse/obsolete.rs
+++ b/src/libsyntax/parse/obsolete.rs
@@ -40,7 +40,8 @@ pub enum ObsoleteSyntax {
     ObsoleteEmptyImpl,
     ObsoleteLoopAsContinue,
     ObsoleteEnumWildcard,
-    ObsoleteStructWildcard
+    ObsoleteStructWildcard,
+    ObsoleteVecDotDotWildcard
 }
 
 impl to_bytes::IterBytes for ObsoleteSyntax {
@@ -123,6 +124,10 @@ fn obsolete(&self, sp: Span, kind: ObsoleteSyntax) {
                 "struct wildcard",
                 "use `..` instead of `_` for matching trailing struct fields"
             ),
+            ObsoleteVecDotDotWildcard => (
+                "vec slice wildcard",
+                "use `..` instead of `.._` for matching slices"
+            ),
         };
 
         self.report(sp, kind, kind_str, desc);

diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index ea861305d9fcc3dca233c5f39e4e33e69a16a44b..1b2e18f3ca5142558db96f20a50a751c29995b95 100644 (file)
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -43,7 +43,7 @@
 use ast::{match_seq, match_tok, method, mt, BiMul, Mutability};
 use ast::{named_field, UnNeg, noreturn, UnNot, Pat, PatBox, PatEnum};
 use ast::{PatIdent, PatLit, PatRange, PatRegion, PatStruct};
-use ast::{PatTup, PatUniq, PatWild, private};
+use ast::{PatTup, PatUniq, PatWild, PatWildMulti, private};
 use ast::{BiRem, required};
 use ast::{ret_style, return_val, BiShl, BiShr, Stmt, StmtDecl};
 use ast::{StmtExpr, StmtSemi, StmtMac, struct_def, struct_field};
@@ -2724,17 +2724,35 @@ fn parse_pat_vec_elements(
                 }
             }
 
-            let subpat = self.parse_pat();
             if is_slice {
-                match subpat {
-                    @ast::Pat { node: PatWild, _ } => (),
-                    @ast::Pat { node: PatIdent(_, _, _), _ } => (),
-                    @ast::Pat { span, _ } => self.span_fatal(
-                        span, "expected an identifier or `_`"
-                    )
+                if *self.token == token::COMMA || *self.token == token::RBRACKET {
+                    slice = Some(@ast::Pat {
+                        id: ast::DUMMY_NODE_ID,
+                        node: PatWildMulti,
+                        span: *self.span,
+                    })
+                } else {
+                    let subpat = self.parse_pat();
+                    match subpat {
+                        @ast::Pat { id, node: PatWild, span } => {
+                            // NOTE #5830 activate after snapshot
+                            // self.obsolete(*self.span, ObsoleteVecDotDotWildcard);
+                            slice = Some(@ast::Pat {
+                                id: id,
+                                node: PatWildMulti,
+                                span: span
+                            })
+                        },
+                        @ast::Pat { node: PatIdent(_, _, _), _ } => {
+                            slice = Some(subpat);
+                        }
+                        @ast::Pat { span, _ } => self.span_fatal(
+                            span, "expected an identifier or nothing"
+                        )
+                    }
                 }
-                slice = Some(subpat);
             } else {
+                let subpat = self.parse_pat();
                 if before_slice {
                     before.push(subpat);
                 } else {
@@ -2757,7 +2775,7 @@ fn parse_pat_fields(&self) -> (~[ast::FieldPat], bool) {
 
             etc = *self.token == token::UNDERSCORE || *self.token == token::DOTDOT;
             if *self.token == token::UNDERSCORE {
-                // FIXME #5830 activate after snapshot
+                // NOTE #5830 activate after snapshot
                 // self.obsolete(*self.span, ObsoleteStructWildcard);
             }
             if etc {
@@ -3031,7 +3049,7 @@ pub fn parse_pat(&self) -> @Pat {
                                 // This is a "top constructor only" pat
                                 self.bump();
                                 if is_star {
-                                    // FIXME #5830 activate after snapshot
+                                    // NOTE #5830 activate after snapshot
                                     // self.obsolete(*self.span, ObsoleteEnumWildcard);
                                 }
                                 self.bump();

diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index 9c4803474d9d2e4b37e3fb2913b8c2024237910e..68af73d4a01cabd3499dcbc31a5fe3b7f3e1d46d 100644 (file)
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -1613,6 +1613,7 @@ pub fn print_pat(s: @ps, pat: &ast::Pat) {
      is that it doesn't matter */
     match pat.node {
       ast::PatWild => word(s.s, "_"),
+      ast::PatWildMulti => word(s.s, ".."),
       ast::PatIdent(binding_mode, ref path, sub) => {
           match binding_mode {
               ast::BindByRef(mutbl) => {
@@ -1701,7 +1702,12 @@ fn print_field(s: @ps, f: &ast::FieldPat) {
         }
         for &p in slice.iter() {
             if !before.is_empty() { word_space(s, ","); }
-            word(s.s, "..");
+            match p {
+                @ast::Pat { node: ast::PatWildMulti, _ } => {
+                    // this case is handled by print_pat
+                }
+                _ => word(s.s, ".."),
+            }
             print_pat(s, p);
             if !after.is_empty() { word_space(s, ","); }
         }

diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
index a195bfb77177cf22fb53b08e45a4dcc5b8133d5d..aa712cae5029a9ef2fdf3b65c62cedd211c88e18 100644 (file)
--- a/src/libsyntax/visit.rs
+++ b/src/libsyntax/visit.rs
@@ -375,7 +375,7 @@ pub fn walk_pat<E:Clone, V:Visitor<E>>(visitor: &mut V, pattern: &Pat, env: E) {
             visitor.visit_expr(lower_bound, env.clone());
             visitor.visit_expr(upper_bound, env)
         }
-        PatWild => (),
+        PatWild | PatWildMulti => (),
         PatVec(ref prepattern, ref slice_pattern, ref postpatterns) => {
             for prepattern in prepattern.iter() {
                 visitor.visit_pat(*prepattern, env.clone())

diff --git a/src/test/run-pass/ignore-all-the-things.rs b/src/test/run-pass/ignore-all-the-things.rs
index b71f139c684a91a13c63c59427f06f5701199075..b3b93c768d1e86af02473a9a7a7cffc4aee8c050 100644 (file)
--- a/src/test/run-pass/ignore-all-the-things.rs
+++ b/src/test/run-pass/ignore-all-the-things.rs
@@ -23,15 +23,21 @@ pub fn main() {
     //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] {
+    match [5, 5, 5, 5] {
+        [..] => { }
+    }
+    match [5, 5, 5, 5] {
         [a, ..] => { }
-    }*/
-    /*match [5, 5, 5, 5] {
+    }
+    match [5, 5, 5, 5] {
         [.., b] => { }
-    }*/
-    /*match [5, 5, 5, 5] {
+    }
+    match [5, 5, 5, 5] {
         [a, .., b] => { }
-    }*/
+    }
+    match [5, 5, 5] {
+        [.._] => { }
+    }
     match [5, 5, 5] {
         [a, .._] => { }
     }