From cc929fc9f9de6cf2d44df46ffc4b4d6e58e3a508 Mon Sep 17 00:00:00 2001 From: Marijn Haverbeke Date: Thu, 5 Jan 2012 16:04:59 +0100 Subject: [PATCH] Clean up translating of def_ids in metadata reader Reduces the amount of closure allocation, and makes the code cleaner. --- src/comp/metadata/creader.rs | 3 +- src/comp/metadata/csearch.rs | 51 +++--------- src/comp/metadata/cstore.rs | 5 +- src/comp/metadata/decoder.rs | 135 ++++++++++++++++---------------- src/comp/metadata/tydecode.rs | 143 ++++++++++++++++------------------ 5 files changed, 149 insertions(+), 188 deletions(-) diff --git a/src/comp/metadata/creader.rs b/src/comp/metadata/creader.rs index 21ead604d31..167e6bbcbab 100644 --- a/src/comp/metadata/creader.rs +++ b/src/comp/metadata/creader.rs @@ -260,7 +260,8 @@ fn resolve_crate(e: env, ident: ast::ident, metas: [@ast::meta_item], // Now resolve the crates referenced by this crate let cnum_map = resolve_crate_deps(e, cdata); - let cmeta = {name: ident, data: cdata, cnum_map: cnum_map}; + let cmeta = @{name: ident, data: cdata, + cnum_map: cnum_map, cnum: cnum}; let cstore = e.sess.get_cstore(); cstore::set_crate_data(cstore, cnum, cmeta); diff --git a/src/comp/metadata/csearch.rs b/src/comp/metadata/csearch.rs index 364dd7aef21..3b0eac2d3ce 100644 --- a/src/comp/metadata/csearch.rs +++ b/src/comp/metadata/csearch.rs @@ -58,32 +58,27 @@ fn resolve_path(cstore: cstore::cstore, cnum: ast::crate_num, fn get_tag_variants(tcx: ty::ctxt, def: ast::def_id) -> [ty::variant_info] { let cstore = tcx.sess.get_cstore(); - let cnum = def.crate; - let cdata = cstore::get_crate_data(cstore, cnum).data; - let resolver = bind translate_def_id(cstore, cnum, _); - ret decoder::get_tag_variants(cdata, def, tcx, resolver) + let cdata = cstore::get_crate_data(cstore, def.crate); + ret decoder::get_tag_variants(cdata, def.node, tcx) } fn get_impls_for_mod(cstore: cstore::cstore, def: ast::def_id, name: option::t) -> @[@middle::resolve::_impl] { - let cdata = cstore::get_crate_data(cstore, def.crate).data; - let resolver = bind translate_def_id(cstore, def.crate, _); - decoder::get_impls_for_mod(cdata, def, name, resolver) + let cdata = cstore::get_crate_data(cstore, def.crate); + decoder::get_impls_for_mod(cdata, def.node, name) } fn get_iface_methods(tcx: ty::ctxt, def: ast::def_id) -> @[ty::method] { let cstore = tcx.sess.get_cstore(); - let cdata = cstore::get_crate_data(cstore, def.crate).data; - let resolver = bind translate_def_id(cstore, def.crate, _); - decoder::get_iface_methods(cdata, def, tcx, resolver) + let cdata = cstore::get_crate_data(cstore, def.crate); + decoder::get_iface_methods(cdata, def.node, tcx) } fn get_type(tcx: ty::ctxt, def: ast::def_id) -> ty::ty_param_bounds_and_ty { let cstore = tcx.sess.get_cstore(); - let cdata = cstore::get_crate_data(cstore, def.crate).data; - let resolver = bind translate_def_id(cstore, def.crate, _); - decoder::get_type(cdata, def, tcx, resolver) + let cdata = cstore::get_crate_data(cstore, def.crate); + decoder::get_type(cdata, def.node, tcx) } fn get_item_name(cstore: cstore::cstore, cnum: int, id: int) -> ast::ident { @@ -94,34 +89,8 @@ fn get_item_name(cstore: cstore::cstore, cnum: int, id: int) -> ast::ident { fn get_impl_iface(tcx: ty::ctxt, def: ast::def_id) -> option::t { let cstore = tcx.sess.get_cstore(); - let cdata = cstore::get_crate_data(cstore, def.crate).data; - let resolver = bind translate_def_id(cstore, def.crate, _); - decoder::get_impl_iface(cdata, def, tcx, resolver) -} - -// Translates a def_id from an external crate to a def_id for the current -// compilation environment. We use this when trying to load types from -// external crates - if those types further refer to types in other crates -// then we must translate the crate number from that encoded in the external -// crate to the correct local crate number. -fn translate_def_id(cstore: cstore::cstore, searched_crate: ast::crate_num, - def_id: ast::def_id) -> ast::def_id { - - let ext_cnum = def_id.crate; - let node_id = def_id.node; - - assert (searched_crate != ast::local_crate); - assert (ext_cnum != ast::local_crate); - - let cmeta = cstore::get_crate_data(cstore, searched_crate); - - let local_cnum = - alt cmeta.cnum_map.find(ext_cnum) { - option::some(n) { n } - option::none. { fail "didn't find a crate in the cnum_map"; } - }; - - ret {crate: local_cnum, node: node_id}; + let cdata = cstore::get_crate_data(cstore, def.crate); + decoder::get_impl_iface(cdata, def.node, tcx) } // Local Variables: diff --git a/src/comp/metadata/cstore.rs b/src/comp/metadata/cstore.rs index b85051ea09a..de56aa236f5 100644 --- a/src/comp/metadata/cstore.rs +++ b/src/comp/metadata/cstore.rs @@ -30,7 +30,10 @@ export get_dep_hashes; // own crate numbers. type cnum_map = map::hashmap; -type crate_metadata = {name: str, data: @[u8], cnum_map: cnum_map}; +type crate_metadata = @{name: str, + data: @[u8], + cnum_map: cnum_map, + cnum: ast::crate_num}; // This is a bit of an experiment at encapsulating the data in cstore. By // keeping all the data in a non-exported tag variant, it's impossible for diff --git a/src/comp/metadata/decoder.rs b/src/comp/metadata/decoder.rs index 95bd8e5811d..a253e116fe8 100644 --- a/src/comp/metadata/decoder.rs +++ b/src/comp/metadata/decoder.rs @@ -1,14 +1,13 @@ // Decoding metadata from a single crate's metadata -import core::{vec, option, str}; import std::{ebml, io}; import syntax::{ast, ast_util}; import front::attr; import middle::ty; import common::*; -import tydecode::{parse_def_id, parse_ty_data}; +import tydecode::{parse_ty_data, parse_def_id, parse_bounds_data}; import syntax::print::pprust; -import cstore; +import cmd=cstore::crate_metadata; export get_symbol; export get_tag_variants; @@ -24,7 +23,6 @@ export list_crate_metadata; export crate_dep; export get_crate_deps; export get_crate_hash; -export external_resolver; export get_impls_for_mod; export get_iface_methods; // A function that takes a def_id relative to the crate being searched and @@ -32,7 +30,6 @@ export get_iface_methods; // def_id for an item defined in another crate, somebody needs to figure out // what crate that's in and give us a def_id that makes sense for the current // build. -type external_resolver = fn@(ast::def_id) -> ast::def_id; fn lookup_hash(d: ebml::doc, eq_fn: fn@([u8]) -> bool, hash: uint) -> [ebml::doc] { @@ -91,66 +88,50 @@ fn variant_tag_id(d: ebml::doc) -> ast::def_id { ret parse_def_id(ebml::doc_data(tagdoc)); } -fn parse_external_def_id(this_cnum: ast::crate_num, - extres: external_resolver, s: str) -> - ast::def_id { - let buf = str::bytes(s); - let external_def_id = parse_def_id(buf); - - - // This item was defined in the crate we're searching if it's has the - // local crate number, otherwise we need to search a different crate - if external_def_id.crate == ast::local_crate { - ret {crate: this_cnum, node: external_def_id.node}; - } else { ret extres(external_def_id); } -} - -fn doc_type(doc: ebml::doc, this_cnum: ast::crate_num, tcx: ty::ctxt, - extres: external_resolver) -> ty::t { +fn doc_type(doc: ebml::doc, tcx: ty::ctxt, cdata: cmd) -> ty::t { let tp = ebml::get_doc(doc, tag_items_data_item_type); - let def_parser = bind parse_external_def_id(this_cnum, extres, _); - parse_ty_data(tp.data, this_cnum, tp.start, def_parser, tcx) + parse_ty_data(tp.data, cdata.cnum, tp.start, tcx, {|did| + translate_def_id(cdata, did) + }) } -fn item_type(item: ebml::doc, this_cnum: ast::crate_num, tcx: ty::ctxt, - extres: external_resolver) -> ty::t { - let t = doc_type(item, this_cnum, tcx, extres); +fn item_type(item: ebml::doc, tcx: ty::ctxt, cdata: cmd) -> ty::t { + let t = doc_type(item, tcx, cdata); if family_names_type(item_family(item)) { ty::mk_named(tcx, t, @item_name(item)) } else { t } } -fn item_impl_iface(item: ebml::doc, this_cnum: ast::crate_num, tcx: ty::ctxt, - extres: external_resolver) -> option::t { +fn item_impl_iface(item: ebml::doc, tcx: ty::ctxt, cdata: cmd) + -> option::t { let result = none; ebml::tagged_docs(item, tag_impl_iface) {|ity| - let def_parser = bind parse_external_def_id(this_cnum, extres, _); - let t = parse_ty_data(ity.data, this_cnum, ity.start, def_parser, - tcx); + let t = parse_ty_data(ity.data, cdata.cnum, ity.start, tcx, {|did| + translate_def_id(cdata, did) + }); result = some(t); } result } -fn item_impl_iface_did(item: ebml::doc, this_cnum: ast::crate_num, - extres: external_resolver) +fn item_impl_iface_did(item: ebml::doc, cdata: cmd) -> option::t { let result = none; ebml::tagged_docs(item, tag_impl_iface_did) {|doc| - let s = str::unsafe_from_bytes(ebml::doc_data(doc)); - result = some(parse_external_def_id(this_cnum, extres, s)); + let did = translate_def_id(cdata, parse_def_id(ebml::doc_data(doc))); + result = some(did); } result } -fn item_ty_param_bounds(item: ebml::doc, this_cnum: ast::crate_num, - tcx: ty::ctxt, extres: external_resolver) +fn item_ty_param_bounds(item: ebml::doc, tcx: ty::ctxt, cdata: cmd) -> @[ty::param_bounds] { let bounds = []; - let def_parser = bind parse_external_def_id(this_cnum, extres, _); ebml::tagged_docs(item, tag_items_data_item_ty_param_bounds) {|p| - bounds += [tydecode::parse_bounds_data(p.data, p.start, - this_cnum, def_parser, tcx)]; + let bd = parse_bounds_data(p.data, p.start, cdata.cnum, tcx, {|did| + translate_def_id(cdata, did) + }); + bounds += [bd]; } @bounds } @@ -162,13 +143,12 @@ fn item_ty_param_count(item: ebml::doc) -> uint { n } -fn tag_variant_ids(item: ebml::doc, this_cnum: ast::crate_num) -> - [ast::def_id] { +fn tag_variant_ids(item: ebml::doc, cdata: cmd) -> [ast::def_id] { let ids: [ast::def_id] = []; let v = tag_items_data_item_variant; ebml::tagged_docs(item, v) {|p| let ext = parse_def_id(ebml::doc_data(p)); - ids += [{crate: this_cnum, node: ext.node}]; + ids += [{crate: cdata.cnum, node: ext.node}]; }; ret ids; } @@ -230,12 +210,12 @@ fn lookup_def(cnum: ast::crate_num, data: @[u8], did_: ast::def_id) -> ret def; } -fn get_type(data: @[u8], def: ast::def_id, tcx: ty::ctxt, - extres: external_resolver) -> ty::ty_param_bounds_and_ty { - let item = lookup_item(def.node, data); - let t = item_type(item, def.crate, tcx, extres); +fn get_type(cdata: cmd, id: ast::node_id, tcx: ty::ctxt) + -> ty::ty_param_bounds_and_ty { + let item = lookup_item(id, cdata.data); + let t = item_type(item, tcx, cdata); let tp_bounds = if family_has_type_params(item_family(item)) { - item_ty_param_bounds(item, def.crate, tcx, extres) + item_ty_param_bounds(item, tcx, cdata) } else { @[] }; ret {bounds: tp_bounds, ty: t}; } @@ -244,27 +224,25 @@ fn get_type_param_count(data: @[u8], id: ast::node_id) -> uint { item_ty_param_count(lookup_item(id, data)) } -fn get_impl_iface(data: @[u8], def: ast::def_id, tcx: ty::ctxt, - extres: external_resolver) -> option::t { - item_impl_iface(lookup_item(def.node, data), def.crate, tcx, extres) +fn get_impl_iface(cdata: cmd, id: ast::node_id, tcx: ty::ctxt) + -> option::t { + item_impl_iface(lookup_item(id, cdata.data), tcx, cdata) } fn get_symbol(data: @[u8], id: ast::node_id) -> str { ret item_symbol(lookup_item(id, data)); } -fn get_tag_variants(_data: @[u8], def: ast::def_id, tcx: ty::ctxt, - extres: external_resolver) -> [ty::variant_info] { - let external_crate_id = def.crate; - let data = - cstore::get_crate_data(tcx.sess.get_cstore(), external_crate_id).data; +fn get_tag_variants(cdata: cmd, id: ast::node_id, tcx: ty::ctxt) + -> [ty::variant_info] { + let data = cdata.data; let items = ebml::get_doc(ebml::new_doc(data), tag_items); - let item = find_item(def.node, items); + let item = find_item(id, items); let infos: [ty::variant_info] = []; - let variant_ids = tag_variant_ids(item, external_crate_id); + let variant_ids = tag_variant_ids(item, cdata); for did: ast::def_id in variant_ids { let item = find_item(did.node, items); - let ctor_ty = item_type(item, external_crate_id, tcx, extres); + let ctor_ty = item_type(item, tcx, cdata); let arg_tys: [ty::t] = []; alt ty::struct(tcx, ctor_ty) { ty::ty_fn(f) { @@ -290,17 +268,17 @@ fn item_impl_methods(data: @[u8], item: ebml::doc, base_tps: uint) rslt } -fn get_impls_for_mod(data: @[u8], m_def: ast::def_id, - name: option::t, extres: external_resolver) +fn get_impls_for_mod(cdata: cmd, m_id: ast::node_id, + name: option::t) -> @[@middle::resolve::_impl] { - let mod_item = lookup_item(m_def.node, data), result = []; + let data = cdata.data; + let mod_item = lookup_item(m_id, data), result = []; ebml::tagged_docs(mod_item, tag_mod_impl) {|doc| - let did = parse_external_def_id( - m_def.crate, extres, str::unsafe_from_bytes(ebml::doc_data(doc))); + let did = translate_def_id(cdata, parse_def_id(ebml::doc_data(doc))); let item = lookup_item(did.node, data), nm = item_name(item); if alt name { some(n) { n == nm } none. { true } } { let base_tps = item_ty_param_count(doc); - let i_did = item_impl_iface_did(item, m_def.crate, extres); + let i_did = item_impl_iface_did(item, cdata); result += [@{did: did, iface_did: i_did, ident: nm, methods: item_impl_methods(data, doc, base_tps)}]; } @@ -308,13 +286,14 @@ fn get_impls_for_mod(data: @[u8], m_def: ast::def_id, @result } -fn get_iface_methods(data: @[u8], def: ast::def_id, tcx: ty::ctxt, - extres: external_resolver) -> @[ty::method] { - let item = lookup_item(def.node, data), result = []; +fn get_iface_methods(cdata: cmd, id: ast::node_id, tcx: ty::ctxt) + -> @[ty::method] { + let data = cdata.data; + let item = lookup_item(id, data), result = []; ebml::tagged_docs(item, tag_item_method) {|mth| - let bounds = item_ty_param_bounds(mth, def.crate, tcx, extres); + let bounds = item_ty_param_bounds(mth, tcx, cdata); let name = item_name(mth); - let ty = doc_type(mth, def.crate, tcx, extres); + let ty = doc_type(mth, tcx, cdata); let fty = alt ty::struct(tcx, ty) { ty::ty_fn(f) { f } }; result += [{ident: name, tps: bounds, fty: fty}]; } @@ -489,6 +468,22 @@ fn list_crate_metadata(bytes: @[u8], out: io::writer) { list_crate_items(bytes, md, out); } +// Translates a def_id from an external crate to a def_id for the current +// compilation environment. We use this when trying to load types from +// external crates - if those types further refer to types in other crates +// then we must translate the crate number from that encoded in the external +// crate to the correct local crate number. +fn translate_def_id(cdata: cmd, did: ast::def_id) -> ast::def_id { + if did.crate == ast::local_crate { + ret {crate: cdata.cnum, node: did.node}; + } + + alt cdata.cnum_map.find(did.crate) { + option::some(n) { ret {crate: n, node: did.node}; } + option::none. { fail "didn't find a crate in the cnum_map"; } + } +} + // Local Variables: // mode: rust // fill-column: 78; diff --git a/src/comp/metadata/tydecode.rs b/src/comp/metadata/tydecode.rs index d67d0460753..4ba9ae3fade 100644 --- a/src/comp/metadata/tydecode.rs +++ b/src/comp/metadata/tydecode.rs @@ -8,8 +8,7 @@ import syntax::ast_util; import syntax::ast_util::respan; import middle::ty; -export parse_def_id; -export parse_ty_data; +export parse_ty_data, parse_def_id; export parse_bounds_data; // Compact string representation for ty::t values. API ty_str & @@ -17,7 +16,7 @@ export parse_bounds_data; // data buffer. Whatever format you choose should not contain pipe characters. // Callback to translate defs to strs or back: -type str_def = fn@(str) -> ast::def_id; +type conv_did = block(ast::def_id) -> ast::def_id; type pstate = {data: @[u8], crate: int, mutable pos: uint, tcx: ty::ctxt}; @@ -31,12 +30,12 @@ fn next(st: @pstate) -> u8 { ret ch; } -fn parse_ident(st: @pstate, sd: str_def, last: char) -> ast::ident { +fn parse_ident(st: @pstate, last: char) -> ast::ident { fn is_last(b: char, c: char) -> bool { ret c == b; } - ret parse_ident_(st, sd, bind is_last(last, _)); + ret parse_ident_(st, bind is_last(last, _)); } -fn parse_ident_(st: @pstate, _sd: str_def, is_last: fn@(char) -> bool) -> +fn parse_ident_(st: @pstate, is_last: fn@(char) -> bool) -> ast::ident { let rslt = ""; while !is_last(peek(st) as char) { @@ -46,28 +45,26 @@ fn parse_ident_(st: @pstate, _sd: str_def, is_last: fn@(char) -> bool) -> } -fn parse_ty_data(data: @[u8], crate_num: int, pos: uint, sd: str_def, - tcx: ty::ctxt) -> ty::t { +fn parse_ty_data(data: @[u8], crate_num: int, pos: uint, tcx: ty::ctxt, + conv: conv_did) -> ty::t { let st = @{data: data, crate: crate_num, mutable pos: pos, tcx: tcx}; - parse_ty(st, sd) + parse_ty(st, conv) } -fn parse_ret_ty(st: @pstate, sd: str_def) -> (ast::ret_style, ty::t) { +fn parse_ret_ty(st: @pstate, conv: conv_did) -> (ast::ret_style, ty::t) { alt peek(st) as char { '!' { next(st); (ast::noreturn, ty::mk_bot(st.tcx)) } - _ { (ast::return_val, parse_ty(st, sd)) } + _ { (ast::return_val, parse_ty(st, conv)) } } } -fn parse_constrs(st: @pstate, sd: str_def) -> [@ty::constr] { +fn parse_constrs(st: @pstate, conv: conv_did) -> [@ty::constr] { let rslt: [@ty::constr] = []; alt peek(st) as char { ':' { do { next(st); - let one: @ty::constr = - parse_constr::(st, sd, parse_constr_arg); - rslt += [one]; + rslt += [parse_constr(st, conv, parse_constr_arg)]; } while peek(st) as char == ';' } _ { } @@ -76,15 +73,13 @@ fn parse_constrs(st: @pstate, sd: str_def) -> [@ty::constr] { } // FIXME less copy-and-paste -fn parse_ty_constrs(st: @pstate, sd: str_def) -> [@ty::type_constr] { +fn parse_ty_constrs(st: @pstate, conv: conv_did) -> [@ty::type_constr] { let rslt: [@ty::type_constr] = []; alt peek(st) as char { ':' { do { next(st); - let one: @ty::type_constr = - parse_constr::<@path>(st, sd, parse_ty_constr_arg); - rslt += [one]; + rslt += [parse_constr(st, conv, parse_ty_constr_arg)]; } while peek(st) as char == ';' } _ { } @@ -92,10 +87,10 @@ fn parse_ty_constrs(st: @pstate, sd: str_def) -> [@ty::type_constr] { ret rslt; } -fn parse_path(st: @pstate, sd: str_def) -> @ast::path { +fn parse_path(st: @pstate) -> @ast::path { let idents: [ast::ident] = []; fn is_last(c: char) -> bool { ret c == '(' || c == ':'; } - idents += [parse_ident_(st, sd, is_last)]; + idents += [parse_ident_(st, is_last)]; while true { alt peek(st) as char { ':' { next(st); next(st); } @@ -103,16 +98,14 @@ fn parse_path(st: @pstate, sd: str_def) -> @ast::path { if c == '(' { ret @respan(ast_util::dummy_sp(), {global: false, idents: idents, types: []}); - } else { idents += [parse_ident_(st, sd, is_last)]; } + } else { idents += [parse_ident_(st, is_last)]; } } } } fail "parse_path: ill-formed path"; } -type arg_parser = fn(@pstate, str_def) -> ast::constr_arg_general_; - -fn parse_constr_arg(st: @pstate, _sd: str_def) -> ast::fn_constr_arg { +fn parse_constr_arg(st: @pstate) -> ast::fn_constr_arg { alt peek(st) as char { '*' { st.pos += 1u; ret ast::carg_base; } c { @@ -129,7 +122,7 @@ fn parse_constr_arg(st: @pstate, _sd: str_def) -> ast::fn_constr_arg { } /* else { - auto lit = parse_lit(st, sd, ','); + auto lit = parse_lit(st, conv, ','); args += [respan(st.span, ast::carg_lit(lit))]; } */ @@ -137,25 +130,25 @@ fn parse_constr_arg(st: @pstate, _sd: str_def) -> ast::fn_constr_arg { } } -fn parse_ty_constr_arg(st: @pstate, sd: str_def) -> - ast::constr_arg_general_<@path> { +fn parse_ty_constr_arg(st: @pstate) -> ast::constr_arg_general_<@path> { alt peek(st) as char { '*' { st.pos += 1u; ret ast::carg_base; } - c { ret ast::carg_ident(parse_path(st, sd)); } + c { ret ast::carg_ident(parse_path(st)); } } } -fn parse_constr(st: @pstate, sd: str_def, pser: arg_parser) -> - @ty::constr_general { +fn parse_constr(st: @pstate, conv: conv_did, + pser: block(@pstate) -> ast::constr_arg_general_) + -> @ty::constr_general { let sp = ast_util::dummy_sp(); // FIXME: use a real span let args: [@sp_constr_arg] = []; - let pth = parse_path(st, sd); + let pth = parse_path(st); let ignore: char = next(st) as char; assert (ignore == '('); - let def = parse_def(st, sd); + let def = parse_def(st, conv); let an_arg: constr_arg_general_; do { - an_arg = pser(st, sd); + an_arg = pser(st); // FIXME use a real span args += [@respan(sp, an_arg)]; ignore = next(st) as char; @@ -164,11 +157,11 @@ fn parse_constr(st: @pstate, sd: str_def, pser: arg_parser) -> ret @respan(sp, {path: pth, args: args, id: def}); } -fn parse_ty_rust_fn(st: @pstate, sd: str_def, p: ast::proto) -> ty::t { - ret ty::mk_fn(st.tcx, {proto: p with parse_ty_fn(st, sd)}); +fn parse_ty_rust_fn(st: @pstate, conv: conv_did, p: ast::proto) -> ty::t { + ret ty::mk_fn(st.tcx, {proto: p with parse_ty_fn(st, conv)}); } -fn parse_ty(st: @pstate, sd: str_def) -> ty::t { +fn parse_ty(st: @pstate, conv: conv_did) -> ty::t { alt next(st) as char { 'n' { ret ty::mk_nil(st.tcx); } 'z' { ret ty::mk_bot(st.tcx); } @@ -194,28 +187,28 @@ fn parse_ty(st: @pstate, sd: str_def) -> ty::t { 'S' { ret ty::mk_str(st.tcx); } 't' { assert (next(st) as char == '['); - let def = parse_def(st, sd); + let def = parse_def(st, conv); let params: [ty::t] = []; - while peek(st) as char != ']' { params += [parse_ty(st, sd)]; } + while peek(st) as char != ']' { params += [parse_ty(st, conv)]; } st.pos = st.pos + 1u; ret ty::mk_tag(st.tcx, def, params); } 'x' { assert (next(st) as char == '['); - let def = parse_def(st, sd); + let def = parse_def(st, conv); let params: [ty::t] = []; - while peek(st) as char != ']' { params += [parse_ty(st, sd)]; } + while peek(st) as char != ']' { params += [parse_ty(st, conv)]; } st.pos = st.pos + 1u; ret ty::mk_iface(st.tcx, def, params); } 'p' { - let did = parse_def(st, sd); + let did = parse_def(st, conv); ret ty::mk_param(st.tcx, parse_int(st) as uint, did); } - '@' { ret ty::mk_box(st.tcx, parse_mt(st, sd)); } - '~' { ret ty::mk_uniq(st.tcx, parse_mt(st, sd)); } - '*' { ret ty::mk_ptr(st.tcx, parse_mt(st, sd)); } - 'I' { ret ty::mk_vec(st.tcx, parse_mt(st, sd)); } + '@' { ret ty::mk_box(st.tcx, parse_mt(st, conv)); } + '~' { ret ty::mk_uniq(st.tcx, parse_mt(st, conv)); } + '*' { ret ty::mk_ptr(st.tcx, parse_mt(st, conv)); } + 'I' { ret ty::mk_vec(st.tcx, parse_mt(st, conv)); } 'R' { assert (next(st) as char == '['); let fields: [ty::field] = []; @@ -225,7 +218,7 @@ fn parse_ty(st: @pstate, sd: str_def) -> ty::t { name += str::unsafe_from_byte(next(st)); } st.pos = st.pos + 1u; - fields += [{ident: name, mt: parse_mt(st, sd)}]; + fields += [{ident: name, mt: parse_mt(st, conv)}]; } st.pos = st.pos + 1u; ret ty::mk_rec(st.tcx, fields); @@ -233,24 +226,24 @@ fn parse_ty(st: @pstate, sd: str_def) -> ty::t { 'T' { assert (next(st) as char == '['); let params = []; - while peek(st) as char != ']' { params += [parse_ty(st, sd)]; } + while peek(st) as char != ']' { params += [parse_ty(st, conv)]; } st.pos = st.pos + 1u; ret ty::mk_tup(st.tcx, params); } 's' { - ret parse_ty_rust_fn(st, sd, ast::proto_send); + ret parse_ty_rust_fn(st, conv, ast::proto_send); } 'F' { - ret parse_ty_rust_fn(st, sd, ast::proto_shared(ast::sugar_normal)); + ret parse_ty_rust_fn(st, conv, ast::proto_shared(ast::sugar_normal)); } 'f' { - ret parse_ty_rust_fn(st, sd, ast::proto_bare); + ret parse_ty_rust_fn(st, conv, ast::proto_bare); } 'B' { - ret parse_ty_rust_fn(st, sd, ast::proto_block); + ret parse_ty_rust_fn(st, conv, ast::proto_block); } 'N' { - let func = parse_ty_fn(st, sd); + let func = parse_ty_fn(st, conv); ret ty::mk_native_fn(st.tcx, func.inputs, func.output); } 'O' { @@ -266,22 +259,22 @@ fn parse_ty(st: @pstate, sd: str_def) -> ty::t { name += str::unsafe_from_byte(next(st)); } methods += [{ident: name, tps: @[], - fty: {proto: proto with parse_ty_fn(st, sd)}}]; + fty: {proto: proto with parse_ty_fn(st, conv)}}]; } st.pos += 1u; ret ty::mk_obj(st.tcx, methods); } 'r' { assert (next(st) as char == '['); - let def = parse_def(st, sd); - let inner = parse_ty(st, sd); + let def = parse_def(st, conv); + let inner = parse_ty(st, conv); let params: [ty::t] = []; - while peek(st) as char != ']' { params += [parse_ty(st, sd)]; } + while peek(st) as char != ']' { params += [parse_ty(st, conv)]; } st.pos = st.pos + 1u; ret ty::mk_res(st.tcx, def, inner, params); } 'X' { ret ty::mk_var(st.tcx, parse_int(st)); } - 'E' { let def = parse_def(st, sd); ret ty::mk_native(st.tcx, def); } + 'E' { let def = parse_def(st, conv); ret ty::mk_native(st.tcx, def); } 'Y' { ret ty::mk_type(st.tcx); } 'y' { ret ty::mk_send_type(st.tcx); } 'C' { ret ty::mk_opaque_closure(st.tcx); } @@ -294,7 +287,7 @@ fn parse_ty(st: @pstate, sd: str_def) -> ty::t { some(tt) { ret tt; } none. { let ps = @{pos: pos with *st}; - let tt = parse_ty(ps, sd); + let tt = parse_ty(ps, conv); st.tcx.rcache.insert({cnum: st.crate, pos: pos, len: len}, tt); ret tt; } @@ -302,8 +295,8 @@ fn parse_ty(st: @pstate, sd: str_def) -> ty::t { } 'A' { assert (next(st) as char == '['); - let tt = parse_ty(st, sd); - let tcs = parse_ty_constrs(st, sd); + let tt = parse_ty(st, conv); + let tcs = parse_ty_constrs(st, conv); assert (next(st) as char == ']'); ret ty::mk_constr(st.tcx, tt, tcs); } @@ -311,21 +304,21 @@ fn parse_ty(st: @pstate, sd: str_def) -> ty::t { } } -fn parse_mt(st: @pstate, sd: str_def) -> ty::mt { +fn parse_mt(st: @pstate, conv: conv_did) -> ty::mt { let mut; alt peek(st) as char { 'm' { next(st); mut = ast::mut; } '?' { next(st); mut = ast::maybe_mut; } _ { mut = ast::imm; } } - ret {ty: parse_ty(st, sd), mut: mut}; + ret {ty: parse_ty(st, conv), mut: mut}; } -fn parse_def(st: @pstate, sd: str_def) -> ast::def_id { - let def = ""; - while peek(st) as char != '|' { def += str::unsafe_from_byte(next(st)); } +fn parse_def(st: @pstate, conv: conv_did) -> ast::def_id { + let def = []; + while peek(st) as char != '|' { def += [next(st)]; } st.pos = st.pos + 1u; - ret sd(def); + ret conv(parse_def_id(def)); } fn parse_int(st: @pstate) -> int { @@ -354,7 +347,7 @@ fn parse_hex(st: @pstate) -> uint { ret n; } -fn parse_ty_fn(st: @pstate, sd: str_def) -> ty::fn_ty { +fn parse_ty_fn(st: @pstate, conv: conv_did) -> ty::fn_ty { assert (next(st) as char == '['); let inputs: [ty::arg] = []; while peek(st) as char != ']' { @@ -366,11 +359,11 @@ fn parse_ty_fn(st: @pstate, sd: str_def) -> ty::fn_ty { '#' { ast::by_val } }; st.pos += 1u; - inputs += [{mode: mode, ty: parse_ty(st, sd)}]; + inputs += [{mode: mode, ty: parse_ty(st, conv)}]; } st.pos += 1u; // eat the ']' - let cs = parse_constrs(st, sd); - let (ret_style, ret_ty) = parse_ret_ty(st, sd); + let cs = parse_constrs(st, conv); + let (ret_style, ret_ty) = parse_ret_ty(st, conv); ret {proto: ast::proto_bare, inputs: inputs, output: ret_ty, ret_style: ret_style, constraints: cs}; } @@ -399,19 +392,19 @@ fn parse_def_id(buf: [u8]) -> ast::def_id { } fn parse_bounds_data(data: @[u8], start: uint, - crate_num: int, sd: str_def, tcx: ty::ctxt) + crate_num: int, tcx: ty::ctxt, conv: conv_did) -> @[ty::param_bound] { let st = @{data: data, crate: crate_num, mutable pos: start, tcx: tcx}; - parse_bounds(st, sd) + parse_bounds(st, conv) } -fn parse_bounds(st: @pstate, sd: str_def) -> @[ty::param_bound] { +fn parse_bounds(st: @pstate, conv: conv_did) -> @[ty::param_bound] { let bounds = []; while true { bounds += [alt next(st) as char { 'S' { ty::bound_send } 'C' { ty::bound_copy } - 'I' { ty::bound_iface(parse_ty(st, sd)) } + 'I' { ty::bound_iface(parse_ty(st, conv)) } '.' { break; } }]; }