---

yaml
---
r: 6633
b: refs/heads/master
c: 9a269a3
h: refs/heads/master
i:
  6631: 3b69b36
v: v3

Author: marijnh

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 8c966b7b18a5529c33dd9766460880bd681ab102
+refs/heads/master: 9a269a3aa8fe8140ad3f2fc2cfdfd68d6b40ec86

trunk/src/comp/middle/alias.rs

@@ -585,8 +585,9 @@ fn pattern_roots(tcx: ty::ctxt, mut: option::t<unsafe_ty>, pat: @ast::pat)
             &set: [pattern_root]) {
         alt pat.node {
           ast::pat_wild. | ast::pat_lit(_) | ast::pat_range(_, _) {}
-          ast::pat_bind(nm) {
+          ast::pat_bind(nm, sub) {
             set += [{id: pat.id, name: nm, mut: mut, span: pat.span}];
+            alt sub { some(p) { walk(tcx, mut, p, set); } _ {} }
           }
           ast::pat_tag(_, ps) | ast::pat_tup(ps) {
             for p in ps { walk(tcx, mut, p, set); }

trunk/src/comp/middle/check_alt.rs

@@ -2,6 +2,7 @@ import syntax::ast::*;
 import syntax::ast_util::{variant_def_ids, dummy_sp, compare_lit_exprs,
                           lit_expr_eq};
 import syntax::visit;
+import std::option::{some, none};
 
 fn check_crate(tcx: ty::ctxt, crate: @crate) {
     let v =
@@ -64,57 +65,58 @@ fn pattern_supersedes(tcx: ty::ctxt, a: @pat, b: @pat) -> bool {
     }
 
     alt a.node {
-      pat_wild. | pat_bind(_) { ret true; }
+      pat_bind(_, some(p)) { pattern_supersedes(tcx, p, b) }
+      pat_wild. | pat_bind(_, none.) { true }
       pat_lit(la) {
         alt b.node {
-          pat_lit(lb) { ret lit_expr_eq(la, lb); }
-          _ { ret false; }
+          pat_lit(lb) { lit_expr_eq(la, lb) }
+          _ { false }
         }
       }
       pat_tag(va, suba) {
         alt b.node {
           pat_tag(vb, subb) {
-            ret tcx.def_map.get(a.id) == tcx.def_map.get(b.id) &&
-                    patterns_supersede(tcx, suba, subb);
+            tcx.def_map.get(a.id) == tcx.def_map.get(b.id) &&
+                patterns_supersede(tcx, suba, subb)
           }
-          _ { ret false; }
+          _ { false }
         }
       }
       pat_rec(suba, _) {
         alt b.node {
-          pat_rec(subb, _) { ret field_patterns_supersede(tcx, suba, subb); }
-          _ { ret false; }
+          pat_rec(subb, _) { field_patterns_supersede(tcx, suba, subb) }
+          _ { false }
         }
       }
       pat_tup(suba) {
         alt b.node {
-          pat_tup(subb) { ret patterns_supersede(tcx, suba, subb); }
-          _ { ret false; }
+          pat_tup(subb) { patterns_supersede(tcx, suba, subb) }
+          _ { false }
         }
       }
       pat_box(suba) {
         alt b.node {
-          pat_box(subb) { ret pattern_supersedes(tcx, suba, subb); }
-          _ { ret pattern_supersedes(tcx, suba, b); }
+          pat_box(subb) { pattern_supersedes(tcx, suba, subb) }
+          _ { pattern_supersedes(tcx, suba, b) }
         }
       }
       pat_uniq(suba) {
         alt b.node {
-          pat_uniq(subb) { ret pattern_supersedes(tcx, suba, subb); }
-          _ { ret pattern_supersedes(tcx, suba, b); }
+          pat_uniq(subb) { pattern_supersedes(tcx, suba, subb) }
+          _ { pattern_supersedes(tcx, suba, b) }
         }
       }
       pat_range(begina, enda) {
         alt b.node {
           pat_lit(lb) {
-            ret compare_lit_exprs(begina, lb) <= 0 &&
-                compare_lit_exprs(enda, lb) >= 0;
+            compare_lit_exprs(begina, lb) <= 0 &&
+            compare_lit_exprs(enda, lb) >= 0
           }
           pat_range(beginb, endb) {
-            ret compare_lit_exprs(begina, beginb) <= 0 &&
-                compare_lit_exprs(enda, endb) >= 0;
+            compare_lit_exprs(begina, beginb) <= 0 &&
+            compare_lit_exprs(enda, endb) >= 0
           }
-          _ { ret false; }
+          _ { false }
         }
       }
     }
@@ -130,25 +132,26 @@ fn check_local(tcx: ty::ctxt, loc: @local, &&s: (), v: visit::vt<()>) {
 
 fn is_refutable(tcx: ty::ctxt, pat: @pat) -> bool {
     alt pat.node {
-      pat_wild. | pat_bind(_) { ret false; }
-      pat_lit(_) { ret true; }
-      pat_box(sub) { ret is_refutable(tcx, sub); }
-      pat_uniq(sub) { ret is_refutable(tcx, sub); }
+      pat_box(sub) | pat_uniq(sub) | pat_bind(_, some(sub)) {
+        is_refutable(tcx, sub)
+      }
+      pat_wild. | pat_bind(_, none.) { false }
+      pat_lit(_) { true }
       pat_rec(fields, _) {
         for field: field_pat in fields {
             if is_refutable(tcx, field.pat) { ret true; }
         }
-        ret false;
+        false
       }
       pat_tup(elts) {
         for elt in elts { if is_refutable(tcx, elt) { ret true; } }
-        ret false;
+        false
       }
       pat_tag(_, args) {
         let vdef = variant_def_ids(tcx.def_map.get(pat.id));
         if std::vec::len(ty::tag_variants(tcx, vdef.tg)) != 1u { ret true; }
         for p: @pat in args { if is_refutable(tcx, p) { ret true; } }
-        ret false;
+        false
       }
     }
 }

trunk/src/comp/middle/resolve.rs

@@ -819,7 +819,7 @@ fn lookup_in_ty_params(name: ident, ty_params: [ast::ty_param]) ->
 fn lookup_in_pat(name: ident, pat: @ast::pat) -> option::t<def_id> {
     let found = none;
     ast_util::pat_bindings(pat) {|bound|
-        let p_name = alt bound.node { ast::pat_bind(n) { n } };
+        let p_name = alt bound.node { ast::pat_bind(n, _) { n } };
         if str::eq(p_name, name) { found = some(local_def(bound.id)); }
     };
     ret found;
@@ -1376,7 +1376,7 @@ fn check_item(e: @env, i: @ast::item, &&x: (), v: vt<()>) {
 
 fn check_pat(ch: checker, p: @ast::pat) {
     ast_util::pat_bindings(p) {|p|
-        let ident = alt p.node { pat_bind(n) { n } };
+        let ident = alt p.node { pat_bind(n, _) { n } };
         add_name(ch, p.span, ident);
     };
 }
@@ -1424,7 +1424,7 @@ fn check_block(e: @env, b: ast::blk, &&x: (), v: vt<()>) {
                 let local_values = checker(*e, "value");
                 for (_, loc) in locs {
                     ast_util::pat_bindings(loc.node.pat) {|p|
-                        let ident = alt p.node { pat_bind(n) { n } };
+                        let ident = alt p.node { pat_bind(n, _) { n } };
                         add_name(local_values, p.span, ident);
                         check_name(values, p.span, ident);
                     };

trunk/src/comp/middle/trans.rs

@@ -4702,7 +4702,7 @@ fn alloc_ty(cx: @block_ctxt, t: ty::t) -> result {
 fn alloc_local(cx: @block_ctxt, local: @ast::local) -> @block_ctxt {
     let t = node_id_type(bcx_ccx(cx), local.node.id);
     let is_simple = alt local.node.pat.node {
-      ast::pat_bind(_) { true } _ { false }
+      ast::pat_bind(_, none.) { true } _ { false }
     };
     // Do not allocate space for locals that can be kept immediate.
     let ccx = bcx_ccx(cx);
@@ -4716,7 +4716,7 @@ fn alloc_local(cx: @block_ctxt, local: @ast::local) -> @block_ctxt {
     }
     let r = alloc_ty(cx, t);
     alt local.node.pat.node {
-      ast::pat_bind(ident) {
+      ast::pat_bind(ident, none.) {
         if bcx_ccx(cx).sess.get_opts().debuginfo {
             let _: () = str::as_buf(ident, {|buf|
                 llvm::LLVMSetValueName(r.val, buf)

trunk/src/comp/middle/trans_alt.rs

@@ -88,14 +88,31 @@ type match_branch =
               id_map: ast_util::pat_id_map}};
 type match = [match_branch];
 
-fn matches_always(p: @ast::pat) -> bool {
-    ret alt p.node {
-          ast::pat_wild. { true }
-          ast::pat_bind(_) { true }
-          ast::pat_rec(_, _) { true }
-          ast::pat_tup(_) { true }
-          _ { false }
-        };
+fn has_nested_bindings(m: match, col: uint) -> bool {
+    for br in m {
+        alt br.pats[col].node {
+          ast::pat_bind(_, some(_)) { ret true; }
+          _ {}
+        }
+    }
+    ret false;
+}
+
+fn expand_nested_bindings(m: match, col: uint, val: ValueRef) -> match {
+    let result = [];
+    for br in m {
+        alt br.pats[col].node {
+          ast::pat_bind(name, some(inner)) {
+            let pats = vec::slice(br.pats, 0u, col) + [inner] +
+                vec::slice(br.pats, col + 1u, vec::len(br.pats));
+            result += [@{pats: pats,
+                         bound: br.bound + [{ident: name, val: val}]
+                         with *br}];
+          }
+          _ { result += [br]; }
+        }
+    }
+    result
 }
 
 type enter_pat = fn@(@ast::pat) -> option::t<[@ast::pat]>;
@@ -109,7 +126,7 @@ fn enter_match(m: match, col: uint, val: ValueRef, e: enter_pat) -> match {
                 vec::slice(br.pats, col + 1u, vec::len(br.pats));
             let new_br = @{pats: pats,
                            bound: alt br.pats[col].node {
-                             ast::pat_bind(name) {
+                             ast::pat_bind(name, none.) {
                                br.bound + [{ident: name, val: val}]
                              }
                              _ { br.bound }
@@ -123,6 +140,13 @@ fn enter_match(m: match, col: uint, val: ValueRef, e: enter_pat) -> match {
 }
 
 fn enter_default(m: match, col: uint, val: ValueRef) -> match {
+    fn matches_always(p: @ast::pat) -> bool {
+        ret alt p.node {
+          ast::pat_wild. | ast::pat_bind(_, none.) | ast::pat_rec(_, _) |
+          ast::pat_tup(_) { true }
+          _ { false }
+        };
+    }
     fn e(p: @ast::pat) -> option::t<[@ast::pat]> {
         ret if matches_always(p) { some([]) } else { none };
     }
@@ -303,18 +327,17 @@ type exit_node = {bound: bind_map, from: BasicBlockRef, to: BasicBlockRef};
 type mk_fail = fn@() -> BasicBlockRef;
 
 fn pick_col(m: match) -> uint {
+    fn score(p: @ast::pat) -> uint {
+        alt p.node {
+          ast::pat_lit(_) | ast::pat_tag(_, _) | ast::pat_range(_, _) { 1u }
+          ast::pat_bind(_, some(p)) { score(p) }
+          _ { 0u }
+        }
+    }
     let scores = vec::init_elt_mut(0u, vec::len(m[0].pats));
     for br: match_branch in m {
         let i = 0u;
-        for p: @ast::pat in br.pats {
-            alt p.node {
-              ast::pat_lit(_) | ast::pat_tag(_, _) | ast::pat_range(_, _) {
-                scores[i] += 1u;
-              }
-              _ { }
-            }
-            i += 1u;
-        }
+        for p: @ast::pat in br.pats { scores[i] += score(p); i += 1u; }
     }
     let max_score = 0u;
     let best_col = 0u;
@@ -368,6 +391,9 @@ fn compile_submatch(bcx: @block_ctxt, m: match, vals: [ValueRef], f: mk_fail,
 
     let col = pick_col(m);
     let val = vals[col];
+    let m = has_nested_bindings(m, col) ?
+        expand_nested_bindings(m, col, val) : m;
+
     let vals_left =
         vec::slice(vals, 0u, col) +
             vec::slice(vals, col + 1u, vec::len(vals));
@@ -662,7 +688,7 @@ fn bind_irrefutable_pat(bcx: @block_ctxt, pat: @ast::pat, val: ValueRef,
                         make_copy: bool) -> @block_ctxt {
     let ccx = bcx.fcx.lcx.ccx, bcx = bcx;
     alt pat.node {
-      ast::pat_bind(_) {
+      ast::pat_bind(_, inner) {
         if make_copy || ccx.copy_map.contains_key(pat.id) {
             let ty = ty::node_id_to_monotype(ccx.tcx, pat.id);
             // FIXME: Could constrain pat_bind to make this
@@ -676,6 +702,10 @@ fn bind_irrefutable_pat(bcx: @block_ctxt, pat: @ast::pat, val: ValueRef,
             bcx.fcx.lllocals.insert(pat.id, local_mem(alloc));
             trans_common::add_clean(bcx, alloc, ty);
         } else { bcx.fcx.lllocals.insert(pat.id, local_mem(val)); }
+        alt inner {
+          some(pat) { bcx = bind_irrefutable_pat(bcx, pat, val, true); }
+          _ {}
+        }
       }
       ast::pat_tag(_, sub) {
         if vec::len(sub) == 0u { ret bcx; }

trunk/src/comp/middle/tstate/auxiliary.rs

@@ -1048,7 +1048,7 @@ type binding = {lhs: [inst], rhs: option::t<initializer>};
 fn local_to_bindings(loc: @local) -> binding {
     let lhs = [];
     pat_bindings(loc.node.pat) {|p|
-        let ident = alt p.node { pat_bind(name) { name } };
+        let ident = alt p.node { pat_bind(name, _) { name } };
         lhs += [{ident: ident, node: p.id}];
     };
     {lhs: lhs, rhs: loc.node.init}

trunk/src/comp/middle/tstate/collect_locals.rs

@@ -12,7 +12,7 @@ type ctxt = {cs: @mutable [sp_constr], tcx: ty::ctxt};
 
 fn collect_local(loc: @local, cx: ctxt, v: visit::vt<ctxt>) {
     pat_bindings(loc.node.pat) {|p|
-        let ident = alt p.node { pat_bind(id) { id } };
+        let ident = alt p.node { pat_bind(id, _) { id } };
         log "collect_local: pushing " + ident;;
         *cx.cs += [respan(loc.span, ninit(p.id, ident))];
     };

trunk/src/comp/middle/tstate/pre_post_conditions.rs

@@ -108,7 +108,7 @@ fn find_pre_post_loop(fcx: fn_ctxt, l: @local, index: @expr, body: blk,
     find_pre_post_expr(fcx, index);
     find_pre_post_block(fcx, body);
     pat_bindings(l.node.pat) {|p|
-        let ident = alt p.node { pat_bind(id) { id } };
+        let ident = alt p.node { pat_bind(id, _) { id } };
         let v_init = ninit(p.id, ident);
         relax_precond_block(fcx, bit_num(fcx, v_init) as node_id, body);
         // Hack: for-loop index variables are frequently ignored,
@@ -579,11 +579,7 @@ fn find_pre_post_stmt(fcx: fn_ctxt, s: stmt) {
                         /* FIXME: This won't be necessary when typestate
                         works well enough for pat_bindings to return a
                         refinement-typed thing. */
-                        let ident = alt pat.node {
-                          pat_bind(n) { n }
-                          _ { fcx.ccx.tcx.sess.span_bug(pat.span,
-                                                        "Impossible LHS"); }
-                        };
+                        let ident = alt pat.node { pat_bind(n, _) { n } };
                         alt p {
                           some(p) {
                             copy_in_postcond(fcx, id,
@@ -612,14 +608,10 @@ fn find_pre_post_stmt(fcx: fn_ctxt, s: stmt) {
                      postconds of the RHSs themselves */
                     pat_bindings(alocal.node.pat) {|pat|
                         alt pat.node {
-                          pat_bind(n) {
+                          pat_bind(n, _) {
                             set_in_postcond(bit_num(fcx, ninit(pat.id, n)),
                                             prev_pp);
                           }
-                          _ {
-                            fcx.ccx.tcx.sess.span_bug(pat.span,
-                                                      "Impossible LHS");
-                          }
                         }
                     };
                     copy_pre_post_(fcx.ccx, id, prev_pp.precondition,

trunk/src/comp/middle/tstate/states.rs

@@ -206,7 +206,7 @@ fn find_pre_post_state_loop(fcx: fn_ctxt, pres: prestate, l: @local,
     // in the body
     let index_post = tritv_clone(expr_poststate(fcx.ccx, index));
     pat_bindings(l.node.pat) {|p|
-        let ident = alt p.node { pat_bind(name) { name } };
+        let ident = alt p.node { pat_bind(name, _) { name } };
         set_in_poststate_ident(fcx, p.id, ident, index_post);
     };
 

trunk/src/comp/middle/typeck.rs

@@ -1178,7 +1178,7 @@ fn gather_locals(ccx: @crate_ctxt, f: ast::_fn, id: ast::node_id,
     let visit_pat =
         lambda (p: @ast::pat, &&e: (), v: visit::vt<()>) {
             alt p.node {
-              ast::pat_bind(_) { assign(p.id, none); }
+              ast::pat_bind(_, _) { assign(p.id, none); }
               _ {/* no-op */ }
             }
             visit::visit_pat(p, e, v);
@@ -1248,7 +1248,7 @@ fn check_pat(fcx: @fn_ctxt, map: ast_util::pat_id_map, pat: @ast::pat,
         }
         write::ty_only_fixup(fcx, pat.id, b_ty);
       }
-      ast::pat_bind(name) {
+      ast::pat_bind(name, sub) {
         let vid = lookup_local(fcx, pat.span, pat.id);
         let typ = ty::mk_var(fcx.ccx.tcx, vid);
         typ = demand::simple(fcx, pat.span, expected, typ);
@@ -1260,6 +1260,10 @@ fn check_pat(fcx: @fn_ctxt, map: ast_util::pat_id_map, pat: @ast::pat,
             typ = demand::simple(fcx, pat.span, ct, typ);
         }
         write::ty_only_fixup(fcx, pat.id, typ);
+        alt sub {
+          some(p) { check_pat(fcx, map, p, expected); }
+          _ {}
+        }
       }
       ast::pat_tag(path, subpats) {
         // Typecheck the path.