Skip to content

Commit 865bbae

Browse files
graydongraydon
committed
More work on resolving names in rustc. Basic expr_name lookup working on items and args.
1 parent 23a00fd commit 865bbae

File tree

6 files changed

+123
-93
lines changed

6 files changed

+123
-93
lines changed

‎src/comp/driver/rustc.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -16,7 +16,7 @@ io fn main(vec[str] args) {
1616
auto sess = session.session();
1717
for (str filename in args) {
1818
if (i > 0) {
19-
auto p = parser.new_parser(sess, filename);
19+
auto p = parser.new_parser(sess, 0, filename);
2020
auto crate = parser.parse_crate(p);
2121
crate = resolve.resolve_crate(sess, crate);
2222
trans.trans_crate(sess, crate);

‎src/comp/front/ast.rs

Lines changed: 18 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -12,20 +12,17 @@ type name = spanned[name_];
1212
type path = vec[name];
1313

1414
type crate_num = int;
15-
type slot_num = int;
16-
type item_num = int;
17-
18-
tag slot_id {
19-
id_slot(crate_num, slot_num);
20-
}
21-
22-
tag item_id {
23-
id_item(crate_num, slot_num);
24-
}
25-
26-
tag referent {
27-
ref_slot(slot_id);
28-
ref_item(item_id);
15+
type def_num = int;
16+
type def_id = tup(crate_num, def_num);
17+
18+
tag def {
19+
def_fn(def_id);
20+
def_mod(def_id);
21+
def_const(def_id);
22+
def_arg(def_id);
23+
def_local(def_id);
24+
def_ty(def_id);
25+
def_ty_arg(def_id);
2926
}
3027

3128
type crate = spanned[crate_];
@@ -93,7 +90,7 @@ tag expr_ {
9390
expr_assign(@expr /* TODO: @expr : is_lval(@expr) */, @expr);
9491
expr_field(@expr, ident);
9592
expr_index(@expr, @expr);
96-
expr_name(name, option[referent]);
93+
expr_name(name, option[def]);
9794
}
9895

9996
type lit = spanned[lit_];
@@ -118,28 +115,26 @@ tag ty_ {
118115
ty_box(@ty);
119116
ty_vec(@ty);
120117
ty_tup(vec[tup(bool /* mutability */, @ty)]);
121-
ty_path(path, option[referent]);
118+
ty_path(path, option[def]);
122119
}
123120

124121
tag mode {
125122
val;
126123
alias;
127124
}
128125

129-
type slot = rec(@ty ty, mode mode, option[slot_id] id);
130-
type input = rec(slot slot, ident ident);
131-
132-
type _fn = rec(vec[input] inputs,
126+
type arg = rec(mode mode, @ty ty, ident ident, def_id id);
127+
type _fn = rec(vec[arg] inputs,
133128
ty output,
134129
block body);
135130

136131
type _mod = hashmap[ident,@item];
137132

138133
type item = spanned[item_];
139134
tag item_ {
140-
item_fn(_fn, item_id);
141-
item_mod(_mod);
142-
item_ty(@ty, item_id);
135+
item_fn(_fn, def_id);
136+
item_mod(_mod, def_id);
137+
item_ty(@ty, def_id);
143138
}
144139

145140

‎src/comp/front/parser.rs

Lines changed: 28 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -15,13 +15,17 @@ state type parser =
1515
io fn err(str s);
1616
fn get_session() -> session.session;
1717
fn get_span() -> common.span;
18+
fn next_def_id() -> ast.def_id;
1819
};
1920

20-
io fn new_parser(session.session sess, str path) -> parser {
21+
io fn new_parser(session.session sess,
22+
ast.crate_num crate, str path) -> parser {
2123
state obj stdio_parser(session.session sess,
2224
mutable token.token tok,
2325
mutable common.pos lo,
2426
mutable common.pos hi,
27+
mutable ast.def_num def,
28+
ast.crate_num crate,
2529
lexer.reader rdr)
2630
{
2731
fn peek() -> token.token {
@@ -49,11 +53,17 @@ io fn new_parser(session.session sess, str path) -> parser {
4953
ret rec(filename = rdr.get_filename(),
5054
lo = lo, hi = hi);
5155
}
56+
57+
fn next_def_id() -> ast.def_id {
58+
def += 1;
59+
ret tup(crate, def);
60+
}
5261
}
5362
auto srdr = _io.new_stdio_reader(path);
5463
auto rdr = lexer.new_reader(srdr, path);
5564
auto npos = rdr.get_curr_pos();
56-
ret stdio_parser(sess, lexer.next_token(rdr), npos, npos, rdr);
65+
ret stdio_parser(sess, lexer.next_token(rdr),
66+
npos, npos, 0, crate, rdr);
5767
}
5868

5969
io fn expect(parser p, token.token t) {
@@ -132,14 +142,15 @@ io fn parse_ty(parser p) -> @ast.ty {
132142
ret @spanned(lo, lo, t);
133143
}
134144

135-
io fn parse_slot(parser p) -> ast.slot {
145+
io fn parse_arg(parser p) -> ast.arg {
136146
let ast.mode m = ast.val;
137147
if (p.peek() == token.BINOP(token.AND)) {
138148
m = ast.alias;
139149
p.bump();
140150
}
141151
let @ast.ty t = parse_ty(p);
142-
ret rec(ty=t, mode=m, id=none[ast.slot_id]);
152+
let ast.ident i = parse_ident(p);
153+
ret rec(mode=m, ty=t, ident=i, id=p.next_def_id());
143154
}
144155

145156
io fn parse_seq[T](token.token bra,
@@ -249,6 +260,13 @@ io fn parse_bottom_expr(parser p) -> @ast.expr {
249260
let ast.expr_ ex = ast.expr_lit(@spanned(lo, lo, ast.lit_nil));
250261

251262
alt (p.peek()) {
263+
264+
case (token.IDENT(?i)) {
265+
auto n = parse_name(p, i);
266+
hi = n.span;
267+
ex = ast.expr_name(n, none[ast.def]);
268+
}
269+
252270
case (token.LPAREN) {
253271
p.bump();
254272
auto e = parse_expr(p);
@@ -665,22 +683,15 @@ io fn parse_block(parser p) -> ast.block {
665683
f, p);
666684
}
667685

668-
io fn parse_slot_ident_pair(parser p) ->
669-
rec(ast.slot slot, ast.ident ident) {
670-
auto s = parse_slot(p);
671-
auto i = parse_ident(p);
672-
ret rec(slot=s, ident=i);
673-
}
674-
675686
io fn parse_fn(parser p) -> tup(ast.ident, @ast.item) {
676687
auto lo = p.get_span();
677688
expect(p, token.FN);
678689
auto id = parse_ident(p);
679-
auto pf = parse_slot_ident_pair;
680-
let util.common.spanned[vec[rec(ast.slot slot, ast.ident ident)]] inputs =
681-
// FIXME: passing parse_slot_ident_pair as an lval doesn't work at the
690+
auto pf = parse_arg;
691+
let util.common.spanned[vec[ast.arg]] inputs =
692+
// FIXME: passing parse_arg as an lval doesn't work at the
682693
// moment.
683-
parse_seq[rec(ast.slot slot, ast.ident ident)]
694+
parse_seq[ast.arg]
684695
(token.LPAREN,
685696
token.RPAREN,
686697
some(token.COMMA),
@@ -701,7 +712,7 @@ io fn parse_fn(parser p) -> tup(ast.ident, @ast.item) {
701712
body = body);
702713

703714
let @ast.item i = @spanned(lo, body.span,
704-
ast.item_fn(f, ast.id_item(0,0)));
715+
ast.item_fn(f, p.next_def_id()));
705716
ret tup(id, i);
706717
}
707718

@@ -717,7 +728,7 @@ io fn parse_mod(parser p) -> tup(ast.ident, @ast.item) {
717728
}
718729
auto hi = p.get_span();
719730
expect(p, token.RBRACE);
720-
ret tup(id, @spanned(lo, hi, ast.item_mod(m)));
731+
ret tup(id, @spanned(lo, hi, ast.item_mod(m, p.next_def_id())));
721732
}
722733

723734
io fn parse_item(parser p) -> tup(ast.ident, @ast.item) {

‎src/comp/middle/fold.rs

Lines changed: 27 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -17,9 +17,9 @@ import front.ast.expr;
1717
import front.ast.stmt;
1818
import front.ast.block;
1919
import front.ast.item;
20-
import front.ast.slot;
20+
import front.ast.arg;
2121
import front.ast.decl;
22-
import front.ast.referent;
22+
import front.ast.def;
2323

2424
import std._vec;
2525

@@ -44,7 +44,7 @@ type ast_fold[ENV] =
4444
vec[tup(bool, @ty)] elts) -> @ty) fold_ty_tup,
4545

4646
(fn(&ENV e, &span sp, ast.path p,
47-
&option[referent] r) -> @ty) fold_ty_path,
47+
&option[def] d) -> @ty) fold_ty_path,
4848

4949
// Expr folds.
5050
(fn(&ENV e, &span sp,
@@ -87,7 +87,7 @@ type ast_fold[ENV] =
8787

8888
(fn(&ENV e, &span sp,
8989
&name n,
90-
&option[referent] r) -> @expr) fold_expr_name,
90+
&option[def] d) -> @expr) fold_expr_name,
9191

9292
// Decl folds.
9393
(fn(&ENV e, &span sp,
@@ -113,19 +113,19 @@ type ast_fold[ENV] =
113113

114114
// Item folds.
115115
(fn(&ENV e, &span sp,
116-
&ast._fn f, ast.item_id id) -> @item) fold_item_fn,
116+
&ast._fn f, ast.def_id id) -> @item) fold_item_fn,
117117

118118
(fn(&ENV e, &span sp,
119-
&ast._mod m) -> @item) fold_item_mod,
119+
&ast._mod m, ast.def_id id) -> @item) fold_item_mod,
120120

121121
(fn(&ENV e, &span sp,
122-
@ty t, ast.item_id id) -> @item) fold_item_ty,
122+
@ty t, ast.def_id id) -> @item) fold_item_ty,
123123

124124
// Additional nodes.
125125
(fn(&ENV e, &span sp,
126126
vec[@stmt] stmts) -> block) fold_block,
127127

128-
(fn(&ENV e, vec[ast.input] inputs,
128+
(fn(&ENV e, vec[arg] inputs,
129129
&ty output, block body) -> ast._fn) fold_fn,
130130

131131
(fn(&ENV e, &ast._mod m) -> ast._mod) fold_mod,
@@ -412,18 +412,17 @@ fn fold_block[ENV](&ENV env, ast_fold[ENV] fld, &block blk) -> block {
412412
ret respan(blk.span, stmts);
413413
}
414414

415-
fn fold_slot[ENV](&ENV env, ast_fold[ENV] fld, &slot s) -> slot {
416-
auto ty = fold_ty(env, fld, s.ty);
417-
ret rec(ty=ty, mode=s.mode, id=s.id);
415+
fn fold_arg[ENV](&ENV env, ast_fold[ENV] fld, &arg a) -> arg {
416+
auto ty = fold_ty(env, fld, a.ty);
417+
ret rec(ty=ty with a);
418418
}
419419

420420

421421
fn fold_fn[ENV](&ENV env, ast_fold[ENV] fld, &ast._fn f) -> ast._fn {
422422

423-
let vec[ast.input] inputs = vec();
424-
for (ast.input i in f.inputs) {
425-
inputs += rec(slot=fold_slot(env, fld, i.slot),
426-
ident=i.ident);
423+
let vec[ast.arg] inputs = vec();
424+
for (ast.arg a in f.inputs) {
425+
inputs += fold_arg(env, fld, a);
427426
}
428427
auto output = fold_ty[ENV](env, fld, @f.output);
429428
auto body = fold_block[ENV](env, fld, f.body);
@@ -446,9 +445,9 @@ fn fold_item[ENV](&ENV env, ast_fold[ENV] fld, @item i) -> @item {
446445
ret fld.fold_item_fn(env_, i.span, ff_, id);
447446
}
448447

449-
case (ast.item_mod(?mm)) {
448+
case (ast.item_mod(?mm, ?id)) {
450449
let ast._mod mm_ = fold_mod[ENV](env_, fld, mm);
451-
ret fld.fold_item_mod(env_, i.span, mm_);
450+
ret fld.fold_item_mod(env_, i.span, mm_, id);
452451
}
453452

454453
case (ast.item_ty(?ty, ?id)) {
@@ -537,8 +536,8 @@ fn identity_fold_ty_tup[ENV](&ENV env, &span sp, vec[tup(bool,@ty)] elts)
537536
}
538537

539538
fn identity_fold_ty_path[ENV](&ENV env, &span sp, ast.path p,
540-
&option[referent] r) -> @ty {
541-
ret @respan(sp, ast.ty_path(p, r));
539+
&option[def] d) -> @ty {
540+
ret @respan(sp, ast.ty_path(p, d));
542541
}
543542

544543

@@ -604,8 +603,8 @@ fn identity_fold_expr_index[ENV](&ENV env, &span sp,
604603
}
605604

606605
fn identity_fold_expr_name[ENV](&ENV env, &span sp,
607-
&name n, &option[referent] r) -> @expr {
608-
ret @respan(sp, ast.expr_name(n, r));
606+
&name n, &option[def] d) -> @expr {
607+
ret @respan(sp, ast.expr_name(n, d));
609608
}
610609

611610

@@ -646,16 +645,17 @@ fn identity_fold_stmt_expr[ENV](&ENV e, &span sp, @expr x) -> @stmt {
646645
// Item identities.
647646

648647
fn identity_fold_item_fn[ENV](&ENV e, &span sp, &ast._fn f,
649-
ast.item_id id) -> @item {
648+
ast.def_id id) -> @item {
650649
ret @respan(sp, ast.item_fn(f, id));
651650
}
652651

653-
fn identity_fold_item_mod[ENV](&ENV e, &span sp, &ast._mod m) -> @item {
654-
ret @respan(sp, ast.item_mod(m));
652+
fn identity_fold_item_mod[ENV](&ENV e, &span sp, &ast._mod m,
653+
ast.def_id id) -> @item {
654+
ret @respan(sp, ast.item_mod(m, id));
655655
}
656656

657657
fn identity_fold_item_ty[ENV](&ENV e, &span sp, @ty t,
658-
ast.item_id id) -> @item {
658+
ast.def_id id) -> @item {
659659
ret @respan(sp, ast.item_ty(t, id));
660660
}
661661

@@ -667,7 +667,7 @@ fn identity_fold_block[ENV](&ENV e, &span sp, vec[@stmt] stmts) -> block {
667667
}
668668

669669
fn identity_fold_fn[ENV](&ENV e,
670-
vec[ast.input] inputs,
670+
vec[arg] inputs,
671671
&ast.ty output,
672672
block body) -> ast._fn {
673673
ret rec(inputs=inputs, output=output, body=body);
@@ -760,7 +760,7 @@ fn new_identity_fold[ENV]() -> ast_fold[ENV] {
760760
fold_stmt_expr = bind identity_fold_stmt_expr[ENV](_,_,_),
761761

762762
fold_item_fn = bind identity_fold_item_fn[ENV](_,_,_,_),
763-
fold_item_mod = bind identity_fold_item_mod[ENV](_,_,_),
763+
fold_item_mod = bind identity_fold_item_mod[ENV](_,_,_,_),
764764
fold_item_ty = bind identity_fold_item_ty[ENV](_,_,_,_),
765765

766766
fold_block = bind identity_fold_block[ENV](_,_,_),

0 commit comments

Comments
 (0)