More work on resolving names in rustc. Basic expr_name lookup working on items and args.

src/comp/front/ast.rs

@@ -12,20 +12,17 @@ type name = spanned[name_];
 type path = vec[name];
 
 type crate_num = int;
-type slot_num = int;
-type item_num = int;
+type def_num = int;
+type def_id = tup(crate_num, def_num);
 
-tag slot_id {
-    id_slot(crate_num, slot_num);
-}
-
-tag item_id {
-    id_item(crate_num, slot_num);
-}
-
-tag referent {
-    ref_slot(slot_id);
-    ref_item(item_id);
+tag def {
+    def_fn(def_id);
+    def_mod(def_id);
+    def_const(def_id);
+    def_arg(def_id);
+    def_local(def_id);
+    def_ty(def_id);
+    def_ty_arg(def_id);
 }
 
 type crate = spanned[crate_];
@@ -93,7 +90,7 @@ tag expr_ {
     expr_assign(@expr /* TODO: @expr : is_lval(@expr) */, @expr);
     expr_field(@expr, ident);
     expr_index(@expr, @expr);
-    expr_name(name, option[referent]);
+    expr_name(name, option[def]);
 }
 
 type lit = spanned[lit_];
@@ -118,7 +115,7 @@ tag ty_ {
     ty_box(@ty);
     ty_vec(@ty);
     ty_tup(vec[tup(bool /* mutability */, @ty)]);
-    ty_path(path, option[referent]);
+    ty_path(path, option[def]);
 }
 
 tag mode {
@@ -126,10 +123,8 @@ tag mode {
     alias;
 }
 
-type slot = rec(@ty ty, mode mode, option[slot_id] id);
-type input = rec(slot slot, ident ident);
-
-type _fn = rec(vec[input] inputs,
+type arg = rec(mode mode, @ty ty, ident ident, def_id id);
+type _fn = rec(vec[arg] inputs,
                ty output,
                block body);
 
@@ -137,9 +132,9 @@ type _mod = hashmap[ident,@item];
 
 type item = spanned[item_];
 tag item_ {
-    item_fn(_fn, item_id);
-    item_mod(_mod);
-    item_ty(@ty, item_id);
+    item_fn(_fn, def_id);
+    item_mod(_mod, def_id);
+    item_ty(@ty, def_id);
 }
 
 

src/comp/front/parser.rs

@@ -15,13 +15,17 @@ state type parser =
           io fn err(str s);
           fn get_session() -> session.session;
           fn get_span() -> common.span;
+          fn next_def_id() -> ast.def_id;
     };
 
-io fn new_parser(session.session sess, str path) -> parser {
+io fn new_parser(session.session sess,
+                 ast.crate_num crate, str path) -> parser {
     state obj stdio_parser(session.session sess,
                            mutable token.token tok,
                            mutable common.pos lo,
                            mutable common.pos hi,
+                           mutable ast.def_num def,
+                           ast.crate_num crate,
                            lexer.reader rdr)
         {
             fn peek() -> token.token {
@@ -49,11 +53,17 @@ io fn new_parser(session.session sess, str path) -> parser {
                 ret rec(filename = rdr.get_filename(),
                         lo = lo, hi = hi);
             }
+
+            fn next_def_id() -> ast.def_id {
+                def += 1;
+                ret tup(crate, def);
+            }
         }
     auto srdr = _io.new_stdio_reader(path);
     auto rdr = lexer.new_reader(srdr, path);
     auto npos = rdr.get_curr_pos();
-    ret stdio_parser(sess, lexer.next_token(rdr), npos, npos, rdr);
+    ret stdio_parser(sess, lexer.next_token(rdr),
+                     npos, npos, 0, crate, rdr);
 }
 
 io fn expect(parser p, token.token t) {
@@ -132,14 +142,15 @@ io fn parse_ty(parser p) -> @ast.ty {
     ret @spanned(lo, lo, t);
 }
 
-io fn parse_slot(parser p) -> ast.slot {
+io fn parse_arg(parser p) -> ast.arg {
     let ast.mode m = ast.val;
     if (p.peek() == token.BINOP(token.AND)) {
         m = ast.alias;
         p.bump();
     }
     let @ast.ty t = parse_ty(p);
-    ret rec(ty=t, mode=m, id=none[ast.slot_id]);
+    let ast.ident i = parse_ident(p);
+    ret rec(mode=m, ty=t, ident=i, id=p.next_def_id());
 }
 
 io fn parse_seq[T](token.token bra,
@@ -249,6 +260,13 @@ io fn parse_bottom_expr(parser p) -> @ast.expr {
     let ast.expr_ ex = ast.expr_lit(@spanned(lo, lo, ast.lit_nil));
 
     alt (p.peek()) {
+
+        case (token.IDENT(?i)) {
+            auto n = parse_name(p, i);
+            hi = n.span;
+            ex = ast.expr_name(n, none[ast.def]);
+        }
+
         case (token.LPAREN) {
             p.bump();
             auto e = parse_expr(p);
@@ -665,22 +683,15 @@ io fn parse_block(parser p) -> ast.block {
                              f, p);
 }
 
-io fn parse_slot_ident_pair(parser p) ->
-    rec(ast.slot slot, ast.ident ident) {
-    auto s = parse_slot(p);
-    auto i = parse_ident(p);
-    ret rec(slot=s, ident=i);
-}
-
 io fn parse_fn(parser p) -> tup(ast.ident, @ast.item) {
     auto lo = p.get_span();
     expect(p, token.FN);
     auto id = parse_ident(p);
-    auto pf = parse_slot_ident_pair;
-    let util.common.spanned[vec[rec(ast.slot slot, ast.ident ident)]] inputs =
-        // FIXME: passing parse_slot_ident_pair as an lval doesn't work at the
+    auto pf = parse_arg;
+    let util.common.spanned[vec[ast.arg]] inputs =
+        // FIXME: passing parse_arg as an lval doesn't work at the
         // moment.
-        parse_seq[rec(ast.slot slot, ast.ident ident)]
+        parse_seq[ast.arg]
         (token.LPAREN,
          token.RPAREN,
          some(token.COMMA),
@@ -701,7 +712,7 @@ io fn parse_fn(parser p) -> tup(ast.ident, @ast.item) {
                         body = body);
 
     let @ast.item i = @spanned(lo, body.span,
-                               ast.item_fn(f, ast.id_item(0,0)));
+                               ast.item_fn(f, p.next_def_id()));
     ret tup(id, i);
 }
 
@@ -717,7 +728,7 @@ io fn parse_mod(parser p) -> tup(ast.ident, @ast.item) {
     }
     auto hi = p.get_span();
     expect(p, token.RBRACE);
-    ret tup(id, @spanned(lo, hi, ast.item_mod(m)));
+    ret tup(id, @spanned(lo, hi, ast.item_mod(m, p.next_def_id())));
 }
 
 io fn parse_item(parser p) -> tup(ast.ident, @ast.item) {