First step for supporting "case (foo.bar(?zed))": Change the ast of

pat_tag to hold a path.

5 files changed, 25 insertions, 19 deletions

diff --git a/src/comp/front/ast.rs b/src/comp/front/ast.rs
index bdd6fa07..2ae4c907 100644
--- a/src/comp/front/ast.rs
+++ b/src/comp/front/ast.rs
@@ -55,7 +55,7 @@ type pat = spanned[pat_];
 tag pat_ {
     pat_wild(ann);
     pat_bind(ident, def_id, ann);
-    pat_tag(ident, vec[@pat], option.t[variant_def], ann);
+    pat_tag(path, vec[@pat], option.t[variant_def], ann);
 }
 
 tag mutability {
diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs
index 5a67efa6..5444e5fd 100644
--- a/src/comp/front/parser.rs
+++ b/src/comp/front/parser.rs
@@ -1071,7 +1071,7 @@ impure fn parse_pat(parser p) -> @ast.pat {
             }
         }
         case (token.IDENT(?id)) {
-            p.bump();
+            auto tag_path = parse_path(p, GREEDY);
 
             let vec[@ast.pat] args;
             alt (p.peek()) {
@@ -1083,7 +1083,8 @@ impure fn parse_pat(parser p) -> @ast.pat {
                 case (_) { args = vec(); }
             }
 
-            pat = ast.pat_tag(id, args, none[ast.variant_def], ast.ann_none);
+            pat = ast.pat_tag(tag_path, args, none[ast.variant_def],
+                              ast.ann_none);
         }
         case (?tok) {
             p.err("expected pattern but found " + token.to_str(tok));
diff --git a/src/comp/middle/fold.rs b/src/comp/middle/fold.rs
index 7862c7ca..8a6f82f2 100644
--- a/src/comp/middle/fold.rs
+++ b/src/comp/middle/fold.rs
@@ -160,7 +160,7 @@ type ast_fold[ENV] =
          ident i, def_id did, ann a) -> @pat)     fold_pat_bind,
 
      (fn(&ENV e, &span sp,
-         ident i, vec[@pat] args,
+         path p, vec[@pat] args,
          option.t[ast.variant_def] d,
          ann a) -> @pat)                          fold_pat_tag,
 
@@ -400,12 +400,12 @@ fn fold_pat[ENV](&ENV env, ast_fold[ENV] fld, @ast.pat p) -> @ast.pat {
         case (ast.pat_bind(?id, ?did, ?t)) {
             ret fld.fold_pat_bind(env_, p.span, id, did, t);
         }
-        case (ast.pat_tag(?id, ?pats, ?d, ?t)) {
+        case (ast.pat_tag(?path, ?pats, ?d, ?t)) {
             let vec[@ast.pat] ppats = vec();
             for (@ast.pat pat in pats) {
                 ppats += vec(fold_pat(env_, fld, pat));
             }
-            ret fld.fold_pat_tag(env_, p.span, id, ppats, d, t);
+            ret fld.fold_pat_tag(env_, p.span, path, ppats, d, t);
         }
     }
 }
@@ -1040,9 +1040,9 @@ fn identity_fold_pat_bind[ENV](&ENV e, &span sp, ident i, def_id did, ann a)
     ret @respan(sp, ast.pat_bind(i, did, a));
 }
 
-fn identity_fold_pat_tag[ENV](&ENV e, &span sp, ident i, vec[@pat] args,
+fn identity_fold_pat_tag[ENV](&ENV e, &span sp, path p, vec[@pat] args,
                               option.t[ast.variant_def] d, ann a) -> @pat {
-    ret @respan(sp, ast.pat_tag(i, args, d, a));
+    ret @respan(sp, ast.pat_tag(p, args, d, a));
 }
 
 
diff --git a/src/comp/middle/resolve.rs b/src/comp/middle/resolve.rs
index 724664b3..76dcc9dc 100644
--- a/src/comp/middle/resolve.rs
+++ b/src/comp/middle/resolve.rs
@@ -375,29 +375,31 @@ fn lookup_name_wrapped(&env e, ast.ident i) -> option.t[tup(@env, def_wrap)] {
     }
 }
 
