From 35c745da03078c9bc58e6f6f2cf57c84e354f09d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafael=20=C3=81vila=20de=20Esp=C3=ADndola?= Date: Tue, 4 Jan 2011 10:17:43 -0500 Subject: [PATCH 1/3] Rename use_or_import to view_item. --- src/comp/front/ast.rs | 6 +++--- src/comp/front/parser.rs | 10 +++++----- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/src/comp/front/ast.rs b/src/comp/front/ast.rs index 9a4a5b24b83b4..1e229b349e61e 100644 --- a/src/comp/front/ast.rs +++ b/src/comp/front/ast.rs @@ -46,9 +46,9 @@ type use_node_ = rec(ident name, vec[@meta_item] metadata); type import_node = spanned[import_node_]; type import_node_ = rec(vec[ident] identifiers); -tag use_or_import { - use_or_import_use(@use_node); - use_or_import_import(@import_node); +tag view_item { + view_item_use(@use_node); + view_item_import(@import_node); } type meta_item = spanned[meta_item_]; diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index dd5a6b50d75da..b167bae460a3c 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -1405,7 +1405,7 @@ impure fn parse_item_obj(parser p, ast.layer lyr) -> @ast.item { } impure fn parse_mod_items(parser p, token.token term) -> ast._mod { - parse_use_and_imports(p); + parse_view(p); let vec[@ast.item] items = vec(); auto index = new_str_hash[ast.mod_index_entry](); @@ -1721,15 +1721,15 @@ impure fn parse_import(parser p) -> @ast.import_node { fail; } -impure fn parse_use_and_imports(parser p) -> vec[ast.use_or_import] { - let vec[ast.use_or_import] items = vec(); +impure fn parse_view(parser p) -> vec[ast.view_item] { + let vec[ast.view_item] items = vec(); while (true) { alt (p.peek()) { case (token.USE) { - items += vec(ast.use_or_import_use(parse_use(p))); + items += vec(ast.view_item_use(parse_use(p))); } case (token.IMPORT) { - items += vec(ast.use_or_import_import(parse_import(p))); + items += vec(ast.view_item_import(parse_import(p))); } case (_) { ret items; From 5fd3d2ca5516cfe5087d802c1b207943a64653da Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafael=20=C3=81vila=20de=20Esp=C3=ADndola?= Date: Sat, 1 Jan 2011 12:55:18 -0500 Subject: [PATCH 2/3] Refactor the view_item code so that it is similar to the code used for parsing regular items. --- src/comp/front/ast.rs | 17 +++++-------- src/comp/front/parser.rs | 53 ++++++++++++++++++++++++++-------------- 2 files changed, 40 insertions(+), 30 deletions(-) diff --git a/src/comp/front/ast.rs b/src/comp/front/ast.rs index 1e229b349e61e..55207de09edc9 100644 --- a/src/comp/front/ast.rs +++ b/src/comp/front/ast.rs @@ -40,17 +40,6 @@ tag def { type crate = spanned[crate_]; type crate_ = rec(_mod module); -type use_node = spanned[use_node_]; -type use_node_ = rec(ident name, vec[@meta_item] metadata); - -type import_node = spanned[import_node_]; -type import_node_ = rec(vec[ident] identifiers); - -tag view_item { - view_item_use(@use_node); - view_item_import(@import_node); -} - type meta_item = spanned[meta_item_]; type meta_item_ = rec(ident name, str value); @@ -233,6 +222,12 @@ type _mod = rec(vec[@item] items, type variant_arg = rec(@ty ty, def_id id); type variant = rec(str name, vec[variant_arg] args, def_id id, ann ann); +type view_item = spanned[view_item_]; +tag view_item_ { + view_item_use(ident, vec[@meta_item]); + view_item_import(vec[ident]); +} + type item = spanned[item_]; tag item_ { item_const(ident, @ty, @expr, def_id, ann); diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index b167bae460a3c..cdf2ae172ab04 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -1662,17 +1662,18 @@ impure fn parse_optional_meta(parser p) -> vec[@ast.meta_item] { } } -impure fn parse_use(parser p) -> @ast.use_node { +impure fn parse_use(parser p) -> @ast.view_item { auto lo = p.get_span(); auto hi = lo; expect(p, token.USE); auto ident = parse_ident(p); auto metadata = parse_optional_meta(p); expect(p, token.SEMI); - ret @spanned(lo, hi, rec(name = ident, metadata = metadata)); + auto use_decl = ast.view_item_use(ident, metadata); + ret @spanned(lo, hi, use_decl); } -impure fn parse_rest_import_name(parser p, ast.ident id) -> @ast.import_node { +impure fn parse_rest_import_name(parser p, ast.ident id) -> @ast.view_item { auto lo = p.get_span(); auto hi = lo; let vec[ast.ident] identifiers = vec(); @@ -1683,10 +1684,11 @@ impure fn parse_rest_import_name(parser p, ast.ident id) -> @ast.import_node { identifiers += i; } p.bump(); - ret @spanned(lo, hi, rec(identifiers = identifiers)); + auto import_decl = ast.view_item_import(identifiers); + ret @spanned(lo, hi, import_decl); } -impure fn parse_full_import_name(parser p) -> @ast.import_node { +impure fn parse_full_import_name(parser p) -> @ast.view_item { alt (p.peek()) { case (token.IDENT(?ident)) { p.bump(); @@ -1699,7 +1701,7 @@ impure fn parse_full_import_name(parser p) -> @ast.import_node { fail; } -impure fn parse_import(parser p) -> @ast.import_node { +impure fn parse_import(parser p) -> @ast.view_item { expect(p, token.IMPORT); alt (p.peek()) { case (token.IDENT(?ident)) { @@ -1721,21 +1723,34 @@ impure fn parse_import(parser p) -> @ast.import_node { fail; } -impure fn parse_view(parser p) -> vec[ast.view_item] { - let vec[ast.view_item] items = vec(); - while (true) { - alt (p.peek()) { - case (token.USE) { - items += vec(ast.view_item_use(parse_use(p))); - } - case (token.IMPORT) { - items += vec(ast.view_item_import(parse_import(p))); - } - case (_) { - ret items; - } +impure fn parse_use_or_import(parser p) -> @ast.view_item { + alt (p.peek()) { + case (token.USE) { + ret parse_use(p); } + case (token.IMPORT) { + ret parse_import(p); + } + } +} + +fn is_use_or_import(token.token t) -> bool { + if (t == token.USE) { + ret true; + } + if (t == token.IMPORT) { + ret true; + } + ret false; +} + +impure fn parse_view(parser p) -> vec[@ast.view_item] { + let vec[@ast.view_item] items = vec(); + while (is_use_or_import(p.peek())) { + auto item = parse_use_or_import(p); + items += vec(item); } + ret items; } impure fn parse_crate_from_crate_file(parser p) -> @ast.crate { From e0fe271d3459d04af9e1580c396b4698063e1999 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafael=20=C3=81vila=20de=20Esp=C3=ADndola?= Date: Sat, 1 Jan 2011 13:13:00 -0500 Subject: [PATCH 3/3] Add support for looking up a name introduced by a 'use'. With this we go from "error: unresolved name: foo" to "unimplemented definition variant for: foo" in use foo; fn main(vec[str] args) { foo.bar(); } --- src/comp/front/ast.rs | 12 ++++++++---- src/comp/front/parser.rs | 23 ++++++++++++++++------- src/comp/middle/resolve.rs | 14 ++++++++++++++ 3 files changed, 38 insertions(+), 11 deletions(-) diff --git a/src/comp/front/ast.rs b/src/comp/front/ast.rs index 55207de09edc9..15c0e4994a567 100644 --- a/src/comp/front/ast.rs +++ b/src/comp/front/ast.rs @@ -35,6 +35,7 @@ tag def { def_ty(def_id); def_ty_arg(def_id); def_binding(def_id); + def_use(def_id); } type crate = spanned[crate_]; @@ -212,20 +213,23 @@ type _obj = rec(vec[obj_field] fields, tag mod_index_entry { + mie_use(uint); mie_item(uint); mie_tag_variant(uint /* tag item index */, uint /* variant index */); } -type _mod = rec(vec[@item] items, - hashmap[ident,mod_index_entry] index); +type mod_index = hashmap[ident,mod_index_entry]; +type _mod = rec(vec[@view_item] view_items, + vec[@item] items, + mod_index index); type variant_arg = rec(@ty ty, def_id id); type variant = rec(str name, vec[variant_arg] args, def_id id, ann ann); type view_item = spanned[view_item_]; tag view_item_ { - view_item_use(ident, vec[@meta_item]); - view_item_import(vec[ident]); + view_item_use(ident, vec[@meta_item], def_id); + view_item_import(vec[ident], def_id); } type item = spanned[item_]; diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index cdf2ae172ab04..8c3db0e10ba30 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -1405,11 +1405,10 @@ impure fn parse_item_obj(parser p, ast.layer lyr) -> @ast.item { } impure fn parse_mod_items(parser p, token.token term) -> ast._mod { - parse_view(p); - - let vec[@ast.item] items = vec(); auto index = new_str_hash[ast.mod_index_entry](); + auto view_items = parse_view(p, index); let uint u = 0u; + let vec[@ast.item] items = vec(); while (p.peek() != term) { auto item = parse_item(p); items += vec(item); @@ -1443,7 +1442,7 @@ impure fn parse_mod_items(parser p, token.token term) -> ast._mod { u += 1u; } - ret rec(items=items, index=index); + ret rec(view_items=view_items, items=items, index=index); } impure fn parse_item_const(parser p) -> @ast.item { @@ -1669,7 +1668,7 @@ impure fn parse_use(parser p) -> @ast.view_item { auto ident = parse_ident(p); auto metadata = parse_optional_meta(p); expect(p, token.SEMI); - auto use_decl = ast.view_item_use(ident, metadata); + auto use_decl = ast.view_item_use(ident, metadata, p.next_def_id()); ret @spanned(lo, hi, use_decl); } @@ -1684,7 +1683,7 @@ impure fn parse_rest_import_name(parser p, ast.ident id) -> @ast.view_item { identifiers += i; } p.bump(); - auto import_decl = ast.view_item_import(identifiers); + auto import_decl = ast.view_item_import(identifiers, p.next_def_id()); ret @spanned(lo, hi, import_decl); } @@ -1744,11 +1743,21 @@ fn is_use_or_import(token.token t) -> bool { ret false; } -impure fn parse_view(parser p) -> vec[@ast.view_item] { +impure fn parse_view(parser p, ast.mod_index index) -> vec[@ast.view_item] { let vec[@ast.view_item] items = vec(); + let uint u = 0u; while (is_use_or_import(p.peek())) { auto item = parse_use_or_import(p); items += vec(item); + alt (item.node) { + case(ast.view_item_use(?id, _, _)) { + index.insert(id, ast.mie_use(u)); + } + case(ast.view_item_import(?ids,_)) { + // FIXME + } + } + u = u + 1u; } ret items; } diff --git a/src/comp/middle/resolve.rs b/src/comp/middle/resolve.rs index 7f344d95293e1..551993dda8b79 100644 --- a/src/comp/middle/resolve.rs +++ b/src/comp/middle/resolve.rs @@ -67,10 +67,24 @@ fn lookup_name(&env e, ast.ident i) -> option.t[def] { ret none[def]; } + fn found_def_view(@ast.view_item i) -> option.t[def] { + alt (i.node) { + case (ast.view_item_use(_, _, ?id)) { + ret some[def](ast.def_use(id)); + } + case (ast.view_item_import(_,?id)) { + fail; + } + } + } + fn check_mod(ast.ident i, ast._mod m) -> option.t[def] { alt (m.index.find(i)) { case (some[ast.mod_index_entry](?ent)) { alt (ent) { + case (ast.mie_use(?ix)) { + ret found_def_view(m.view_items.(ix)); + } case (ast.mie_item(?ix)) { ret found_def_item(m.items.(ix)); }