Skip to content

R
Rust

int / Rust
大约 1 年 前同步成功

通知 1
Star 0
Fork 0
R
Rust

体验新版 GitCode，发现更多精彩内容 >>

提交 15f71b36 编写于 作者: M Marijn Haverbeke
浏览文件
操作

Refactor ast::item representation 

Most of the fields in an AST item were present in all variants. Things
could be simplified considerably by putting them in the rec rather
than in the variant tags.
上级 6c2f322f
隐藏空白更改
内联 并排
Showing with 311 addition and 382 deletion
src/comp/front/ast.rs
浏览文件 @ 15f71b36
......@@ -459,28 +459,21 @@ fn unop_to_str(unop op) -> str {
type attribute_ = rec(attr_style style, meta_item value);
type item = spanned[item_];
type item = rec(ident ident,
vec[attribute] attrs,
def_id id, // For objs, this is the type def_id
ann ann,
item_ node,
span span);
tag item_ {
item_const(ident, @ty, @expr, vec[attribute], def_id, ann);
item_fn(ident, _fn, vec[ty_param], vec[attribute], def_id, ann);
item_mod(ident, _mod, vec[attribute], def_id);
item_native_mod(ident, native_mod, vec[attribute], def_id);
item_ty(ident, @ty, vec[ty_param], vec[attribute], def_id, ann);
item_tag(ident, vec[variant], vec[ty_param], vec[attribute], def_id, ann);
item_obj(ident, _obj, vec[ty_param], vec[attribute], obj_def_ids, ann);
}
fn item_ident(@item it) -> ident {
ret alt (it.node) {
case (item_const(?ident, _, _, _, _, _)) { ident }
case (item_fn(?ident, _, _, _, _, _)) { ident }
case (item_mod(?ident, _, _, _)) { ident }
case (item_native_mod(?ident, _, _, _)) { ident }
case (item_ty(?ident, _, _, _, _, _)) { ident }
case (item_tag(?ident, _, _, _, _, _)) { ident }
case (item_obj(?ident, _, _, _, _, _)) { ident }
}
item_const(@ty, @expr);
item_fn(_fn, vec[ty_param]);
item_mod(_mod);
item_native_mod(native_mod);
item_ty(@ty, vec[ty_param]);
item_tag(vec[variant], vec[ty_param]);
item_obj(_obj, vec[ty_param], def_id /* constructor id */);
}
type native_item = spanned[native_item_];
......@@ -498,15 +491,16 @@ fn item_ident(@item it) -> ident {
fn is_exported(ident i, _mod m) -> bool {
auto nonlocal = true;
for (@ast::item it in m.items) {
if (item_ident(it) == i) { nonlocal = false; }
if (it.ident == i) { nonlocal = false; }
alt (it.node) {
case (item_tag(_, ?variants, _, _, _, _)) {
case (item_tag(?variants, _)) {
for (variant v in variants) {
if (v.node.name == i) { nonlocal = false; }
}
}
case (_) { }
}
if (!nonlocal) { break; }
}
auto count = 0u;
for (@ast::view_item vi in m.view_items) {
......@@ -525,7 +519,7 @@ fn is_exported(ident i, _mod m) -> bool {
// If there are no declared exports then
// everything not imported is exported
if (count == 0u && !nonlocal) { ret true; } else { ret false; }
ret count == 0u && !nonlocal;
}
fn is_call_expr(@expr e) -> bool {
......
src/comp/front/eval.rs
浏览文件 @ 15f71b36
......@@ -294,8 +294,8 @@ fn eval_crate_directive(ctx cx, env e, @ast::crate_directive cdir, str prefix,
cx.p.set_def(next_id._1);
cx.chpos = p0.get_chpos();
cx.next_ann = p0.next_ann_num();
auto im = ast::item_mod(id, m0, [], next_id);
auto i = @spanned(cdir.span.lo, cdir.span.hi, im);
auto i = front::parser::mk_item(cx.p, cdir.span.lo, cdir.span.hi,
id, ast::item_mod(m0), []);
vec::push[@ast::item](items, i);
}
case (ast::cdir_dir_mod(?id, ?dir_opt, ?cdirs)) {
......@@ -303,8 +303,8 @@ fn eval_crate_directive(ctx cx, env e, @ast::crate_directive cdir, str prefix,
alt (dir_opt) { case (some(?d)) { path = d; } case (none) { } }
auto full_path = prefix + std::fs::path_sep() + path;
auto m0 = eval_crate_directives_to_mod(cx, e, cdirs, full_path);
auto im = ast::item_mod(id, m0, [], cx.p.next_def_id());
auto i = @spanned(cdir.span.lo, cdir.span.hi, im);
auto i = front::parser::mk_item
(cx.p, cdir.span.lo, cdir.span.hi, id, ast::item_mod(m0), []);
vec::push[@ast::item](items, i);
}
case (ast::cdir_view_item(?vi)) {
......
src/comp/front/parser.rs
浏览文件 @ 15f71b36
......@@ -1662,14 +1662,22 @@ fn parse_fn_header(&parser p) -> tup(ast::ident, vec[ast::ty_param]) {
ret tup(id, ty_params);
}
fn mk_item(&parser p, uint lo, uint hi, &ast::ident ident, &ast::item_ node,
&vec[ast::attribute] attrs) -> @ast::item {
ret @rec(ident=ident,
attrs=attrs,
id=p.next_def_id(),
ann=p.get_ann(),
node=node,
span=rec(lo=lo, hi=hi));
}
fn parse_item_fn_or_iter(&parser p, ast::purity purity, ast::proto proto,
vec[ast::attribute] attrs) -> @ast::item {
auto lo = p.get_last_lo_pos();
auto t = parse_fn_header(p);
auto f = parse_fn(p, proto, purity);
auto item =
ast::item_fn(t._0, f, t._1, attrs, p.next_def_id(), p.get_ann());
ret @spanned(lo, f.body.span.hi, item);
ret mk_item(p, lo, f.body.span.hi, t._0, ast::item_fn(f, t._1), attrs);
}
fn parse_obj_field(&parser p) -> ast::obj_field {
......@@ -1727,9 +1735,8 @@ fn parse_item_obj(&parser p, ast::layer lyr, vec[ast::attribute] attrs) ->
auto hi = p.get_hi_pos();
expect(p, token::RBRACE);
let ast::_obj ob = rec(fields=fields.node, methods=meths, dtor=dtor);
auto odid = rec(ty=p.next_def_id(), ctor=p.next_def_id());
auto item = ast::item_obj(ident, ob, ty_params, attrs, odid, p.get_ann());
ret @spanned(lo, hi, item);
ret mk_item(p, lo, hi, ident, ast::item_obj(ob, ty_params,
p.next_def_id()), attrs);
}
fn parse_mod_items(&parser p, token::token term) -> ast::_mod {
......@@ -1756,9 +1763,7 @@ fn parse_item_const(&parser p, vec[ast::attribute] attrs) -> @ast::item {
auto e = parse_expr(p);
auto hi = p.get_hi_pos();
expect(p, token::SEMI);
auto item =
ast::item_const(id, ty, e, attrs, p.next_def_id(), p.get_ann());
ret @spanned(lo, hi, item);
ret mk_item(p, lo, hi, id, ast::item_const(ty, e), attrs);
}
fn parse_item_mod(&parser p, vec[ast::attribute] attrs) -> @ast::item {
......@@ -1768,8 +1773,7 @@ fn parse_item_mod(&parser p, vec[ast::attribute] attrs) -> @ast::item {
auto m = parse_mod_items(p, token::RBRACE);
auto hi = p.get_hi_pos();
expect(p, token::RBRACE);
auto item = ast::item_mod(id, m, attrs, p.next_def_id());
ret @spanned(lo, hi, item);
ret mk_item(p, lo, hi, id, ast::item_mod(m), attrs);
}
fn parse_item_native_type(&parser p) -> @ast::native_item {
......@@ -1856,8 +1860,7 @@ fn parse_item_native_mod(&parser p, vec[ast::attribute] attrs) -> @ast::item {
auto m = parse_native_mod_items(p, native_name, abi);
auto hi = p.get_hi_pos();
expect(p, token::RBRACE);
auto item = ast::item_native_mod(id, m, attrs, p.next_def_id());
ret @spanned(lo, hi, item);
ret mk_item(p, lo, hi, id, ast::item_native_mod(m), attrs);
}
fn parse_type_decl(&parser p) -> tup(uint, ast::ident) {
......@@ -1873,9 +1876,7 @@ fn parse_item_type(&parser p, vec[ast::attribute] attrs) -> @ast::item {
auto ty = parse_ty(p);
auto hi = p.get_hi_pos();
expect(p, token::SEMI);
auto item =
ast::item_ty(t._1, ty, tps, attrs, p.next_def_id(), p.get_ann());
ret @spanned(t._0, hi, item);
ret mk_item(p, t._0, hi, t._1, ast::item_ty(ty, tps), attrs);
}
fn parse_item_tag(&parser p, vec[ast::attribute] attrs) -> @ast::item {
......@@ -1922,10 +1923,7 @@ fn parse_item_tag(&parser p, vec[ast::attribute] attrs) -> @ast::item {
}
auto hi = p.get_hi_pos();
p.bump();
auto item =
ast::item_tag(id, variants, ty_params, attrs, p.next_def_id(),
p.get_ann());
ret @spanned(lo, hi, item);
ret mk_item(p, lo, hi, id, ast::item_tag(variants, ty_params), attrs);
}
fn parse_layer(&parser p) -> ast::layer {
......
src/comp/middle/alias.rs
浏览文件 @ 15f71b36
......@@ -63,7 +63,7 @@ fn visit_fn(@ctx cx, &ast::_fn f, &vec[ast::ty_param] tp, &span sp,
fn visit_item(@ctx cx, &@ast::item i, &scope sc, &vt[scope] v) {
alt (i.node) {
case (ast::item_obj(_, ?o, _, _, _, _)) {
case (ast::item_obj(?o, _, _)) {
for (ast::obj_field f in o.fields) {
cx.local_map.insert(f.id._1, objfield(f.mut));
}
......
src/comp/middle/metadata.rs
浏览文件 @ 15f71b36
......@@ -361,64 +361,65 @@ fn encode_module_item_paths(&ebml::writer ebml_w, &ast::_mod module,
&vec[str] path,
&mutable vec[tup(str, uint)] index) {
for (@ast::item it in module.items) {
if (!ast::is_exported(ast::item_ident(it), module)) { cont; }
if (!ast::is_exported(it.ident, module)) { cont; }
alt (it.node) {
case (ast::item_const(?id, _, ?tps, _, ?did, ?ann)) {
add_to_index(ebml_w, path, index, id);
case (ast::item_const(_, _)) {
add_to_index(ebml_w, path, index, it.ident);
ebml::start_tag(ebml_w, tag_paths_data_item);
encode_name(ebml_w, id);
encode_def_id(ebml_w, did);
encode_name(ebml_w, it.ident);
encode_def_id(ebml_w, it.id);
ebml::end_tag(ebml_w);
}
case (ast::item_fn(?id, _, ?tps, _, ?did, ?ann)) {
add_to_index(ebml_w, path, index, id);
case (ast::item_fn(_, ?tps)) {
add_to_index(ebml_w, path, index, it.ident);
ebml::start_tag(ebml_w, tag_paths_data_item);
encode_name(ebml_w, id);
encode_def_id(ebml_w, did);
encode_name(ebml_w, it.ident);
encode_def_id(ebml_w, it.id);
ebml::end_tag(ebml_w);
}
case (ast::item_mod(?id, ?_mod, _, ?did)) {
add_to_index(ebml_w, path, index, id);
case (ast::item_mod(?_mod)) {
add_to_index(ebml_w, path, index, it.ident);
ebml::start_tag(ebml_w, tag_paths_data_mod);
encode_name(ebml_w, id);
encode_def_id(ebml_w, did);
encode_module_item_paths(ebml_w, _mod, path + [id], index);
encode_name(ebml_w, it.ident);
encode_def_id(ebml_w, it.id);
encode_module_item_paths(ebml_w, _mod, path + [it.ident],
index);
ebml::end_tag(ebml_w);
}
case (ast::item_native_mod(?id, ?nmod, _, ?did)) {
add_to_index(ebml_w, path, index, id);
case (ast::item_native_mod(?nmod)) {
add_to_index(ebml_w, path, index, it.ident);
ebml::start_tag(ebml_w, tag_paths_data_mod);
encode_name(ebml_w, id);
encode_def_id(ebml_w, did);
encode_native_module_item_paths(ebml_w, nmod, path + [id],
index);
encode_name(ebml_w, it.ident);
encode_def_id(ebml_w, it.id);
encode_native_module_item_paths(ebml_w, nmod,
path + [it.ident], index);
ebml::end_tag(ebml_w);
}
case (ast::item_ty(?id, _, ?tps, _, ?did, ?ann)) {
add_to_index(ebml_w, path, index, id);
case (ast::item_ty(_, ?tps)) {
add_to_index(ebml_w, path, index, it.ident);
ebml::start_tag(ebml_w, tag_paths_data_item);
encode_name(ebml_w, id);
encode_def_id(ebml_w, did);
encode_name(ebml_w, it.ident);
encode_def_id(ebml_w, it.id);
ebml::end_tag(ebml_w);
}
case (ast::item_tag(?id, ?variants, ?tps, _, ?did, _)) {
add_to_index(ebml_w, path, index, id);
case (ast::item_tag(?variants, ?tps)) {
add_to_index(ebml_w, path, index, it.ident);
ebml::start_tag(ebml_w, tag_paths_data_item);
encode_name(ebml_w, id);
encode_def_id(ebml_w, did);
encode_name(ebml_w, it.ident);
encode_def_id(ebml_w, it.id);
ebml::end_tag(ebml_w);
encode_tag_variant_paths(ebml_w, variants, path, index);
}
case (ast::item_obj(?id, _, ?tps, _, ?odid, ?ann)) {
add_to_index(ebml_w, path, index, id);
case (ast::item_obj(_, ?tps, ?ctor_id)) {
add_to_index(ebml_w, path, index, it.ident);
ebml::start_tag(ebml_w, tag_paths_data_item);
encode_name(ebml_w, id);
encode_def_id(ebml_w, odid.ctor);
encode_name(ebml_w, it.ident);
encode_def_id(ebml_w, ctor_id);
ebml::end_tag(ebml_w);
add_to_index(ebml_w, path, index, id);
add_to_index(ebml_w, path, index, it.ident);
ebml::start_tag(ebml_w, tag_paths_data_item);
encode_name(ebml_w, id);
encode_def_id(ebml_w, odid.ty);
encode_name(ebml_w, it.ident);
encode_def_id(ebml_w, it.id);
ebml::end_tag(ebml_w);
}
}
......@@ -509,67 +510,68 @@ fn encode_tag_variant_info(&@trans::crate_ctxt cx, &ebml::writer ebml_w,
fn encode_info_for_item(@trans::crate_ctxt cx, &ebml::writer ebml_w,
@ast::item item, &mutable vec[tup(int, uint)] index) {
alt (item.node) {
case (ast::item_const(_, _, _, _, ?did, ?ann)) {
case (ast::item_const(_, _)) {
ebml::start_tag(ebml_w, tag_items_data_item);
encode_def_id(ebml_w, did);
encode_def_id(ebml_w, item.id);
encode_kind(ebml_w, 'c' as u8);
encode_type(cx, ebml_w, trans::node_ann_type(cx, ann));
encode_symbol(cx, ebml_w, did);
encode_type(cx, ebml_w, trans::node_ann_type(cx, item.ann));
encode_symbol(cx, ebml_w, item.id);
ebml::end_tag(ebml_w);
}
case (ast::item_fn(_, _, ?tps, _, ?did, ?ann)) {
case (ast::item_fn(_, ?tps)) {
ebml::start_tag(ebml_w, tag_items_data_item);
encode_def_id(ebml_w, did);
encode_def_id(ebml_w, item.id);
encode_kind(ebml_w, 'f' as u8);
encode_type_param_count(ebml_w, tps);
encode_type(cx, ebml_w, trans::node_ann_type(cx, ann));
encode_symbol(cx, ebml_w, did);
encode_type(cx, ebml_w, trans::node_ann_type(cx, item.ann));
encode_symbol(cx, ebml_w, item.id);
ebml::end_tag(ebml_w);
}
case (ast::item_mod(_, _, _, ?did)) {
case (ast::item_mod(_)) {
ebml::start_tag(ebml_w, tag_items_data_item);
encode_def_id(ebml_w, did);
encode_def_id(ebml_w, item.id);
encode_kind(ebml_w, 'm' as u8);
ebml::end_tag(ebml_w);
}
case (ast::item_native_mod(?id, _, _, ?did)) {
case (ast::item_native_mod(_)) {
ebml::start_tag(ebml_w, tag_items_data_item);
encode_def_id(ebml_w, did);
encode_def_id(ebml_w, item.id);
encode_kind(ebml_w, 'n' as u8);
ebml::end_tag(ebml_w);
}
case (ast::item_ty(?id, _, ?tps, _, ?did, ?ann)) {
case (ast::item_ty(_, ?tps)) {
ebml::start_tag(ebml_w, tag_items_data_item);
encode_def_id(ebml_w, did);
encode_def_id(ebml_w, item.id);
encode_kind(ebml_w, 'y' as u8);
encode_type_param_count(ebml_w, tps);
encode_type(cx, ebml_w, trans::node_ann_type(cx, ann));
encode_type(cx, ebml_w, trans::node_ann_type(cx, item.ann));
ebml::end_tag(ebml_w);
}
case (ast::item_tag(?id, ?variants, ?tps, _, ?did, ?ann)) {
case (ast::item_tag(?variants, ?tps)) {
ebml::start_tag(ebml_w, tag_items_data_item);
encode_def_id(ebml_w, did);
encode_def_id(ebml_w, item.id);
encode_kind(ebml_w, 't' as u8);
encode_type_param_count(ebml_w, tps);
encode_type(cx, ebml_w, trans::node_ann_type(cx, ann));
encode_type(cx, ebml_w, trans::node_ann_type(cx, item.ann));
for (ast::variant v in variants) {
encode_variant_id(ebml_w, v.node.id);
}
ebml::end_tag(ebml_w);
encode_tag_variant_info(cx, ebml_w, did, variants, index, tps);
encode_tag_variant_info(cx, ebml_w, item.id, variants,
index, tps);
}
case (ast::item_obj(?id, _, ?tps, _, ?odid, ?ann)) {
case (ast::item_obj(_, ?tps, ?ctor_id)) {
ebml::start_tag(ebml_w, tag_items_data_item);
encode_def_id(ebml_w, odid.ctor);
encode_def_id(ebml_w, ctor_id);
encode_kind(ebml_w, 'o' as u8);
encode_type_param_count(ebml_w, tps);
auto fn_ty = trans::node_ann_type(cx, ann);
auto fn_ty = trans::node_ann_type(cx, item.ann);
encode_type(cx, ebml_w, fn_ty);
encode_symbol(cx, ebml_w, odid.ctor);
encode_symbol(cx, ebml_w, ctor_id);
ebml::end_tag(ebml_w);
index += [tup(odid.ty._1, ebml_w.writer.tell())];
index += [tup(item.id._1, ebml_w.writer.tell())];
ebml::start_tag(ebml_w, tag_items_data_item);
encode_def_id(ebml_w, odid.ty);
encode_def_id(ebml_w, item.id);
encode_kind(ebml_w, 'y' as u8);
encode_type_param_count(ebml_w, tps);
encode_type(cx, ebml_w, ty::ty_fn_ret(cx.tcx, fn_ty));
......
src/comp/middle/resolve.rs
浏览文件 @ 15f71b36
......@@ -176,39 +176,30 @@ fn index_vi(@env e, &@ast::view_item i, &scopes sc, &vt[scopes] v) {
fn index_i(@env e, &@ast::item i, &scopes sc, &vt[scopes] v) {
visit_item_with_scope(i, sc, v);
alt (i.node) {
case (ast::item_mod(_, ?md, _, ?defid)) {
case (ast::item_mod(?md)) {
auto s = new_str_hash[import_state]();
e.mod_map.insert(defid._1,
e.mod_map.insert(i.id._1,
@rec(m=some(md),
index=index_mod(md),
mutable glob_imports=vec::empty[def](),
glob_imported_names=s));
e.ast_map.insert(defid, i);
e.ast_map.insert(i.id, i);
}
case (ast::item_native_mod(_, ?nmd, _, ?defid)) {
case (ast::item_native_mod(?nmd)) {
auto s = new_str_hash[import_state]();
e.mod_map.insert(defid._1,
e.mod_map.insert(i.id._1,
@rec(m=none[ast::_mod],
index=index_nmod(nmd),
mutable glob_imports=vec::empty[def](),
glob_imported_names=s));
e.ast_map.insert(defid, i);
e.ast_map.insert(i.id, i);
}
case (ast::item_const(_, _, _, _, ?defid, _)) {
e.ast_map.insert(defid, i);
case (ast::item_obj(_, _, ?ctor_id)) {
e.ast_map.insert(i.id, i);
e.ast_map.insert(ctor_id, i);
}
case (ast::item_fn(_, _, _, _, ?defid, _)) {
e.ast_map.insert(defid, i);
}
case (ast::item_ty(_, _, _, _, ?defid, _)) {
e.ast_map.insert(defid, i);
}
case (ast::item_tag(_, _, _, _, ?defid, _)) {
e.ast_map.insert(defid, i);
}
case (ast::item_obj(_, _, _, _, ?obj_def_ids, _)) {
e.ast_map.insert(obj_def_ids.ty, i);
e.ast_map.insert(obj_def_ids.ctor, i);
case (_) {
e.ast_map.insert(i.id, i);
}
}
}
......@@ -225,11 +216,11 @@ fn find_mod(@env e, scopes sc) -> @indexed_mod {
alt (sc) {
case (cons(scope_item(?i), ?tl)) {
alt (i.node) {
case (ast::item_mod(_, _, _, ?defid)) {
ret e.mod_map.get(defid._1);
case (ast::item_mod(_)) {
ret e.mod_map.get(i.id._1);
}
case (ast::item_native_mod(_, _, _, ?defid)) {
ret e.mod_map.get(defid._1);
case (ast::item_native_mod(_)) {
ret e.mod_map.get(i.id._1);
}
case (_) { be find_mod(e, *tl); }
}
......@@ -556,21 +547,21 @@ fn in_scope(&env e, &span sp, &ident id, &scope s, namespace ns) ->
}
case (scope_item(?it)) {
alt (it.node) {
case (ast::item_obj(_, ?ob, ?ty_params, _, _, _)) {
case (ast::item_obj(?ob, ?ty_params, _)) {
ret lookup_in_obj(id, ob, ty_params, ns);
}
case (ast::item_tag(_, _, ?ty_params, _, _, _)) {
case (ast::item_tag(_, ?ty_params)) {
if (ns == ns_type) {
ret lookup_in_ty_params(id, ty_params);
}
}
case (ast::item_mod(_, _, _, ?defid)) {
ret lookup_in_local_mod(e, defid, sp, id, ns, inside);
case (ast::item_mod(_)) {
ret lookup_in_local_mod(e, it.id, sp, id, ns, inside);
}
case (ast::item_native_mod(_, ?m, _, ?defid)) {
ret lookup_in_local_native_mod(e, defid, sp, id, ns);
case (ast::item_native_mod(?m)) {
ret lookup_in_local_native_mod(e, it.id, sp, id, ns);
}
case (ast::item_ty(_, _, ?ty_params, _, _, _)) {
case (ast::item_ty(_, ?ty_params)) {
if (ns == ns_type) {
ret lookup_in_ty_params(id, ty_params);
}
......@@ -702,24 +693,23 @@ fn lookup_in_block(&ident id, &ast::block_ b, namespace ns) ->
}
case (ast::decl_item(?it)) {
alt (it.node) {
case (ast::item_tag(?name, ?variants, _, _,
?defid, _)) {
case (ast::item_tag(?variants, _)) {
if (ns == ns_type) {
if (str::eq(name, id)) {
ret some(ast::def_ty(defid));
if (str::eq(it.ident, id)) {
ret some(ast::def_ty(it.id));
}
} else if (ns == ns_value) {
for (ast::variant v in variants) {
if (str::eq(v.node.name, id)) {
auto i = v.node.id;
ret some(ast::def_variant(defid,
ret some(ast::def_variant(it.id,
i));
}
}
}
}
case (_) {
if (str::eq(ast::item_ident(it), id)) {
if (str::eq(it.ident, id)) {
auto found = found_def_item(it, ns);
if (!option::is_none(found)) {
ret found;
......@@ -738,28 +728,28 @@ fn lookup_in_block(&ident id, &ast::block_ b, namespace ns) ->
fn found_def_item(&@ast::item i, namespace ns) -> option::t[def] {
alt (i.node) {
case (ast::item_const(_, _, _, _, ?defid, _)) {
if (ns == ns_value) { ret some(ast::def_const(defid)); }
case (ast::item_const(_, _)) {
if (ns == ns_value) { ret some(ast::def_const(i.id)); }
}
case (ast::item_fn(_, _, _, _, ?defid, _)) {
if (ns == ns_value) { ret some(ast::def_fn(defid)); }
case (ast::item_fn(_, _)) {
if (ns == ns_value) { ret some(ast::def_fn(i.id)); }
}
case (ast::item_mod(_, _, _, ?defid)) {
if (ns == ns_module) { ret some(ast::def_mod(defid)); }
case (ast::item_mod(_)) {
if (ns == ns_module) { ret some(ast::def_mod(i.id)); }
}
case (ast::item_native_mod(_, _, _, ?defid)) {
if (ns == ns_module) { ret some(ast::def_native_mod(defid)); }
case (ast::item_native_mod(_)) {
if (ns == ns_module) { ret some(ast::def_native_mod(i.id)); }
}
case (ast::item_ty(_, _, _, _, ?defid, _)) {
if (ns == ns_type) { ret some(ast::def_ty(defid)); }
case (ast::item_ty(_, _)) {
if (ns == ns_type) { ret some(ast::def_ty(i.id)); }
}
case (ast::item_tag(_, _, _, _, ?defid, _)) {
if (ns == ns_type) { ret some(ast::def_ty(defid)); }
case (ast::item_tag(_, _)) {
if (ns == ns_type) { ret some(ast::def_ty(i.id)); }
}
case (ast::item_obj(_, _, _, _, ?odid, _)) {
case (ast::item_obj(_, _, ?ctor_id)) {
alt (ns) {
case (ns_value) { ret some(ast::def_obj(odid.ctor)); }
case (ns_type) { ret some(ast::def_obj(odid.ty)); }
case (ns_value) { ret some(ast::def_obj(ctor_id)); }
case (ns_type) { ret some(ast::def_obj(i.id)); }
case (_) { }
}
}
......@@ -939,10 +929,10 @@ fn lookup_in_mie(&env e, &mod_index_entry mie, namespace ns) ->
case (mie_item(?item)) { ret found_def_item(item, ns); }
case (mie_tag_variant(?item, ?variant_idx)) {
alt (item.node) {
case (ast::item_tag(_, ?variants, _, _, ?tid, _)) {
case (ast::item_tag(?variants, _)) {
if (ns == ns_value) {
auto vid = variants.(variant_idx).node.id;
ret some(ast::def_variant(tid, vid));
ret some(ast::def_variant(item.id, vid));
} else { ret none[def]; }
}
}
......@@ -991,23 +981,23 @@ fn index_mod(&ast::_mod md) -> mod_index {
}
for (@ast::item it in md.items) {
alt (it.node) {
case (ast::item_const(?id, _, _, _, _, _)) {
add_to_index(index, id, mie_item(it));
case (ast::item_const(_, _)) {
add_to_index(index, it.ident, mie_item(it));
}
case (ast::item_fn(?id, _, _, _, _, _)) {
add_to_index(index, id, mie_item(it));
case (ast::item_fn(_, _)) {
add_to_index(index, it.ident, mie_item(it));
}
case (ast::item_mod(?id, _, _, _)) {
add_to_index(index, id, mie_item(it));
case (ast::item_mod(_)) {
add_to_index(index, it.ident, mie_item(it));
}
case (ast::item_native_mod(?id, _, _, _)) {
add_to_index(index, id, mie_item(it));
case (ast::item_native_mod(_)) {
add_to_index(index, it.ident, mie_item(it));
}
case (ast::item_ty(?id, _, _, _, _, _)) {
add_to_index(index, id, mie_item(it));
case (ast::item_ty(_, _)) {
add_to_index(index, it.ident, mie_item(it));
}
case (ast::item_tag(?id, ?variants, _, _, _, _)) {
add_to_index(index, id, mie_item(it));
case (ast::item_tag(?variants, _)) {
add_to_index(index, it.ident, mie_item(it));
let uint variant_idx = 0u;
for (ast::variant v in variants) {
add_to_index(index, v.node.name,
......@@ -1015,8 +1005,8 @@ fn index_mod(&ast::_mod md) -> mod_index {
variant_idx += 1u;
}
}
case (ast::item_obj(?id, _, _, _, _, _)) {
add_to_index(index, id, mie_item(it));
case (ast::item_obj(_, _, _)) {
add_to_index(index, it.ident, mie_item(it));
}
}
}
......@@ -1143,11 +1133,11 @@ fn mie_span(&mod_index_entry mie) -> span {
fn check_item(@env e, &@ast::item i, &() x, &vt[()] v) {
visit::visit_item(i, x, v);
alt (i.node) {
case (ast::item_fn(_, ?f, ?ty_params, _, _, _)) {
case (ast::item_fn(?f, ?ty_params)) {
check_fn(*e, i.span, f);
ensure_unique(*e, i.span, ty_params, ident_id, "type parameter");
}
case (ast::item_obj(_, ?ob, ?ty_params, _, _, _)) {
case (ast::item_obj(?ob, ?ty_params, _)) {
fn field_name(&ast::obj_field field) -> ident { ret field.ident; }
ensure_unique(*e, i.span, ob.fields, field_name, "object field");
for (@ast::method m in ob.methods) {
......@@ -1155,7 +1145,7 @@ fn check_item(@env e, &@ast::item i, &() x, &vt[()] v) {
}
ensure_unique(*e, i.span, ty_params, ident_id, "type parameter");
}
case (ast::item_tag(_, _, ?ty_params, _, _, _)) {
case (ast::item_tag(_, ?ty_params)) {
ensure_unique(*e, i.span, ty_params, ident_id, "type parameter");
}
case (_) { }
......@@ -1190,31 +1180,30 @@ fn check_block(@env e, &ast::block b, &() x, &vt[()] v) {
}
case (ast::decl_item(?it)) {
alt (it.node) {
case (ast::item_tag(?name, ?variants, _, _, _, _))
{
add_name(types, it.span, name);
case (ast::item_tag(?variants, _)) {
add_name(types, it.span, it.ident);
for (ast::variant v in variants) {
add_name(values, v.span, v.node.name);
}
}
case (ast::item_const(?name, _, _, _, _, _)) {
add_name(values, it.span, name);
case (ast::item_const(_, _)) {
add_name(values, it.span, it.ident);
}
case (ast::item_fn(?name, _, _, _, _, _)) {
add_name(values, it.span, name);
case (ast::item_fn(_, _)) {
add_name(values, it.span, it.ident);
}
case (ast::item_mod(?name, _, _, _)) {
add_name(mods, it.span, name);
case (ast::item_mod(_)) {
add_name(mods, it.span, it.ident);
}
case (ast::item_native_mod(?name, _, _, _)) {
add_name(mods, it.span, name);
case (ast::item_native_mod(_)) {
add_name(mods, it.span, it.ident);
}
case (ast::item_ty(?name, _, _, _, _, _)) {
add_name(types, it.span, name);
case (ast::item_ty(_, _)) {
add_name(types, it.span, it.ident);
}
case (ast::item_obj(?name, _, _, _, _, _)) {
add_name(types, it.span, name);
add_name(values, it.span, name);
case (ast::item_obj(_, _, _)) {
add_name(types, it.span, it.ident);
add_name(values, it.span, it.ident);
}
case (_) { }
}
......
src/comp/middle/trans.rs
浏览文件 @ 15f71b36
......@@ -7254,34 +7254,34 @@ fn trans_const(&@crate_ctxt cx, @ast::expr e, &ast::def_id cid,
fn trans_item(@local_ctxt cx, &ast::item item) {
alt (item.node) {
case (ast::item_fn(?name, ?f, ?tps, _, ?fid, ?ann)) {
auto sub_cx = extend_path(cx, name);
auto llfndecl = cx.ccx.item_ids.get(fid);
case (ast::item_fn(?f, ?tps)) {
auto sub_cx = extend_path(cx, item.ident);
auto llfndecl = cx.ccx.item_ids.get(item.id);
trans_fn(sub_cx, item.span, f, llfndecl, none[ty_self_pair], tps,
ann);
item.ann);
}
case (ast::item_obj(?name, ?ob, ?tps, _, ?oid, ?ann)) {
case (ast::item_obj(?ob, ?tps, ?ctor_id)) {
auto sub_cx =
@rec(obj_typarams=tps, obj_fields=ob.fields
with *extend_path(cx, name));
trans_obj(sub_cx, item.span, ob, oid.ctor, tps, ann);
with *extend_path(cx, item.ident));
trans_obj(sub_cx, item.span, ob, ctor_id, tps, item.ann);
}
case (ast::item_mod(?name, ?m, _, _)) {
case (ast::item_mod(?m)) {
auto sub_cx =
@rec(path=cx.path + [name],
module_path=cx.module_path + [name] with *cx);
@rec(path=cx.path + [item.ident],
module_path=cx.module_path + [item.ident] with *cx);
trans_mod(sub_cx, m);
}
case (ast::item_tag(?name, ?variants, ?tps, _, ?tag_id, _)) {
auto sub_cx = extend_path(cx, name);
case (ast::item_tag(?variants, ?tps)) {
auto sub_cx = extend_path(cx, item.ident);
auto i = 0;
for (ast::variant variant in variants) {
trans_tag_variant(sub_cx, tag_id, variant, i, tps);
trans_tag_variant(sub_cx, item.id, variant, i, tps);
i += 1;
}
}
case (ast::item_const(?name, _, ?expr, _, ?cid, ?ann)) {
trans_const(cx.ccx, expr, cid, ann);
case (ast::item_const(_, ?expr)) {
trans_const(cx.ccx, expr, item.id, item.ann);
}
case (_) {/* fall through */ }
}
......@@ -7545,12 +7545,7 @@ fn trans_simple_native_abi(&@block_ctxt bcx, str name,
}
fn item_path(&@ast::item item) -> vec[str] {
alt (item.node) {
case (ast::item_fn(?name, _, _, _, _, _)) { ret [name]; }
case (ast::item_obj(?name, _, _, _, _, _)) { ret [name]; }
case (ast::item_mod(?name, _, _, _)) { ret [name]; }
case (_) { ret []; }
}
ret [item.ident];
}
fn collect_native_item(@crate_ctxt ccx, &@ast::native_item i, &vec[str] pt,
......@@ -7572,25 +7567,21 @@ fn collect_item_1(@crate_ctxt ccx, &@ast::item i, &vec[str] pt,
&vt[vec[str]] v) {
visit::visit_item(i, pt + item_path(i), v);
alt (i.node) {
case (ast::item_const(?name, _, _, _, ?cid, ?ann)) {
auto typ = node_ann_type(ccx, ann);
case (ast::item_const(_, _)) {
auto typ = node_ann_type(ccx, i.ann);
auto g =
llvm::LLVMAddGlobal(ccx.llmod, type_of(ccx, i.span, typ),
str::buf(ccx.names.next(name)));
str::buf(ccx.names.next(i.ident)));
llvm::LLVMSetLinkage(g,
lib::llvm::LLVMInternalLinkage as
llvm::Linkage);
ccx.items.insert(cid, i);
ccx.consts.insert(cid, g);
}
case (ast::item_mod(?name, ?m, _, ?mid)) { ccx.items.insert(mid, i); }
case (ast::item_native_mod(_, _, _, ?mid)) {
ccx.items.insert(mid, i);
}
case (ast::item_ty(_, _, _, _, ?did, _)) { ccx.items.insert(did, i); }
case (ast::item_tag(?name, ?variants, ?tps, _, ?tag_id, _)) {
ccx.items.insert(tag_id, i);
ccx.items.insert(i.id, i);
ccx.consts.insert(i.id, g);
}
case (ast::item_mod(?m)) { ccx.items.insert(i.id, i); }
case (ast::item_native_mod(_)) { ccx.items.insert(i.id, i); }
case (ast::item_ty(_, _)) { ccx.items.insert(i.id, i); }
case (ast::item_tag(_, _)) { ccx.items.insert(i.id, i); }
case (_) { }
}
}
......@@ -7600,16 +7591,16 @@ fn collect_item_2(&@crate_ctxt ccx, &@ast::item i, &vec[str] pt,
auto new_pt = pt + item_path(i);
visit::visit_item(i, new_pt, v);
alt (i.node) {
case (ast::item_fn(?name, ?f, ?tps, _, ?fid, ?ann)) {
ccx.items.insert(fid, i);
if (!ccx.obj_methods.contains_key(fid)) {
decl_fn_and_pair(ccx, i.span, new_pt, "fn", tps, ann, fid);
case (ast::item_fn(?f, ?tps)) {
ccx.items.insert(i.id, i);
if (!ccx.obj_methods.contains_key(i.id)) {
decl_fn_and_pair(ccx, i.span, new_pt, "fn", tps, i.ann, i.id);
}
}
case (ast::item_obj(?name, ?ob, ?tps, _, ?oid, ?ann)) {
ccx.items.insert(oid.ctor, i);
decl_fn_and_pair(ccx, i.span, new_pt, "obj_ctor", tps, ann,
oid.ctor);
case (ast::item_obj(?ob, ?tps, ?ctor_id)) {
ccx.items.insert(ctor_id, i);
decl_fn_and_pair(ccx, i.span, new_pt, "obj_ctor", tps, i.ann,
ctor_id);
for (@ast::method m in ob.methods) {
ccx.obj_methods.insert(m.node.id, ());
}
......@@ -7634,7 +7625,7 @@ fn collect_tag_ctor(@crate_ctxt ccx, &@ast::item i, &vec[str] pt,
auto new_pt = pt + item_path(i);
visit::visit_item(i, new_pt, v);
alt (i.node) {
case (ast::item_tag(_, ?variants, ?tps, _, _, _)) {
case (ast::item_tag(?variants, ?tps)) {
for (ast::variant variant in variants) {
if (vec::len[ast::variant_arg](variant.node.args) != 0u) {
decl_fn_and_pair(ccx, i.span,
......@@ -7661,13 +7652,13 @@ fn trans_constant(@crate_ctxt ccx, &@ast::item it, &vec[str] pt,
auto new_pt = pt + item_path(it);
visit::visit_item(it, new_pt, v);
alt (it.node) {
case (ast::item_tag(?ident, ?variants, _, _, ?tag_id, _)) {
case (ast::item_tag(?variants, _)) {
auto i = 0u;
auto n_variants = vec::len[ast::variant](variants);
while (i < n_variants) {
auto variant = variants.(i);
auto discrim_val = C_int(i as int);
auto p = new_pt + [ident, variant.node.name, "discrim"];
auto p = new_pt + [it.ident, variant.node.name, "discrim"];
auto s = mangle_exported_name(ccx, p, ty::mk_int(ccx.tcx));
auto discrim_gvar =
llvm::LLVMAddGlobal(ccx.llmod, T_int(), str::buf(s));
......@@ -7678,16 +7669,16 @@ fn trans_constant(@crate_ctxt ccx, &@ast::item it, &vec[str] pt,
i += 1u;
}
}
case (ast::item_const(?name, _, ?expr, _, ?cid, ?ann)) {
case (ast::item_const(_, ?expr)) {
// FIXME: The whole expr-translation system needs cloning to deal
// with consts.
auto v = C_int(1);
ccx.item_ids.insert(cid, v);
ccx.item_ids.insert(it.id, v);
auto s =
mangle_exported_name(ccx, new_pt + [name],
node_ann_type(ccx, ann));
ccx.item_symbols.insert(cid, s);
mangle_exported_name(ccx, new_pt + [it.ident],
node_ann_type(ccx, it.ann));
ccx.item_symbols.insert(it.id, s);
}
case (_) { }
}
......
src/comp/middle/tstate/pre_post_conditions.rs
浏览文件 @ 15f71b36
......@@ -61,7 +61,6 @@
import front::ast::*;
import middle::ty::expr_ann;
import util::common::new_def_hash;
import util::common::decl_lhs;
import util::common::uistr;
import util::common::log_expr;
import util::common::log_fn;
......@@ -101,9 +100,8 @@ fn do_a_method(crate_ctxt ccx, &@method m) {
fn find_pre_post_item(&crate_ctxt ccx, &item i) {
alt (i.node) {
case (item_const(?id, ?t, ?e, _, ?di, ?a)) {
case (item_const(_, ?e)) {
// make a fake fcx
auto fake_fcx =
rec(enclosing=rec(constrs=@new_def_hash[constraint](),
num_constraints=0u,
......@@ -113,18 +111,19 @@ fn find_pre_post_item(&crate_ctxt ccx, &item i) {
ccx=ccx);
find_pre_post_expr(fake_fcx, e);
}
case (item_fn(?id, ?f, ?ps, _, ?di, ?a)) {
assert (ccx.fm.contains_key(di));
auto fcx = rec(enclosing=ccx.fm.get(di), id=di, name=id, ccx=ccx);
case (item_fn(?f, ?ps)) {
assert (ccx.fm.contains_key(i.id));
auto fcx = rec(enclosing=ccx.fm.get(i.id), id=i.id,
name=i.ident, ccx=ccx);
find_pre_post_fn(fcx, f);
}
case (item_mod(?id, ?m, _, ?di)) { find_pre_post_mod(m); }
case (item_native_mod(?id, ?nm, _, ?di)) {
case (item_mod(?m)) { find_pre_post_mod(m); }
case (item_native_mod(?nm)) {
find_pre_post_native_mod(nm);
}
case (item_ty(_, _, _, _, _, _)) { ret; }
case (item_tag(_, _, _, _, _, _)) { ret; }
case (item_obj(?id, ?o, ?ps, _, ?di, ?a)) {
case (item_ty(_, _)) { ret; }
case (item_tag(_, _)) { ret; }
case (item_obj(?o, _, _)) {
find_pre_post_obj(ccx, o);
}
}
......
src/comp/middle/tstate/states.rs
浏览文件 @ 15f71b36
......@@ -66,7 +66,6 @@
import middle::ty::type_is_nil;
import middle::ty::type_is_bot;
import util::common::new_def_hash;
import util::common::decl_lhs;
import util::common::uistr;
import util::common::log_expr;
import util::common::log_block;
......
src/comp/middle/ty.rs
浏览文件 @ 15f71b36
......@@ -1507,26 +1507,6 @@ fn pat_ty(&ctxt cx, &@ast::pat pat) -> t {
ret ann_to_monotype(cx, pat_ann(pat));
}
fn item_ann(&@ast::item it) -> ast::ann {
alt (it.node) {
case (ast::item_const(_, _, _, _, _, ?a)) { ret a; }
case (ast::item_fn(_, _, _, _, _, ?a)) { ret a; }
case (ast::item_mod(_, _, _, _)) {
log_err "a module was passed to item_ann(), " +
"but modules haven't annotations";
fail;
}
case (ast::item_native_mod(_, _, _, _)) {
log_err "a native module was passed to item_ann(), " +
"but native modules haven't annotations";
fail;
}
case (ast::item_ty(_, _, _, _, _, ?a)) { ret a; }
case (ast::item_tag(_, _, _, _, _, ?a)) { ret a; }
case (ast::item_obj(_, _, _, _, _, ?a)) { ret a; }
}
}
fn expr_ann(&@ast::expr e) -> ast::ann {
alt (e.node) {
case (ast::expr_vec(_, _, _, ?a)) { ret a; }
......@@ -2441,7 +2421,7 @@ fn tag_variants(&ctxt cx, &ast::def_id id) -> vec[variant_info] {
alt (cx.items.get(id)) {
case (any_item_rust(?item)) {
alt (item.node) {
case (ast::item_tag(_, ?variants, _, _, _, _)) {
case (ast::item_tag(?variants, _)) {
let vec[variant_info] result = [];
for (ast::variant variant in variants) {
auto ctor_ty = ann_to_monotype(cx, variant.node.ann);
......
src/comp/middle/typeck.rs
浏览文件 @ 15f71b36
......@@ -559,24 +559,24 @@ fn ty_of_item(&@ctxt cx, &@ast::item it) -> ty::ty_param_count_and_ty {
auto get = bind getter(cx, _);
auto convert = bind ast_ty_to_ty(cx.tcx, get, _);
alt (it.node) {
case (ast::item_const(?ident, ?t, _, _, ?def_id, _)) {
case (ast::item_const(?t, _)) {
auto typ = convert(t);
auto tpt = tup(0u, typ);
cx.tcx.tcache.insert(def_id, tpt);
cx.tcx.tcache.insert(it.id, tpt);
ret tpt;
}
case (ast::item_fn(?ident, ?fn_info, ?tps, _, ?def_id, _)) {
case (ast::item_fn(?fn_info, ?tps)) {
auto f = bind ty_of_arg(cx, _);
ret ty_of_fn_decl(cx, convert, f, fn_info.decl, fn_info.proto,
tps, some(def_id));
tps, some(it.id));
}
case (ast::item_obj(?ident, ?obj_info, ?tps, _, ?odid, _)) {
auto t_obj = ty_of_obj(cx, ident, obj_info, tps);
cx.tcx.tcache.insert(odid.ty, t_obj);
case (ast::item_obj(?obj_info, ?tps, _)) {
auto t_obj = ty_of_obj(cx, it.ident, obj_info, tps);
cx.tcx.tcache.insert(it.id, t_obj);
ret t_obj;
}
case (ast::item_ty(?ident, ?t, ?tps, _, ?def_id, _)) {
alt (cx.tcx.tcache.find(def_id)) {
case (ast::item_ty(?t, ?tps)) {
alt (cx.tcx.tcache.find(it.id)) {
case (some(?tpt)) { ret tpt; }
case (none) { }
}
......@@ -586,10 +586,10 @@ fn ty_of_item(&@ctxt cx, &@ast::item it) -> ty::ty_param_count_and_ty {
auto typ = convert(t);
auto ty_param_count = vec::len[ast::ty_param](tps);
auto tpt = tup(ty_param_count, typ);
cx.tcx.tcache.insert(def_id, tpt);
cx.tcx.tcache.insert(it.id, tpt);
ret tpt;
}
case (ast::item_tag(_, _, ?tps, _, ?def_id, _)) {
case (ast::item_tag(_, ?tps)) {
// Create a new generic polytype.
let vec[ty::t] subtys = [];
......@@ -598,28 +598,27 @@ fn ty_of_item(&@ctxt cx, &@ast::item it) -> ty::ty_param_count_and_ty {
subtys += [ty::mk_param(cx.tcx, i)];
i += 1u;
}
auto t = ty::mk_tag(cx.tcx, def_id, subtys);
auto t = ty::mk_tag(cx.tcx, it.id, subtys);
auto ty_param_count = vec::len[ast::ty_param](tps);
auto tpt = tup(ty_param_count, t);
cx.tcx.tcache.insert(def_id, tpt);
cx.tcx.tcache.insert(it.id, tpt);
ret tpt;
}
case (ast::item_mod(_, _, _, _)) { fail; }
case (ast::item_native_mod(_, _, _, _)) { fail; }
case (ast::item_mod(_)) { fail; }
case (ast::item_native_mod(_)) { fail; }
}
}
fn ty_of_native_item(&@ctxt cx, &@ast::native_item it,
ast::native_abi abi) -> ty::ty_param_count_and_ty {
alt (it.node) {
case (ast::native_item_fn(?ident, ?lname, ?fn_decl, ?params,
?def_id, _)) {
case (ast::native_item_fn(_, _, ?fn_decl, ?params, ?did, _)) {
auto get = bind getter(cx, _);
auto convert = bind ast_ty_to_ty(cx.tcx, get, _);
auto f = bind ty_of_arg(cx, _);
ret ty_of_native_fn_decl(cx, convert, f, fn_decl, abi, params,
def_id);
did);
}
case (ast::native_item_ty(_, ?def_id)) {
case (ast::native_item_ty(?tpt, ?def_id)) {
alt (cx.tcx.tcache.find(def_id)) {
case (some(?tpt)) { ret tpt; }
case (none) { }
......@@ -676,14 +675,14 @@ fn get_obj_method_types(&@ctxt cx, &ast::_obj object) -> vec[ty::method] {
}
fn collect(ty::item_table id_to_ty_item, &@ast::item i) {
alt (i.node) {
case (ast::item_ty(_, _, _, _, ?def_id, _)) {
id_to_ty_item.insert(def_id, ty::any_item_rust(i));
case (ast::item_ty(_, _)) {
id_to_ty_item.insert(i.id, ty::any_item_rust(i));
}
case (ast::item_tag(_, _, _, _, ?def_id, _)) {
id_to_ty_item.insert(def_id, ty::any_item_rust(i));
case (ast::item_tag(_, _)) {
id_to_ty_item.insert(i.id, ty::any_item_rust(i));
}
case (ast::item_obj(_, _, _, _, ?odid, _)) {
id_to_ty_item.insert(odid.ty, ty::any_item_rust(i));
case (ast::item_obj(_, _, _)) {
id_to_ty_item.insert(i.id, ty::any_item_rust(i));
}
case (_) {/* empty */ }
}
......@@ -702,23 +701,22 @@ fn collect_native(ty::item_table id_to_ty_item, &@ast::native_item i) {
fn convert(@ctxt cx, @mutable option::t[ast::native_abi] abi,
&@ast::item it) {
alt (it.node) {
case (ast::item_mod(_, _, _, _)) {
case (ast::item_mod(_)) {
// ignore item_mod, it has no type.
}
case (ast::item_native_mod(_, ?native_mod, _, _)) {
case (ast::item_native_mod(?native_mod)) {
// Propagate the native ABI down to convert_native() below,
// but otherwise do nothing, as native modules have no types.
*abi = some[ast::native_abi](native_mod.abi);
}
case (ast::item_tag(_, ?variants, ?ty_params, _, ?tag_id, ?ann)) {
case (ast::item_tag(?variants, ?ty_params)) {
auto tpt = ty_of_item(cx, it);
write::ty_only(cx.tcx, ann.id, tpt._1);
get_tag_variant_types(cx, tag_id, variants, ty_params);
write::ty_only(cx.tcx, it.ann.id, tpt._1);
get_tag_variant_types(cx, it.id, variants, ty_params);
}
case (ast::item_obj(?ident, ?object, ?ty_params, _, ?odid, ?ann))
{
case (ast::item_obj(?object, ?ty_params, ?ctor_id)) {
// This calls ty_of_obj().
auto t_obj = ty_of_item(cx, it);
......@@ -726,8 +724,8 @@ fn convert(@ctxt cx, @mutable option::t[ast::native_abi] abi,
// we write into the table for this item.
auto tpt =
ty_of_obj_ctor(cx, ident, object, odid.ctor, ty_params);
write::ty_only(cx.tcx, ann.id, tpt._1);
ty_of_obj_ctor(cx, it.ident, object, ctor_id, ty_params);
write::ty_only(cx.tcx, it.ann.id, tpt._1);
// Write the methods into the type table.
//
// FIXME: Inefficient; this ends up calling
......@@ -771,7 +769,7 @@ fn convert(@ctxt cx, @mutable option::t[ast::native_abi] abi,
// it into the node type table.
auto tpt = ty_of_item(cx, it);
write::ty_only(cx.tcx, ty::item_ann(it).id, tpt._1);
write::ty_only(cx.tcx, it.ann.id, tpt._1);
}
}
}
......@@ -788,8 +786,8 @@ fn convert_native(@ctxt cx, @mutable option::t[ast::native_abi] abi,
// FIXME: Native types have no annotation. Should they? --pcw
}
case (ast::native_item_fn(_, _, _, _, _, ?a)) {
write::ty_only(cx.tcx, a.id, tpt._1);
case (ast::native_item_fn(_, _, _, _, _, ?ann)) {
write::ty_only(cx.tcx, ann.id, tpt._1);
}
}
}
......@@ -2327,18 +2325,17 @@ fn check_method(&@crate_ctxt ccx, &@ast::method method) {
fn check_item(@crate_ctxt ccx, &@ast::item it) {
alt (it.node) {
case (ast::item_const(_, _, ?e, _, _, ?a)) {
check_const(ccx, it.span, e, a);
case (ast::item_const(_, ?e)) {
check_const(ccx, it.span, e, it.ann);
}
case (ast::item_fn(_, ?f, _, _, _, ?a)) {
check_fn(ccx, f.decl, f.proto, f.body, a);
case (ast::item_fn(?f, _)) {
check_fn(ccx, f.decl, f.proto, f.body, it.ann);
}
case (ast::item_obj(_, ?ob, _, _, ?obj_def_ids, _)) {
case (ast::item_obj(?ob, _, _)) {
// We're entering an object, so gather up the info we need.
let ast::def_id di = obj_def_ids.ty;
vec::push[obj_info](ccx.obj_infos,
rec(obj_fields=ob.fields, this_obj=di));
rec(obj_fields=ob.fields, this_obj=it.id));
// Typecheck the methods.
for (@ast::method method in ob.methods) {
......@@ -2357,8 +2354,8 @@ fn mk_fn_purity_table(&@ast::crate crate) -> @fn_purity_table {
auto res = @new_def_hash[ast::purity]();
fn do_one(@fn_purity_table t, &@ast::item i) {
alt (i.node) {
case (ast::item_fn(_, ?f, _, _, ?d_id, _)) {
t.insert(d_id, f.decl.purity);
case (ast::item_fn(?f, _)) {
t.insert(i.id, f.decl.purity);
}
case (_) { }
}
......
src/comp/middle/visit.rs
浏览文件 @ 15f71b36
......@@ -99,15 +99,15 @@ fn visit_local[E](&@local loc, &E e, &vt[E] v) {
fn visit_item[E](&@item i, &E e, &vt[E] v) {
alt (i.node) {
case (item_const(_, ?t, ?ex, _, _, _)) {
case (item_const(?t, ?ex)) {
vt(v).visit_ty(t, e, v);
vt(v).visit_expr(ex, e, v);
}
case (item_fn(?nm, ?f, ?tp, _, ?d, ?a)) {
vt(v).visit_fn(f, tp, i.span, nm, d, a, e, v);
case (item_fn(?f, ?tp)) {
vt(v).visit_fn(f, tp, i.span, i.ident, i.id, i.ann, e, v);
}
case (item_mod(_, ?m, _, _)) { vt(v).visit_mod(m, i.span, e, v); }
case (item_native_mod(_, ?nm, _, _)) {
case (item_mod(?m)) { vt(v).visit_mod(m, i.span, e, v); }
case (item_native_mod(?nm)) {
for (@view_item vi in nm.view_items) {
vt(v).visit_view_item(vi, e, v);
}
......@@ -115,15 +115,15 @@ fn visit_item[E](&@item i, &E e, &vt[E] v) {
vt(v).visit_native_item(ni, e, v);
}
}
case (item_ty(_, ?t, _, _, _, _)) { vt(v).visit_ty(t, e, v); }
case (item_tag(_, ?variants, _, _, _, _)) {
case (item_ty(?t, _)) { vt(v).visit_ty(t, e, v); }
case (item_tag(?variants, _)) {
for (variant vr in variants) {
for (variant_arg va in vr.node.args) {
vt(v).visit_ty(va.ty, e, v);
}
}
}
case (item_obj(_, ?ob, _, _, _, _)) {
case (item_obj(?ob, _, _)) {
for (obj_field f in ob.fields) { vt(v).visit_ty(f.ty, e, v); }
for (@method m in ob.methods) {
vt(v).visit_fn(m.node.meth, [], m.span, m.node.ident,
......
src/comp/middle/walk.rs
浏览文件 @ 15f71b36
......@@ -103,24 +103,24 @@ fn walk_item(&ast_visitor v, @ast::item i) {
if (!v.keep_going()) { ret; }
v.visit_item_pre(i);
alt (i.node) {
case (ast::item_const(_, ?t, ?e, _, _, _)) {
case (ast::item_const(?t, ?e)) {
walk_ty(v, t);
walk_expr(v, e);
}
case (ast::item_fn(?nm, ?f, _, _, ?d, ?a)) {
walk_fn(v, f, i.span, nm, d, a);
case (ast::item_fn(?f, _)) {
walk_fn(v, f, i.span, i.ident, i.id, i.ann);
}
case (ast::item_mod(_, ?m, _, _)) { walk_mod(v, m); }
case (ast::item_native_mod(_, ?nm, _, _)) { walk_native_mod(v, nm); }
case (ast::item_ty(_, ?t, _, _, _, _)) { walk_ty(v, t); }
case (ast::item_tag(_, ?variants, _, _, _, _)) {
case (ast::item_mod(?m)) { walk_mod(v, m); }
case (ast::item_native_mod(?nm)) { walk_native_mod(v, nm); }
case (ast::item_ty(?t, _)) { walk_ty(v, t); }
case (ast::item_tag(?variants, _)) {
for (ast::variant vr in variants) {
for (ast::variant_arg va in vr.node.args) {
walk_ty(v, va.ty);
}
}
}
case (ast::item_obj(_, ?ob, _, _, _, _)) {
case (ast::item_obj(?ob, _, _)) {
for (ast::obj_field f in ob.fields) { walk_ty(v, f.ty); }
for (@ast::method m in ob.methods) {
v.visit_method_pre(m);
......
src/comp/pretty/pprust.rs
浏览文件 @ 15f71b36
......@@ -259,12 +259,12 @@ fn print_item(&ps s, &@ast::item item) {
hardbreak(s.s);
maybe_print_comment(s, item.span.lo);
alt (item.node) {
case (ast::item_const(?id, ?ty, ?expr, ?attrs, _, _)) {
print_outer_attributes(s, attrs);
case (ast::item_const(?ty, ?expr)) {
print_outer_attributes(s, item.attrs);
head(s, "const");
print_type(s, *ty);
space(s.s);
word_space(s, id);
word_space(s, item.ident);
end(s); // end the head-ibox
word_space(s, "=");
......@@ -273,22 +273,22 @@ fn print_item(&ps s, &@ast::item item) {
end(s); // end the outer cbox
}
case (ast::item_fn(?name, ?_fn, ?typarams, ?attrs, _, _)) {
print_outer_attributes(s, attrs);
print_fn(s, _fn.decl, _fn.proto, name, typarams);
case (ast::item_fn(?_fn, ?typarams)) {
print_outer_attributes(s, item.attrs);
print_fn(s, _fn.decl, _fn.proto, item.ident, typarams);
word(s.s, " ");
print_block(s, _fn.body);
}
case (ast::item_mod(?id, ?_mod, ?attrs, _)) {
print_outer_attributes(s, attrs);
case (ast::item_mod(?_mod)) {
print_outer_attributes(s, item.attrs);
head(s, "mod");
word_nbsp(s, id);
word_nbsp(s, item.ident);
bopen(s);
for (@ast::item itm in _mod.items) { print_item(s, itm); }
bclose(s, item.span);
}
case (ast::item_native_mod(?id, ?nmod, ?attrs, _)) {
print_outer_attributes(s, attrs);
case (ast::item_native_mod(?nmod)) {
print_outer_attributes(s, item.attrs);
head(s, "native");
alt (nmod.abi) {
case (ast::native_abi_rust) { word_nbsp(s, "\"rust\""); }
......@@ -298,7 +298,7 @@ fn print_item(&ps s, &@ast::item item) {
}
}
word_nbsp(s, "mod");
word_nbsp(s, id);
word_nbsp(s, item.ident);
bopen(s);
for (@ast::native_item item in nmod.items) {
hardbreak(s.s);
......@@ -331,12 +331,12 @@ fn print_item(&ps s, &@ast::item item) {
}
bclose(s, item.span);
}
case (ast::item_ty(?id, ?ty, ?params, ?attrs, _, _)) {
print_outer_attributes(s, attrs);
case (ast::item_ty(?ty, ?params)) {
print_outer_attributes(s, item.attrs);
ibox(s, indent_unit);
ibox(s, 0u);
word_nbsp(s, "type");
word(s.s, id);
word(s.s, item.ident);
print_type_params(s, params);
end(s); // end the inner ibox
......@@ -348,10 +348,10 @@ fn print_item(&ps s, &@ast::item item) {
break_offset(s.s, 0u, 0);
}
case (ast::item_tag(?id, ?variants, ?params, ?attrs, _, _)) {
print_outer_attributes(s, attrs);
case (ast::item_tag(?variants, ?params)) {
print_outer_attributes(s, item.attrs);
head(s, "tag");
word(s.s, id);
word(s.s, item.ident);
print_type_params(s, params);
space(s.s);
bopen(s);
......@@ -372,10 +372,10 @@ fn print_variant_arg(&ps s, &ast::variant_arg arg) {
}
bclose(s, item.span);
}
case (ast::item_obj(?id, ?_obj, ?params, ?attrs, _, _)) {
print_outer_attributes(s, attrs);
case (ast::item_obj(?_obj, ?params, _)) {
print_outer_attributes(s, item.attrs);
head(s, "obj");
word(s.s, id);
word(s.s, item.ident);
print_type_params(s, params);
popen(s);
fn print_field(&ps s, &ast::obj_field field) {
......@@ -415,7 +415,7 @@ fn print_field(&ps s, &ast::obj_field field) {
alt (s.mode) {
case (mo_identified) {
space(s.s);
synth_comment(s, uint::to_str(ty::item_ann(item).id, 10u));
synth_comment(s, uint::to_str(item.ann.id, 10u));
}
case (_) {/* no-op */ }
}
......
src/comp/util/common.rs
浏览文件 @ 15f71b36
......@@ -148,26 +148,6 @@ fn log_fn_err(&ast::_fn f, str name, vec[ast::ty_param] params) {
fn log_stmt_err(&ast::stmt st) { log_err pretty::pprust::stmt_to_str(st); }
fn decl_lhs(@ast::decl d) -> ast::def_id {
alt (d.node) {
case (ast::decl_local(?l)) { ret l.id; }
case (ast::decl_item(?an_item)) {
alt (an_item.node) {
case (ast::item_const(_, _, _, _, ?d, _)) { ret d; }
case (ast::item_fn(_, _, _, _, ?d, _)) { ret d; }
case (ast::item_mod(_, _, _, ?d)) { ret d; }
case (ast::item_native_mod(_, _, _, ?d)) { ret d; }
case (ast::item_ty(_, _, _, _, ?d, _)) { ret d; }
case (ast::item_tag(_, _, _, _, ?d, _)) { ret d; }
case (ast::item_obj(_, _, _, _, ?d, _)) {
ret d.ctor; /* This doesn't really make sense */
}
}
}
}
}
fn has_nonlocal_exits(&ast::block b) -> bool {
auto has_exits = @mutable false;
fn visit_expr(@mutable bool flag, &@ast::expr e) {
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或