Change single-ident expr_ident to greedy/fat multi-ident expr_path, to handle the module-path/value-indexing distinction.

5 files changed, 99 insertions, 60 deletions

diff --git a/src/comp/middle/fold.rs b/src/comp/middle/fold.rs
index 4adf5ff9..b96ca938 100644
--- a/src/comp/middle/fold.rs
+++ b/src/comp/middle/fold.rs
@@ -11,7 +11,6 @@ import util.common.append;
 
 import front.ast;
 import front.ast.ident;
-import front.ast.name;
 import front.ast.path;
 import front.ast.mutability;
 import front.ast.ty;
@@ -34,8 +33,8 @@ import std._vec;
 type ast_fold[ENV] =
     @rec
     (
-     // Name fold.
-     (fn(&ENV e, &span sp, ast.name_ n) -> name)  fold_name,
+     // Path fold.
+     (fn(&ENV e, &span sp, ast.path_ p) -> path)  fold_path,
 
      // Type folds.
      (fn(&ENV e, &span sp) -> @ty)                fold_ty_nil,
@@ -137,9 +136,9 @@ type ast_fold[ENV] =
          ann a) -> @expr)                         fold_expr_index,
 
      (fn(&ENV e, &span sp,
-         &name n,
+         &path p,
          &option.t[def] d,
-         ann a) -> @expr)                         fold_expr_name,
+         ann a) -> @expr)                         fold_expr_path,
 
      // Decl folds.
      (fn(&ENV e, &span sp,
@@ -249,13 +248,13 @@ type ast_fold[ENV] =
 
 //// Fold drivers.
 
-fn fold_name[ENV](&ENV env, ast_fold[ENV] fld, &name n) -> name {
+fn fold_path[ENV](&ENV env, ast_fold[ENV] fld, &path p) -> path {
     let vec[@ast.ty] tys_ = vec();
-    for (@ast.ty t in n.node.types) {
+    for (@ast.ty t in p.node.types) {
         append[@ast.ty](tys_, fold_ty(env, fld, t));
     }
-    let ast.name_ n_ = rec(ident=n.node.ident, types=tys_);
-    ret fld.fold_name(env, n.span, n_);
+    let ast.path_ p_ = rec(idents=p.node.idents, types=tys_);
+    ret fld.fold_path(env, p.span, p_);
 }
 
 fn fold_ty[ENV](&ENV env, ast_fold[ENV] fld, @ty t) -> @ty {
@@ -321,11 +320,8 @@ fn fold_ty[ENV](&ENV env, ast_fold[ENV] fld, @ty t) -> @ty {
         }
 
         case (ast.ty_path(?pth, ?ref_opt)) {
-            let vec[ast.name] path = vec();
-            for (ast.name n in pth) {
-                path += fold_name(env, fld, n);
-            }
-            ret fld.fold_ty_path(env_, t.span, path, ref_opt);
+            auto pth_ = fold_path(env, fld, pth);
+            ret fld.fold_ty_path(env_, t.span, pth_, ref_opt);
         }
 
         case (ast.ty_mutable(?ty)) {
@@ -550,9 +546,9 @@ fn fold_expr[ENV](&ENV env, ast_fold[ENV] fld, &@expr e) -> @expr {
             ret fld.fold_expr_index(env_, e.span, ee, iix, t);
         }
 
-        case (ast.expr_name(?n, ?r, ?t)) {
-            auto n_ = fold_name(env_, fld, n);
-            ret fld.fold_expr_name(env_, e.span, n_, r, t);
+        case (ast.expr_path(?p, ?r, ?t)) {
+            auto p_ = fold_path(env_, fld, p);
+            ret fld.fold_expr_path(env_, e.span, p_, r, t);
         }
     }
 
@@ -809,10 +805,10 @@ fn respan[T](&span sp, &T t) -> spanned[T] {
 }
 
 
-// Name identity.
+// Path identity.
 
-fn identity_fold_name[ENV](&ENV env, &span sp, ast.name_ n) -> name {
-    ret respan(sp, n);
+fn identity_fold_path[ENV](&ENV env, &span sp, ast.path_ p) -> path {
+    ret respan(sp, p);
 }
 
 // Type identities.
@@ -983,10 +979,10 @@ fn identity_fold_expr_index[ENV](&ENV env, &span sp,
     ret @respan(sp, ast.expr_index(e, ix, a));
 }
 
-fn identity_fold_expr_name[ENV](&ENV env, &span sp,
-                                &name n, &option.t[def] d,
+fn identity_fold_expr_path[ENV](&ENV env, &span sp,
+                                &path p, &option.t[def] d,
                                 ann a) -> @expr {
-    ret @respan(sp, ast.expr_name(n, d, a));
+    ret @respan(sp, ast.expr_path(p, d, a));
 }
 
 
@@ -1176,7 +1172,7 @@ fn always_keep_going[ENV](&ENV e) -> bool {
 fn new_identity_fold[ENV]() -> ast_fold[ENV] {
     ret @rec
         (
-         fold_name       = bind identity_fold_name[ENV](_,_,_),
+         fold_path       = bind identity_fold_path[ENV](_,_,_),
 
          fold_ty_nil     = bind identity_fold_ty_nil[ENV](_,_),
          fold_ty_bool    = bind identity_fold_ty_bool[ENV](_,_),
@@ -1214,7 +1210,7 @@ fn new_identity_fold[ENV]() -> ast_fold[ENV] {
                        = bind identity_fold_expr_assign_op[ENV](_,_,_,_,_,_),
          fold_expr_field  = bind identity_fold_expr_field[ENV](_,_,_,_,_),
          fold_expr_index  = bind identity_fold_expr_index[ENV](_,_,_,_,_),
-         fold_expr_name   = bind identity_fold_expr_name[ENV](_,_,_,_,_),
+         fold_expr_path   = bind identity_fold_expr_path[ENV](_,_,_,_,_),
 
          fold_decl_local  = bind identity_fold_decl_local[ENV](_,_,_),
          fold_decl_item   = bind identity_fold_decl_item[ENV](_,_,_),
diff --git a/src/comp/middle/resolve.rs b/src/comp/middle/resolve.rs
index 700c0902..f7567590 100644
--- a/src/comp/middle/resolve.rs
+++ b/src/comp/middle/resolve.rs
@@ -295,25 +295,63 @@ fn fold_pat_tag(&env e, &span sp, import_map index, ident i,
     ret @fold.respan[ast.pat_](sp, ast.pat_tag(i, args, new_def, a));
 }
 
-fn fold_expr_name(&env e, &span sp, import_map index,
-                  &ast.name n, &option.t[def] d, ann a) -> @ast.expr {
-
-    if (_vec.len[@ast.ty](n.node.types) > 0u) {
+// We received a path expression of the following form:
+//
+//     a.b.c.d
+//
+// Somewhere along this path there might be a split from a path-expr
+// to a runtime field-expr. For example:
+//
+//     'a' could be the name of a variable in the local scope
+//     and 'b.c.d' could be a field-sequence inside it.
+//
+// Or:
+//
+//     'a.b' could be a module path to a constant record, and 'c.d'
+//     could be a field within it.
+//
+// Our job here is to figure out what the prefix of 'a.b.c.d' is that
+// corresponds to a static binding-name (a module or slot, with no type info)
+// and split that off as the 'primary' expr_path, with secondary expr_field
+// expressions tacked on the end.
+
+fn fold_expr_path(&env e, &span sp, import_map index,
+                  &ast.path p, &option.t[def] d, ann a) -> @ast.expr {
+
+    if (_vec.len[@ast.ty](p.node.types) > 0u) {
         e.sess.unimpl("resolving name expr with ty params");
     }
 
-    auto d_ = unwrap_def(lookup_name(e, some(index), n.node.ident));
+    auto n_idents = _vec.len[ast.ident](p.node.idents);
+
+    check (n_idents != 0u);
+    auto id0 = p.node.idents.(0);
+
+    auto d_ = unwrap_def(lookup_name(e, some(index), id0));
 
     alt (d_) {
         case (some[def](_)) {
             // log "resolved name " + n.node.ident;
         }
         case (none[def]) {
-            e.sess.span_err(sp, "unresolved name: " + n.node.ident);
+            e.sess.span_err(sp, "unresolved name: " + id0);
         }
     }
 
-    ret @fold.respan[ast.expr_](sp, ast.expr_name(n, d_, a));
+    // FIXME: once espindola's modifications to lookup land, actually step
+    // through the path doing speculative lookup, and extend the maximal
+    // static prefix. For now we are always using the minimal prefix: first
+    // ident is static anchor, rest turn into fields.
+
+    auto p_ = rec(node=rec(idents = vec(id0) with p.node) with p);
+    auto ex = @fold.respan[ast.expr_](sp, ast.expr_path(p_, d_, a));
+    auto i = 1u;
+    while (i < n_idents) {
+        auto id = p.node.idents.(i);
+        ex = @fold.respan[ast.expr_](sp, ast.expr_field(ex, id, a));
+        i += 1u;
+    }
+    ret ex;
 }
 
 fn fold_view_item_import(&env e, &span sp,
@@ -339,26 +377,24 @@ fn fold_view_item_import(&env e, &span sp,
 fn fold_ty_path(&env e, &span sp, import_map index, ast.path p,
                 &option.t[def] d) -> @ast.ty {
 
-    let uint len = _vec.len[ast.name](p);
+    let uint len = _vec.len[ast.ident](p.node.idents);
     check (len != 0u);
     if (len > 1u) {
         e.sess.unimpl("resolving path ty with >1 component");
     }
 
-    let ast.name n = p.(0);
-
-    if (_vec.len[@ast.ty](n.node.types) > 0u) {
+    if (_vec.len[@ast.ty](p.node.types) > 0u) {
         e.sess.unimpl("resolving path ty with ty params");
     }
 
-    auto d_ = unwrap_def(lookup_name(e, some(index), n.node.ident));
+    auto d_ = unwrap_def(lookup_name(e, some(index), p.node.idents.(0)));
 
     alt (d_) {
-        case (some[def](_)) {
+        case (some[def](?d)) {
             // log "resolved name " + n.node.ident;
         }
         case (none[def]) {
-            e.sess.span_err(sp, "unresolved name: " + n.node.ident);
+            e.sess.span_err(sp, "unresolved name: " + p.node.idents.(0));
         }
     }
 
@@ -387,7 +423,7 @@ fn resolve_crate(session.session sess, @ast.crate crate) -> @ast.crate {
 
     auto import_index = new_def_hash[def_wrap]();
     fld = @rec( fold_pat_tag = bind fold_pat_tag(_,_,import_index,_,_,_,_),
-                fold_expr_name = bind fold_expr_name(_,_,import_index,_,_,_),
+                fold_expr_path = bind fold_expr_path(_,_,import_index,_,_,_),
                 fold_view_item_import
                     = bind fold_view_item_import(_,_,import_index,_,_),
                 fold_ty_path = bind fold_ty_path(_,_,import_index,_,_),
diff --git a/src/comp/middle/trans.rs b/src/comp/middle/trans.rs
index 09fa0a8d..594d7bc5 100644
--- a/src/comp/middle/trans.rs
+++ b/src/comp/middle/trans.rs
@@ -1772,7 +1772,7 @@ fn lval_val(@block_ctxt cx, ValueRef val) -> lval_result {
             llobj=none[ValueRef]);
 }
 
-fn trans_name(@block_ctxt cx, &ast.name n, &option.t[ast.def] dopt,
+fn trans_path(@block_ctxt cx, &ast.path p, &option.t[ast.def] dopt,
         &ast.ann ann) -> lval_result {
     alt (dopt) {
         case (some[ast.def](?def)) {
@@ -1826,7 +1826,7 @@ fn trans_name(@block_ctxt cx, &ast.name n, &option.t[ast.def] dopt,
             }
         }
         case (none[ast.def]) {
-            cx.fcx.ccx.sess.err("unresolved expr_name in trans");
+            cx.fcx.ccx.sess.err("unresolved expr_path in trans");
         }
     }
     fail;
@@ -1906,8 +1906,8 @@ impure fn trans_index(@block_ctxt cx, &ast.span sp, @ast.expr base,
 
 impure fn trans_lval(@block_ctxt cx, @ast.expr e) -> lval_result {
     alt (e.node) {
-        case (ast.expr_name(?n, ?dopt, ?ann)) {
-            ret trans_name(cx, n, dopt, ann);
+        case (ast.expr_path(?p, ?dopt, ?ann)) {
+            ret trans_path(cx, p, dopt, ann);
         }
         case (ast.expr_field(?base, ?ident, ?ann)) {
             ret trans_field(cx, e.span, base, ident, ann);
diff --git a/src/comp/middle/ty.rs b/src/comp/middle/ty.rs
index ff54a0a1..b55e8be6 100644
--- a/src/comp/middle/ty.rs
+++ b/src/comp/middle/ty.rs
@@ -146,22 +146,17 @@ fn ast_ty_to_str(&@ast.ty ty) -> str {
     ret s;
 }
 
-fn name_to_str(&ast.name nm) -> str {
-    auto result = nm.node.ident;
-    if (_vec.len[@ast.ty](nm.node.types) > 0u) {
+fn path_to_str(&ast.path pth) -> str {
+    auto result = _str.connect(pth.node.idents,  ".");
+    if (_vec.len[@ast.ty](pth.node.types) > 0u) {
         auto f = ast_ty_to_str;
         result += "[";
-        result += _str.connect(_vec.map[@ast.ty,str](f, nm.node.types), ",");
+        result += _str.connect(_vec.map[@ast.ty,str](f, pth.node.types), ",");
         result += "]";
     }
     ret result;
 }
 
-fn path_to_str(&ast.path path) -> str {
-    auto f = name_to_str;
-    ret _str.connect(_vec.map[ast.name,str](f, path), ".");
-}
-
 fn ty_to_str(&@t typ) -> str {
 
     fn fn_input_to_str(&rec(ast.mode mode, @t ty) input) -> str {
@@ -632,7 +627,7 @@ fn expr_ty(@ast.expr expr) -> @t {
                                               { ret ann_to_type(ann); }
         case (ast.expr_field(_, _, ?ann))     { ret ann_to_type(ann); }
         case (ast.expr_index(_, _, ?ann))     { ret ann_to_type(ann); }
-        case (ast.expr_name(_, _, ?ann))      { ret ann_to_type(ann); }
+        case (ast.expr_path(_, _, ?ann))      { ret ann_to_type(ann); }
     }
     fail;
 }
@@ -697,7 +692,7 @@ fn is_lval(@ast.expr expr) -> bool {
     alt (expr.node) {
         case (ast.expr_field(_,_,_))    { ret true;  }
         case (ast.expr_index(_,_,_))    { ret true;  }
-        case (ast.expr_name(_,_,_))     { ret true;  }
+        case (ast.expr_path(_,_,_))     { ret true;  }
         case (_)                        { ret false; }
     }
 }
@@ -1238,3 +1233,11 @@ fn resolve_ty_params(@ast.item item, @t monoty) -> vec[@t] {
     ret result_tys;
 }
 
+// Local Variables:
+// mode: rust
+// fill-column: 78;
+// indent-tabs-mode: nil
+// c-basic-offset: 4
+// buffer-file-coding-system: utf-8-unix
+// compile-command: "make -k -C ../.. 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
+// End:
diff --git a/src/comp/middle/typeck.rs b/src/comp/middle/typeck.rs
index d1e34e7a..d159c76f 100644
--- a/src/comp/middle/typeck.rs
+++ b/src/comp/middle/typeck.rs
@@ -753,9 +753,9 @@ fn demand_expr(&@fn_ctxt fcx, @ty.t expected, @ast.expr e) -> @ast.expr {
             auto t = demand(fcx, e.span, expected, ann_to_type(ann));
             e_1 = ast.expr_index(base, index, ast.ann_type(t));
         }
-        case (ast.expr_name(?name, ?d, ?ann)) {
+        case (ast.expr_path(?pth, ?d, ?ann)) {
             auto t = demand(fcx, e.span, expected, ann_to_type(ann));
-            e_1 = ast.expr_name(name, d, ast.ann_type(t));
+            e_1 = ast.expr_path(pth, d, ast.ann_type(t));
         }
         case (_) {
             fail;
@@ -941,7 +941,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
                                                        ast.ann_type(oper_t)));
         }
 
-        case (ast.expr_name(?name, ?defopt, _)) {
+        case (ast.expr_path(?pth, ?defopt, _)) {
             auto t = plain_ty(ty.ty_nil);
             check (defopt != none[ast.def]);
             alt (option.get[ast.def](defopt)) {
@@ -980,16 +980,20 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
                     t = generalize_ty(fcx.ccx, fcx.ccx.item_types.get(id));
                 }
 
+                case (ast.def_mod(_)) {
+                    // Hopefully part of a path.
+                }
+
                 case (_) {
                     // FIXME: handle other names.
                     fcx.ccx.sess.unimpl("definition variant for: "
-                                        + name.node.ident);
+                                        + _str.connect(pth.node.idents, "."));
                     fail;
                 }
             }
 
             ret @fold.respan[ast.expr_](expr.span,
-                                        ast.expr_name(name, defopt,
+                                        ast.expr_path(pth, defopt,
                                                       ast.ann_type(t)));
         }