OpenE2K/rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

turn ast::ident into a struct

Browse Source 
This will help with the auto_serialize2 migration. We have to change
ident from a type alias to uint into a unique type. We need to use
a struct instead of a "enum ident = token::str_num" because structs
support constants, but newtypes do not.
This commit is contained in:
Erick Tryzelaar 2012-09-19 18:50:24 -07:00 committed by Graydon Hoare
parent c0b9986c8f
commit b96af73159
20 changed files with 152 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/fuzzer/fuzzer.rs
View File

@ -243,7 +243,7 @@ fn check_variants_T<T: Copy>(
filename: &Path,
thing_label: ~str,
things: ~[T],
stringifier: fn@(@T, syntax::parse::token::ident_interner) -> ~str,
stringifier: fn@(@T, @syntax::parse::token::ident_interner) -> ~str,
replacer: fn@(ast::crate, uint, T, test_mode) -> ast::crate,
cx: context
) {

15
src/libsyntax/ast.rs
View File

@ -38,6 +38,10 @@ macro_rules! interner_key (
(-3 as uint, 0u)))
)
// FIXME(#3534): Replace with the struct-based newtype when it's been
// implemented.
struct ident { repr: uint }
fn serialize_ident<S: Serializer>(s: S, i: ident) {
let intr = match unsafe{
task::local_data::local_data_get(interner_key!())
@ -59,7 +63,16 @@ fn deserialize_ident<D: Deserializer>(d: D) -> ident {
(*intr).intern(@d.read_str())
}
type ident = token::str_num;
impl ident: cmp::Eq {
pure fn eq(other: &ident) -> bool { self.repr == other.repr }
pure fn ne(other: &ident) -> bool { !self.eq(other) }
}
impl ident: to_bytes::IterBytes {
pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
self.repr.iter_bytes(lsb0, f)
}
}
// Functions may or may not have names.
#[auto_serialize]

8
src/libsyntax/ast_map.rs
View File

@ -34,7 +34,7 @@ impl path_elt : cmp::Eq {
type path = ~[path_elt];
/* FIXMEs that say "bad" are as per #2543 */
fn path_to_str_with_sep(p: path, sep: ~str, itr: ident_interner) -> ~str {
fn path_to_str_with_sep(p: path, sep: ~str, itr: @ident_interner) -> ~str {
let strs = do vec::map(p) |e| {
match *e {
path_mod(s) => *itr.get(s),
@ -44,7 +44,7 @@ fn path_to_str_with_sep(p: path, sep: ~str, itr: ident_interner) -> ~str {
str::connect(strs, sep)
}
fn path_ident_to_str(p: path, i: ident, itr: ident_interner) -> ~str {
fn path_ident_to_str(p: path, i: ident, itr: @ident_interner) -> ~str {
if vec::is_empty(p) {
//FIXME /* FIXME (#2543) */ copy *i
*itr.get(i)
@ -53,7 +53,7 @@ fn path_ident_to_str(p: path, i: ident, itr: ident_interner) -> ~str {
}
}
fn path_to_str(p: path, itr: ident_interner) -> ~str {
fn path_to_str(p: path, itr: @ident_interner) -> ~str {
path_to_str_with_sep(p, ~"::", itr)
}
@ -326,7 +326,7 @@ fn map_stmt(stmt: @stmt, cx: ctx, v: vt) {
visit::visit_stmt(stmt, cx, v);
}
fn node_id_to_str(map: map, id: node_id, itr: ident_interner) -> ~str {
fn node_id_to_str(map: map, id: node_id, itr: @ident_interner) -> ~str {
match map.find(id) {
None => {
fmt!("unknown node (id=%d)", id)

2
src/libsyntax/ast_util.rs
View File

@ -23,7 +23,7 @@ pure fn dummy_sp() -> span { return mk_sp(0u, 0u); }
pure fn path_name_i(idents: ~[ident], intr: token::ident_interner) -> ~str {
pure fn path_name_i(idents: ~[ident], intr: @token::ident_interner) -> ~str {
// FIXME: Bad copies (#2543 -- same for everything else that says "bad")
str::connect(idents.map(|i| *intr.get(*i)), ~"::")
}

4
src/libsyntax/ext/tt/transcribe.rs
View File

@ -25,7 +25,7 @@ type tt_frame = @{
type tt_reader = @{
sp_diag: span_handler,
interner: ident_interner,
interner: @ident_interner,
mut cur: tt_frame,
/* for MBE-style macro transcription */
interpolations: std::map::HashMap<ident, @named_match>,
@ -39,7 +39,7 @@ type tt_reader = @{
/** This can do Macro-By-Example transcription. On the other hand, if
* `src` contains no `tt_seq`s and `tt_nonterminal`s, `interp` can (and
* should) be none. */
fn new_tt_reader(sp_diag: span_handler, itr: ident_interner,
fn new_tt_reader(sp_diag: span_handler, itr: @ident_interner,
interp: Option<std::map::HashMap<ident,@named_match>>,
src: ~[ast::token_tree])
-> tt_reader {

2
src/libsyntax/parse.rs
View File

@ -25,7 +25,7 @@ type parse_sess = @{
cm: codemap::codemap,
mut next_id: node_id,
span_diagnostic: span_handler,
interner: ident_interner,
interner: @ident_interner,
// these two must be kept up to date
mut chpos: uint,
mut byte_pos: uint

12
src/libsyntax/parse/lexer.rs
View File

@ -13,7 +13,7 @@ trait reader {
fn next_token() -> {tok: token::token, sp: span};
fn fatal(~str) -> !;
fn span_diag() -> span_handler;
pure fn interner() -> token::ident_interner;
pure fn interner() -> @token::ident_interner;
fn peek() -> {tok: token::token, sp: span};
fn dup() -> reader;
}
@ -26,7 +26,7 @@ type string_reader = @{
mut curr: char,
mut chpos: uint,
filemap: codemap::filemap,
interner: token::ident_interner,
interner: @token::ident_interner,
/* cached: */
mut peek_tok: token::token,
mut peek_span: span
@ -34,7 +34,7 @@ type string_reader = @{
fn new_string_reader(span_diagnostic: span_handler,
filemap: codemap::filemap,
itr: token::ident_interner) -> string_reader {
itr: @token::ident_interner) -> string_reader {
let r = new_low_level_string_reader(span_diagnostic, filemap, itr);
string_advance_token(r); /* fill in peek_* */
return r;
@ -43,7 +43,7 @@ fn new_string_reader(span_diagnostic: span_handler,
/* For comments.rs, which hackily pokes into 'pos' and 'curr' */
fn new_low_level_string_reader(span_diagnostic: span_handler,
filemap: codemap::filemap,
itr: token::ident_interner)
itr: @token::ident_interner)
-> string_reader {
let r = @{span_diagnostic: span_diagnostic, src: filemap.src,
mut col: 0u, mut pos: 0u, mut curr: -1 as char,
@ -78,7 +78,7 @@ impl string_reader: reader {
self.span_diagnostic.span_fatal(copy self.peek_span, m)
}
fn span_diag() -> span_handler { self.span_diagnostic }
pure fn interner() -> token::ident_interner { self.interner }
pure fn interner() -> @token::ident_interner { self.interner }
fn peek() -> {tok: token::token, sp: span} {
{tok: self.peek_tok, sp: self.peek_span}
}
@ -100,7 +100,7 @@ impl tt_reader: reader {
self.sp_diag.span_fatal(copy self.cur_span, m);
}
fn span_diag() -> span_handler { self.sp_diag }
pure fn interner() -> token::ident_interner { self.interner }
pure fn interner() -> @token::ident_interner { self.interner }
fn peek() -> {tok: token::token, sp: span} {
{ tok: self.cur_tok, sp: self.cur_span }
}

2
src/libsyntax/parse/parser.rs
View File

@ -237,7 +237,7 @@ struct parser {
mut restriction: restriction,
mut quote_depth: uint, // not (yet) related to the quasiquoter
reader: reader,
interner: interner<@~str>,
interner: @token::ident_interner,
keywords: HashMap<~str, ()>,
strict_keywords: HashMap<~str, ()>,
reserved_keywords: HashMap<~str, ()>,

114
src/libsyntax/parse/token.rs
View File

@ -12,9 +12,6 @@ use std::serialization::{Serializer,
serialize_bool,
deserialize_bool};
#[auto_serialize]
type str_num = uint;
#[auto_serialize]
enum binop {
PLUS,
@ -72,17 +69,17 @@ enum token {
LIT_INT(i64, ast::int_ty),
LIT_UINT(u64, ast::uint_ty),
LIT_INT_UNSUFFIXED(i64),
LIT_FLOAT(str_num, ast::float_ty),
LIT_STR(str_num),
LIT_FLOAT(ast::ident, ast::float_ty),
LIT_STR(ast::ident),
/* Name components */
IDENT(str_num, bool),
IDENT(ast::ident, bool),
UNDERSCORE,
/* For interpolation */
INTERPOLATED(nonterminal),
DOC_COMMENT(str_num),
DOC_COMMENT(ast::ident),
EOF,
}
@ -95,7 +92,7 @@ enum nonterminal {
nt_pat( @ast::pat),
nt_expr(@ast::expr),
nt_ty( @ast::ty),
nt_ident(str_num, bool),
nt_ident(ast::ident, bool),
nt_path(@ast::path),
nt_tt( @ast::token_tree), //needs @ed to break a circularity
nt_matchers(~[ast::matcher])
@ -116,7 +113,7 @@ fn binop_to_str(o: binop) -> ~str {
}
}
fn to_str(in: interner<@~str>, t: token) -> ~str {
fn to_str(in: @ident_interner, t: token) -> ~str {
match t {
EQ => ~"=",
LT => ~"<",
@ -174,7 +171,7 @@ fn to_str(in: interner<@~str>, t: token) -> ~str {
}
body + ast_util::float_ty_to_str(t)
}
LIT_STR(s) => { ~"\"" + str::escape_default( *in.get(s)) + ~"\"" }
LIT_STR(s) => { ~"\"" + str::escape_default(*in.get(s)) + ~"\"" }
/* Name components */
IDENT(s, _) => *in.get(s),
@ -281,49 +278,66 @@ pure fn is_bar(t: token) -> bool {
mod special_idents {
#[legacy_exports];
use ast::ident;
const underscore : ident = 0u;
const anon : ident = 1u;
const dtor : ident = 2u; // 'drop', but that's reserved
const invalid : ident = 3u; // ''
const unary : ident = 4u;
const not_fn : ident = 5u;
const idx_fn : ident = 6u;
const unary_minus_fn : ident = 7u;
const clownshoes_extensions : ident = 8u;
const underscore : ident = ident { repr: 0u };
const anon : ident = ident { repr: 1u };
const dtor : ident = ident { repr: 2u }; // 'drop', but that's reserved
const invalid : ident = ident { repr: 3u }; // ''
const unary : ident = ident { repr: 4u };
const not_fn : ident = ident { repr: 5u };
const idx_fn : ident = ident { repr: 6u };
const unary_minus_fn : ident = ident { repr: 7u };
const clownshoes_extensions : ident = ident { repr: 8u };
const self_ : ident = 9u; // 'self'
const self_ : ident = ident { repr: 9u }; // 'self'
/* for matcher NTs */
const item : ident = 10u;
const block : ident = 11u;
const stmt : ident = 12u;
const pat : ident = 13u;
const expr : ident = 14u;
const ty : ident = 15u;
const ident : ident = 16u;
const path : ident = 17u;
const tt : ident = 18u;
const matchers : ident = 19u;
const item : ident = ident { repr: 10u };
const block : ident = ident { repr: 11u };
const stmt : ident = ident { repr: 12u };
const pat : ident = ident { repr: 13u };
const expr : ident = ident { repr: 14u };
const ty : ident = ident { repr: 15u };
const ident : ident = ident { repr: 16u };
const path : ident = ident { repr: 17u };
const tt : ident = ident { repr: 18u };
const matchers : ident = ident { repr: 19u };
const str : ident = 20u; // for the type
const str : ident = ident { repr: 20u }; // for the type
/* outside of libsyntax */
const ty_visitor : ident = 21u;
const arg : ident = 22u;
const descrim : ident = 23u;
const clownshoe_abi : ident = 24u;
const clownshoe_stack_shim : ident = 25u;
const tydesc : ident = 26u;
const literally_dtor : ident = 27u;
const main : ident = 28u;
const opaque : ident = 29u;
const blk : ident = 30u;
const static : ident = 31u;
const intrinsic : ident = 32u;
const clownshoes_foreign_mod: ident = 33;
const ty_visitor : ident = ident { repr: 21u };
const arg : ident = ident { repr: 22u };
const descrim : ident = ident { repr: 23u };
const clownshoe_abi : ident = ident { repr: 24u };
const clownshoe_stack_shim : ident = ident { repr: 25u };
const tydesc : ident = ident { repr: 26u };
const literally_dtor : ident = ident { repr: 27u };
const main : ident = ident { repr: 28u };
const opaque : ident = ident { repr: 29u };
const blk : ident = ident { repr: 30u };
const static : ident = ident { repr: 31u };
const intrinsic : ident = ident { repr: 32u };
const clownshoes_foreign_mod: ident = ident { repr: 33 };
}
type ident_interner = util::interner::interner<@~str>;
struct ident_interner {
priv interner: util::interner::interner<@~str>,
}
impl ident_interner {
fn intern(val: @~str) -> ast::ident {
ast::ident { repr: self.interner.intern(val) }
}
fn gensym(val: @~str) -> ast::ident {
ast::ident { repr: self.interner.gensym(val) }
}
pure fn get(idx: ast::ident) -> @~str {
self.interner.get(idx.repr)
}
fn len() -> uint {
self.interner.len()
}
}
/** Key for thread-local data for sneaking interner information to the
* serializer/deserializer. It sounds like a hack because it is one.
@ -335,7 +349,7 @@ macro_rules! interner_key (
(-3 as uint, 0u)))
)
fn mk_ident_interner() -> ident_interner {
fn mk_ident_interner() -> @ident_interner {
/* the indices here must correspond to the numbers in special_idents */
let init_vec = ~[@~"_", @~"anon", @~"drop", @~"", @~"unary", @~"!",
@~"[]", @~"unary-", @~"__extensions__", @~"self",
@ -346,7 +360,9 @@ fn mk_ident_interner() -> ident_interner {
@~"dtor", @~"main", @~"<opaque>", @~"blk", @~"static",
@~"intrinsic", @~"__foreign_mod__"];
let rv = interner::mk_prefill::<@~str>(init_vec);
let rv = @ident_interner {
interner: interner::mk_prefill::<@~str>(init_vec)
};
/* having multiple interners will just confuse the serializer */
unsafe {
@ -360,8 +376,8 @@ fn mk_ident_interner() -> ident_interner {
/* for when we don't care about the contents; doesn't interact with TLD or
serialization */
fn mk_fake_ident_interner() -> ident_interner {
interner::mk::<@~str>()
fn mk_fake_ident_interner() -> @ident_interner {
@ident_interner { interner: interner::mk::<@~str>() }
}
/**

34
src/libsyntax/print/pprust.rs
View File

@ -25,7 +25,7 @@ fn no_ann() -> pp_ann {
type ps =
@{s: pp::printer,
cm: Option<codemap>,
intr: token::ident_interner,
intr: @token::ident_interner,
comments: Option<~[comments::cmnt]>,
literals: Option<~[comments::lit]>,
mut cur_cmnt: uint,
@ -43,7 +43,7 @@ fn end(s: ps) {
pp::end(s.s);
}
fn rust_printer(writer: io::Writer, intr: ident_interner) -> ps {
fn rust_printer(writer: io::Writer, intr: @ident_interner) -> ps {
return @{s: pp::mk_printer(writer, default_columns),
cm: None::<codemap>,
intr: intr,
@ -63,7 +63,7 @@ const default_columns: uint = 78u;
// Requires you to pass an input filename and reader so that
// it can scan the input text for comments and literals to
// copy forward.
fn print_crate(cm: codemap, intr: ident_interner,
fn print_crate(cm: codemap, intr: @ident_interner,
span_diagnostic: diagnostic::span_handler,
crate: @ast::crate, filename: ~str, in: io::Reader,
out: io::Writer, ann: pp_ann, is_expanded: bool) {
@ -91,40 +91,40 @@ fn print_crate_(s: ps, &&crate: @ast::crate) {
eof(s.s);
}
fn ty_to_str(ty: @ast::ty, intr: ident_interner) -> ~str {
fn ty_to_str(ty: @ast::ty, intr: @ident_interner) -> ~str {
to_str(ty, print_type, intr)
}
fn pat_to_str(pat: @ast::pat, intr: ident_interner) -> ~str {
fn pat_to_str(pat: @ast::pat, intr: @ident_interner) -> ~str {
to_str(pat, print_pat, intr)
}
fn expr_to_str(e: @ast::expr, intr: ident_interner) -> ~str {
fn expr_to_str(e: @ast::expr, intr: @ident_interner) -> ~str {
to_str(e, print_expr, intr)
}
fn tt_to_str(tt: ast::token_tree, intr: ident_interner) -> ~str {
fn tt_to_str(tt: ast::token_tree, intr: @ident_interner) -> ~str {
to_str(tt, print_tt, intr)
}
fn stmt_to_str(s: ast::stmt, intr: ident_interner) -> ~str {
fn stmt_to_str(s: ast::stmt, intr: @ident_interner) -> ~str {
to_str(s, print_stmt, intr)
}
fn item_to_str(i: @ast::item, intr: ident_interner) -> ~str {
fn item_to_str(i: @ast::item, intr: @ident_interner) -> ~str {
to_str(i, print_item, intr)
}
fn typarams_to_str(tps: ~[ast::ty_param], intr: ident_interner) -> ~str {
fn typarams_to_str(tps: ~[ast::ty_param], intr: @ident_interner) -> ~str {
to_str(tps, print_type_params, intr)
}
fn path_to_str(&&p: @ast::path, intr: ident_interner) -> ~str {
fn path_to_str(&&p: @ast::path, intr: @ident_interner) -> ~str {
to_str(p, |a,b| print_path(a, b, false), intr)
}
fn fun_to_str(decl: ast::fn_decl, name: ast::ident,
params: ~[ast::ty_param], intr: ident_interner) -> ~str {
params: ~[ast::ty_param], intr: @ident_interner) -> ~str {
do io::with_str_writer |wr| {
let s = rust_printer(wr, intr);
print_fn(s, decl, None, name, params, None, ast::inherited);
@ -147,7 +147,7 @@ fn test_fun_to_str() {
assert fun_to_str(decl, "a", ~[]) == "fn a()";
}
fn block_to_str(blk: ast::blk, intr: ident_interner) -> ~str {
fn block_to_str(blk: ast::blk, intr: @ident_interner) -> ~str {
do io::with_str_writer |wr| {
let s = rust_printer(wr, intr);
// containing cbox, will be closed by print-block at }
@ -159,15 +159,15 @@ fn block_to_str(blk: ast::blk, intr: ident_interner) -> ~str {
}
}
fn meta_item_to_str(mi: @ast::meta_item, intr: ident_interner) -> ~str {
fn meta_item_to_str(mi: @ast::meta_item, intr: @ident_interner) -> ~str {
to_str(mi, print_meta_item, intr)
}
fn attribute_to_str(attr: ast::attribute, intr: ident_interner) -> ~str {
fn attribute_to_str(attr: ast::attribute, intr: @ident_interner) -> ~str {
to_str(attr, print_attribute, intr)
}
fn variant_to_str(var: ast::variant, intr: ident_interner) -> ~str {
fn variant_to_str(var: ast::variant, intr: @ident_interner) -> ~str {
to_str(var, print_variant, intr)
}
@ -2059,7 +2059,7 @@ fn print_string(s: ps, st: ~str) {
word(s.s, ~"\"");
}
fn to_str<T>(t: T, f: fn@(ps, T), intr: ident_interner) -> ~str {
fn to_str<T>(t: T, f: fn@(ps, T), intr: @ident_interner) -> ~str {
do io::with_str_writer |wr| {
let s = rust_printer(wr, intr);
f(s, t);

2
src/rustc/back/link.rs
View File

@ -607,7 +607,7 @@ fn mangle_internal_name_by_path(ccx: @crate_ctxt, path: path) -> ~str {
}
fn mangle_internal_name_by_seq(ccx: @crate_ctxt, flav: ~str) -> ~str {
return fmt!("%s_%u", flav, ccx.names(flav));
return fmt!("%s_%u", flav, ccx.names(flav).repr);
}
// If the user wants an exe generated we need to invoke

2
src/rustc/driver/session.rs
View File

@ -243,7 +243,7 @@ impl session {
fn ident_of(st: ~str) -> ast::ident {
self.parse_sess.interner.intern(@st)
}
fn intr() -> syntax::parse::token::ident_interner {
fn intr() -> @syntax::parse::token::ident_interner {
self.parse_sess.interner
}
}

4
src/rustc/metadata/creader.rs
View File

@ -18,7 +18,7 @@ export read_crates;
// libraries necessary for later resolving, typechecking, linking, etc.
fn read_crates(diag: span_handler, crate: ast::crate,
cstore: cstore::cstore, filesearch: filesearch,
os: loader::os, static: bool, intr: ident_interner) {
os: loader::os, static: bool, intr: @ident_interner) {
let e = @{diag: diag,
filesearch: filesearch,
cstore: cstore,
@ -94,7 +94,7 @@ type env = @{diag: span_handler,
static: bool,
crate_cache: DVec<cache_entry>,
mut next_crate_num: ast::crate_num,
intr: ident_interner};
intr: @ident_interner};
fn visit_view_item(e: env, i: @ast::view_item) {
match i.node {

4
src/rustc/metadata/cstore.rs
View File

@ -58,7 +58,7 @@ type cstore_private =
mut used_crate_files: ~[Path],
mut used_libraries: ~[~str],
mut used_link_args: ~[~str],
intr: ident_interner};
intr: @ident_interner};
// Map from node_id's of local use statements to crate numbers
type use_crate_map = map::HashMap<ast::node_id, ast::crate_num>;
@ -68,7 +68,7 @@ pure fn p(cstore: cstore) -> cstore_private {
match cstore { private(p) => p }
}
fn mk_cstore(intr: ident_interner) -> cstore {
fn mk_cstore(intr: @ident_interner) -> cstore {
let meta_cache = map::HashMap();
let crate_map = map::HashMap();
let mod_path_map = HashMap();

42
src/rustc/metadata/decoder.rs
View File

@ -268,7 +268,7 @@ fn enum_variant_ids(item: ebml::Doc, cdata: cmd) -> ~[ast::def_id] {
return ids;
}
fn item_path(intr: ident_interner, item_doc: ebml::Doc) -> ast_map::path {
fn item_path(intr: @ident_interner, item_doc: ebml::Doc) -> ast_map::path {
let path_doc = ebml::get_doc(item_doc, tag_path);
let len_doc = ebml::get_doc(path_doc, tag_path_len);
@ -290,7 +290,7 @@ fn item_path(intr: ident_interner, item_doc: ebml::Doc) -> ast_map::path {
return result;
}
fn item_name(intr: ident_interner, item: ebml::Doc) -> ast::ident {
fn item_name(intr: @ident_interner, item: ebml::Doc) -> ast::ident {
let name = ebml::get_doc(item, tag_paths_data_name);
intr.intern(@str::from_bytes(ebml::doc_data(name)))
}
@ -365,7 +365,7 @@ fn get_impl_traits(cdata: cmd, id: ast::node_id, tcx: ty::ctxt) -> ~[ty::t] {
item_impl_traits(lookup_item(id, cdata.data), tcx, cdata)
}
fn get_impl_method(intr: ident_interner, cdata: cmd, id: ast::node_id,
fn get_impl_method(intr: @ident_interner, cdata: cmd, id: ast::node_id,
name: ast::ident) -> ast::def_id {
let items = ebml::get_doc(ebml::Doc(cdata.data), tag_items);
let mut found = None;
@ -378,7 +378,7 @@ fn get_impl_method(intr: ident_interner, cdata: cmd, id: ast::node_id,
found.get()
}
fn get_class_method(intr: ident_interner, cdata: cmd, id: ast::node_id,
fn get_class_method(intr: @ident_interner, cdata: cmd, id: ast::node_id,
name: ast::ident) -> ast::def_id {
let items = ebml::get_doc(ebml::Doc(cdata.data), tag_items);
let mut found = None;
@ -451,7 +451,7 @@ fn path_entry(path_string: ~str, def_like: def_like) -> path_entry {
}
/// Iterates over all the paths in the given crate.
fn each_path(intr: ident_interner, cdata: cmd, f: fn(path_entry) -> bool) {
fn each_path(intr: @ident_interner, cdata: cmd, f: fn(path_entry) -> bool) {
let root = ebml::Doc(cdata.data);
let items = ebml::get_doc(root, tag_items);
let items_data = ebml::get_doc(items, tag_items_data);
@ -531,7 +531,7 @@ fn each_path(intr: ident_interner, cdata: cmd, f: fn(path_entry) -> bool) {
}
}
fn get_item_path(intr: ident_interner, cdata: cmd, id: ast::node_id)
fn get_item_path(intr: @ident_interner, cdata: cmd, id: ast::node_id)
-> ast_map::path {
item_path(intr, lookup_item(id, cdata.data))
}
@ -542,7 +542,7 @@ type decode_inlined_item = fn(
path: ast_map::path,
par_doc: ebml::Doc) -> Option<ast::inlined_item>;
fn maybe_get_item_ast(intr: ident_interner, cdata: cmd, tcx: ty::ctxt,
fn maybe_get_item_ast(intr: @ident_interner, cdata: cmd, tcx: ty::ctxt,
id: ast::node_id,
decode_inlined_item: decode_inlined_item
) -> csearch::found_ast {
@ -568,7 +568,7 @@ fn maybe_get_item_ast(intr: ident_interner, cdata: cmd, tcx: ty::ctxt,
}
}
fn get_enum_variants(intr: ident_interner, cdata: cmd, id: ast::node_id,
fn get_enum_variants(intr: @ident_interner, cdata: cmd, id: ast::node_id,
tcx: ty::ctxt) -> ~[ty::variant_info] {
let data = cdata.data;
let items = ebml::get_doc(ebml::Doc(data), tag_items);
@ -638,7 +638,7 @@ fn get_self_ty(item: ebml::Doc) -> ast::self_ty_ {
}
}
fn item_impl_methods(intr: ident_interner, cdata: cmd, item: ebml::Doc,
fn item_impl_methods(intr: @ident_interner, cdata: cmd, item: ebml::Doc,
base_tps: uint) -> ~[@method_info] {
let mut rslt = ~[];
for ebml::tagged_docs(item, tag_item_impl_method) |doc| {
@ -654,7 +654,7 @@ fn item_impl_methods(intr: ident_interner, cdata: cmd, item: ebml::Doc,
rslt
}
fn get_impls_for_mod(intr: ident_interner, cdata: cmd,
fn get_impls_for_mod(intr: @ident_interner, cdata: cmd,
m_id: ast::node_id, name: Option<ast::ident>,
get_cdata: fn(ast::crate_num) -> cmd)
-> @~[@_impl] {
@ -685,7 +685,7 @@ fn get_impls_for_mod(intr: ident_interner, cdata: cmd,
}
/* Works for both classes and traits */
fn get_trait_methods(intr: ident_interner, cdata: cmd, id: ast::node_id,
fn get_trait_methods(intr: @ident_interner, cdata: cmd, id: ast::node_id,
tcx: ty::ctxt) -> @~[ty::method] {
let data = cdata.data;
let item = lookup_item(id, data);
@ -712,7 +712,7 @@ fn get_trait_methods(intr: ident_interner, cdata: cmd, id: ast::node_id,
// If the item in question is a trait, returns its set of methods and
// their self types. Otherwise, returns none. This overlaps in an
// annoying way with get_trait_methods.
fn get_method_names_if_trait(intr: ident_interner, cdata: cmd,
fn get_method_names_if_trait(intr: @ident_interner, cdata: cmd,
node_id: ast::node_id)
-> Option<@DVec<(ast::ident, ast::self_ty_)>> {
@ -742,7 +742,7 @@ fn get_item_attrs(cdata: cmd,
}
// Helper function that gets either fields or methods
fn get_class_members(intr: ident_interner, cdata: cmd, id: ast::node_id,
fn get_class_members(intr: @ident_interner, cdata: cmd, id: ast::node_id,
p: fn(Family) -> bool) -> ~[ty::field_ty] {
let data = cdata.data;
let item = lookup_item(id, data);
@ -769,7 +769,7 @@ pure fn family_to_visibility(family: Family) -> ast::visibility {
}
}
fn get_class_fields(intr: ident_interner, cdata: cmd, id: ast::node_id)
fn get_class_fields(intr: @ident_interner, cdata: cmd, id: ast::node_id)
-> ~[ty::field_ty] {
get_class_members(intr, cdata, id, |f| f == PublicField
|| f == PrivateField || f == InheritedField)
@ -876,14 +876,14 @@ fn get_attributes(md: ebml::Doc) -> ~[ast::attribute] {
return attrs;
}
fn list_meta_items(intr: ident_interner,
fn list_meta_items(intr: @ident_interner,
meta_items: ebml::Doc, out: io::Writer) {
for get_meta_items(meta_items).each |mi| {
out.write_str(fmt!("%s\n", pprust::meta_item_to_str(*mi, intr)));
}
}
fn list_crate_attributes(intr: ident_interner, md: ebml::Doc, hash: ~str,
fn list_crate_attributes(intr: @ident_interner, md: ebml::Doc, hash: ~str,
out: io::Writer) {
out.write_str(fmt!("=Crate Attributes (%s)=\n", hash));
@ -901,7 +901,7 @@ fn get_crate_attributes(data: @~[u8]) -> ~[ast::attribute] {
type crate_dep = {cnum: ast::crate_num, name: ast::ident,
vers: ~str, hash: ~str};
fn get_crate_deps(intr: ident_interner, data: @~[u8]) -> ~[crate_dep] {
fn get_crate_deps(intr: @ident_interner, data: @~[u8]) -> ~[crate_dep] {
let mut deps: ~[crate_dep] = ~[];
let cratedoc = ebml::Doc(data);
let depsdoc = ebml::get_doc(cratedoc, tag_crate_deps);
@ -919,7 +919,7 @@ fn get_crate_deps(intr: ident_interner, data: @~[u8]) -> ~[crate_dep] {
return deps;
}
fn list_crate_deps(intr: ident_interner, data: @~[u8], out: io::Writer) {
fn list_crate_deps(intr: @ident_interner, data: @~[u8], out: io::Writer) {
out.write_str(~"=External Dependencies=\n");
for get_crate_deps(intr, data).each |dep| {
@ -946,7 +946,7 @@ fn get_crate_vers(data: @~[u8]) -> ~str {
};
}
fn iter_crate_items(intr: ident_interner,
fn iter_crate_items(intr: @ident_interner,
cdata: cmd, proc: fn(~str, ast::def_id)) {
for each_path(intr, cdata) |path_entry| {
match path_entry.def_like {
@ -958,7 +958,7 @@ fn iter_crate_items(intr: ident_interner,
}
}
fn get_crate_module_paths(intr: ident_interner, cdata: cmd)
fn get_crate_module_paths(intr: @ident_interner, cdata: cmd)
-> ~[(ast::def_id, ~str)] {
fn mod_of_path(p: ~str) -> ~str {
str::connect(vec::init(str::split_str(p, ~"::")), ~"::")
@ -985,7 +985,7 @@ fn get_crate_module_paths(intr: ident_interner, cdata: cmd)
}
}
fn list_crate_metadata(intr: ident_interner, bytes: @~[u8],
fn list_crate_metadata(intr: @ident_interner, bytes: @~[u8],
out: io::Writer) {
let hash = get_crate_hash(bytes);
let md = ebml::Doc(bytes);

6
src/rustc/metadata/loader.rs
View File

@ -35,7 +35,7 @@ type ctxt = {
hash: ~str,
os: os,
static: bool,
intr: ident_interner
intr: @ident_interner
};
fn load_library_crate(cx: ctxt) -> {ident: ~str, data: @~[u8]} {
@ -135,7 +135,7 @@ fn crate_name_from_metas(metas: ~[@ast::meta_item]) -> ~str {
}
}
fn note_linkage_attrs(intr: ident_interner, diag: span_handler,
fn note_linkage_attrs(intr: @ident_interner, diag: span_handler,
attrs: ~[ast::attribute]) {
for attr::find_linkage_metas(attrs).each |mi| {
diag.handler().note(fmt!("meta: %s",
@ -226,7 +226,7 @@ fn meta_section_name(os: os) -> ~str {
}
// A diagnostic function for dumping crate metadata to an output stream
fn list_file_metadata(intr: ident_interner,
fn list_file_metadata(intr: @ident_interner,
os: os, path: &Path, out: io::Writer) {
match get_metadata_section(os, path) {
option::Some(bytes) => decoder::list_crate_metadata(intr, bytes, out),

6
src/rustc/middle/resolve.rs
View File

@ -652,14 +652,14 @@ struct PrimitiveTypeTable {
}
impl PrimitiveTypeTable {
fn intern(intr: ident_interner, string: @~str,
fn intern(intr: @ident_interner, string: @~str,
primitive_type: prim_ty) {
let atom = intr.intern(string);
self.primitive_types.insert(atom, primitive_type);
}
}
fn PrimitiveTypeTable(intr: ident_interner) -> PrimitiveTypeTable {
fn PrimitiveTypeTable(intr: @ident_interner) -> PrimitiveTypeTable {
let table = PrimitiveTypeTable {
primitive_types: atom_hashmap()
};
@ -765,7 +765,7 @@ struct Resolver {
lang_items: LanguageItems,
crate: @crate,
intr: ident_interner,
intr: @ident_interner,
graph_root: @NameBindings,

9
src/rustc/middle/trans/common.rs
View File

@ -25,9 +25,9 @@ use syntax::parse::token::ident_interner;
use syntax::ast::ident;
type namegen = fn@(~str) -> ident;
fn new_namegen(intr: ident_interner) -> namegen {
fn new_namegen(intr: @ident_interner) -> namegen {
return fn@(prefix: ~str) -> ident {
return intr.gensym(@fmt!("%s_%u", prefix, intr.gensym(@prefix)))
return intr.gensym(@fmt!("%s_%u", prefix, intr.gensym(@prefix).repr))
};
}
@ -1024,7 +1024,7 @@ fn C_cstr(cx: @crate_ctxt, s: ~str) -> ValueRef {
llvm::LLVMConstString(buf, str::len(s) as c_uint, False)
};
let g =
str::as_c_str(fmt!("str%u", cx.names(~"str")),
str::as_c_str(fmt!("str%u", cx.names(~"str").repr),
|buf| llvm::LLVMAddGlobal(cx.llmod, val_ty(sc), buf));
llvm::LLVMSetInitializer(g, sc);
llvm::LLVMSetGlobalConstant(g, True);
@ -1086,7 +1086,8 @@ fn C_bytes_plus_null(bytes: ~[u8]) -> ValueRef unsafe {
fn C_shape(ccx: @crate_ctxt, bytes: ~[u8]) -> ValueRef {
let llshape = C_bytes_plus_null(bytes);
let llglobal = str::as_c_str(fmt!("shape%u", ccx.names(~"shape")), |buf| {
let name = fmt!("shape%u", ccx.names(~"shape").repr);
let llglobal = str::as_c_str(name, |buf| {
llvm::LLVMAddGlobal(ccx.llmod, val_ty(llshape), buf)
});
llvm::LLVMSetInitializer(llglobal, llshape);

2
src/rustc/middle/trans/debuginfo.rs
View File

@ -90,7 +90,7 @@ type debug_ctxt = {
crate_file: ~str
};
fn mk_ctxt(crate: ~str, intr: ident_interner) -> debug_ctxt {
fn mk_ctxt(crate: ~str, intr: @ident_interner) -> debug_ctxt {
{llmetadata: map::HashMap(),
names: new_namegen(intr),
crate_file: crate}

2
src/rustdoc/extract.rs
View File

@ -21,7 +21,7 @@ fn to_str(id: ast::ident) -> ~str {
return *(*intr.get()).get(id);
}
fn interner() -> syntax::parse::token::ident_interner {
fn interner() -> @syntax::parse::token::ident_interner {
return *(unsafe{ local_data_get(interner_key!()) }).get();
}