-fn fold_pat_tag(&env e, &span sp, ident i, vec[@ast.pat] args,
+fn fold_pat_tag(&env e, &span sp, ast.path p, vec[@ast.pat] args,
                 option.t[ast.variant_def] old_def,
                 ann a) -> @ast.pat {
+    auto len = _vec.len[ast.ident](p.node.idents);
+    auto last_id = p.node.idents.(len - 1u);
     auto new_def;
-    alt (lookup_name(e, i)) {
+    alt (lookup_name(e, last_id)) {
         case (some[def](?d)) {
             alt (d) {
                 case (ast.def_variant(?did, ?vid)) {
                     new_def = some[ast.variant_def](tup(did, vid));
                 }
                 case (_) {
-                    e.sess.span_err(sp, "not a tag variant: " + i);
+                    e.sess.span_err(sp, "not a tag variant: " + last_id);
                     new_def = none[ast.variant_def];
                 }
             }
         }
         case (none[def]) {
             new_def = none[ast.variant_def];
-            e.sess.span_err(sp, "unresolved name: " + i);
+            e.sess.span_err(sp, "unresolved name: " + last_id);
         }
     }
 
-    ret @fold.respan[ast.pat_](sp, ast.pat_tag(i, args, new_def, a));
+    ret @fold.respan[ast.pat_](sp, ast.pat_tag(p, args, new_def, a));
 }
 
 // We received a path expression of the following form:
diff --git a/src/comp/middle/typeck.rs b/src/comp/middle/typeck.rs
index e21e72a9..c3ae8f58 100644
--- a/src/comp/middle/typeck.rs
+++ b/src/comp/middle/typeck.rs
@@ -993,9 +993,11 @@ fn check_pat(&@fn_ctxt fcx, @ast.pat pat) -> @ast.pat {
             auto ann = ast.ann_type(next_ty_var(fcx.ccx));
             new_pat = ast.pat_bind(id, def_id, ann);
         }
-        case (ast.pat_tag(?id, ?subpats, ?vdef_opt, _)) {
+        case (ast.pat_tag(?p, ?subpats, ?vdef_opt, _)) {
             auto vdef = option.get[ast.variant_def](vdef_opt);
-            auto t = fcx.ccx.item_types.get(vdef._1); 
+            auto t = fcx.ccx.item_types.get(vdef._1);
+            auto len = _vec.len[ast.ident](p.node.idents);
+            auto last_id = p.node.idents.(len - 1u);
             alt (t.struct) {
                 // N-ary variants have function types.
                 case (ty.ty_fn(?args, ?tag_ty)) {
@@ -1003,7 +1005,7 @@ fn check_pat(&@fn_ctxt fcx, @ast.pat pat) -> @ast.pat {
                     auto subpats_len = _vec.len[@ast.pat](subpats);
                     if (arg_len != subpats_len) {
                         // TODO: pluralize properly
-                        auto err_msg = "tag type " + id + " has " +
+                        auto err_msg = "tag type " + last_id + " has " +
                                        _uint.to_str(subpats_len, 10u) +
                                        " fields, but this pattern has " +
                                        _uint.to_str(arg_len, 10u) + " fields";
@@ -1018,7 +1020,7 @@ fn check_pat(&@fn_ctxt fcx, @ast.pat pat) -> @ast.pat {
                     }
 
                     auto ann = ast.ann_type(tag_ty);
-                    new_pat = ast.pat_tag(id, new_subpats, vdef_opt, ann);
+                    new_pat = ast.pat_tag(p, new_subpats, vdef_opt, ann);
                 }
 
                 // Nullary variants have tag types.
@@ -1026,7 +1028,8 @@ fn check_pat(&@fn_ctxt fcx, @ast.pat pat) -> @ast.pat {
                     auto subpats_len = _vec.len[@ast.pat](subpats);
                     if (subpats_len > 0u) {
                         // TODO: pluralize properly
-                        auto err_msg = "tag type " + id + " has no fields," +
+                        auto err_msg = "tag type " + last_id +
+                                       " has no fields," +
                                        " but this pattern has " +
                                        _uint.to_str(subpats_len, 10u) +
                                        " fields";
@@ -1036,7 +1039,7 @@ fn check_pat(&@fn_ctxt fcx, @ast.pat pat) -> @ast.pat {
                     }
 
                     auto ann = ast.ann_type(plain_ty(ty.ty_tag(tid)));
-                    new_pat = ast.pat_tag(id, subpats, vdef_opt, ann);
+                    new_pat = ast.pat_tag(p, subpats, vdef_opt, ann);
                 }
             }
         }