bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

intern identifiers

Browse source
This commit is contained in:
Paul Stansifer 2012-07-18 16:18:02 -07:00
parent 7317bf8792
commit 1153b5dcc8
94 changed files with 1667 additions and 1469 deletions
Download patch file Download diff file Expand all files Collapse all files

32
src/cargo/cargo.rs
View file

@ -225,7 +225,7 @@ fn load_link(mis: ~[@ast::meta_item]) -> (option<~str>,
for mis.each |a| {
match a.node {
ast::meta_name_value(v, {node: ast::lit_str(s), span: _}) => {
match *v {
match v {
~"name" => name = some(*s),
~"vers" => vers = some(*s),
~"uuid" => uuid = some(*s),
@ -252,15 +252,15 @@ fn load_crate(filename: ~str) -> option<crate> {
for c.node.attrs.each |a| {
match a.node.value.node {
ast::meta_name_value(v, {node: ast::lit_str(s), span: _}) => {
match *v {
~"desc" => desc = some(*v),
~"sigs" => sigs = some(*v),
~"crate_type" => crate_type = some(*v),
match v {
~"desc" => desc = some(v),
~"sigs" => sigs = some(v),
~"crate_type" => crate_type = some(v),
_ => { }
}
}
ast::meta_list(v, mis) => {
if *v == ~"link" {
if v == ~"link" {
let (n, v, u) = load_link(mis);
name = n;
vers = v;
@ -278,13 +278,15 @@ fn load_crate(filename: ~str) -> option<crate> {
mut deps: ~[~str]
};
fn goto_view_item(e: env, i: @ast::view_item) {
fn goto_view_item(ps: syntax::parse::parse_sess, e: env,
i: @ast::view_item) {
match i.node {
ast::view_item_use(ident, metas, id) => {
let name_items =
attr::find_meta_items_by_name(metas, ~"name");
let m = if name_items.is_empty() {
metas + ~[attr::mk_name_value_item_str(@~"name", *ident)]
metas + ~[attr::mk_name_value_item_str(
~"name", *ps.interner.get(ident))]
} else {
metas
};
@ -297,9 +299,9 @@ fn load_crate(filename: ~str) -> option<crate> {
some(value) => {
let name = attr::get_meta_item_name(item);
match *name {
~"vers" => attr_vers = *value,
~"from" => attr_from = *value,
match name {
~"vers" => attr_vers = value,
~"from" => attr_from = value,
_ => ()
}
}
@ -311,11 +313,11 @@ fn load_crate(filename: ~str) -> option<crate> {
attr_from
} else {
if !str::is_empty(attr_vers) {
*attr_name + ~"@" + attr_vers
} else { *attr_name }
ps.interner.get(attr_name) + ~"@" + attr_vers
} else { *ps.interner.get(attr_name) }
};
match *attr_name {
match *ps.interner.get(attr_name) {
~"std" | ~"core" => (),
_ => vec::push(e.deps, query)
}
@ -330,7 +332,7 @@ fn load_crate(filename: ~str) -> option<crate> {
mut deps: ~[]
};
let v = visit::mk_simple_visitor(@{
visit_view_item: |a| goto_view_item(e, a),
visit_view_item: |a| goto_view_item(sess, e, a),
visit_item: |a| goto_item(e, a),
with *visit::default_simple_visitor()
});

14
src/fuzzer/fuzzer.rs
View file

@ -238,20 +238,23 @@ fn check_variants_T<T: copy>(
filename: ~str,
thing_label: ~str,
things: ~[T],
stringifier: fn@(@T) -> ~str,
stringifier: fn@(@T, syntax::parse::token::ident_interner) -> ~str,
replacer: fn@(ast::crate, uint, T, test_mode) -> ast::crate,
cx: context
) {
error!{"%s contains %u %s objects", filename,
vec::len(things), thing_label};
// Assuming we're not generating any token_trees
let intr = syntax::parse::token::mk_fake_ident_interner();
let L = vec::len(things);
if L < 100u {
do under(uint::min(L, 20u)) |i| {
log(error, ~"Replacing... #" + uint::str(i));
do under(uint::min(L, 30u)) |j| {
log(error, ~"With... " + stringifier(@things[j]));
log(error, ~"With... " + stringifier(@things[j], intr));
let crate2 = @replacer(crate, i, things[j], cx.mode);
// It would be best to test the *crate* for stability, but
// testing the string for stability is easier and ok for now.
@ -259,8 +262,7 @@ fn check_variants_T<T: copy>(
let str3 =
@as_str(|a|pprust::print_crate(
codemap,
// Assuming we're not generating any token_trees
syntax::parse::token::mk_ident_interner(),
intr,
diagnostic::mk_span_handler(handler, codemap),
crate2,
filename,
@ -422,7 +424,7 @@ fn parse_and_print(code: @~str) -> ~str {
pprust::print_crate(
sess.cm,
// Assuming there are no token_trees
syntax::parse::token::mk_ident_interner(),
syntax::parse::token::mk_fake_ident_interner(),
sess.span_diagnostic,
crate,
filename,
@ -570,7 +572,7 @@ fn check_variants(files: ~[~str], cx: context) {
as_str(|a| pprust::print_crate(
sess.cm,
// Assuming no token_trees
syntax::parse::token::mk_ident_interner(),
syntax::parse::token::mk_fake_ident_interner(),
sess.span_diagnostic,
crate,
file,

50
src/libsyntax/ast.rs
View file

@ -30,8 +30,18 @@ fn deserialize_span<D>(_d: D) -> span {
#[auto_serialize]
type spanned<T> = {node: T, span: span};
#[auto_serialize]
type ident = @~str;
fn serialize_ident<S: serializer>(s: S, i: ident) {
let intr = unsafe{ task::local_data_get(parse::token::interner_key) };
s.emit_str(*(*intr.get()).get(i));
}
fn deserialize_ident<D: deserializer>(d: D) -> ident {
let intr = unsafe{ task::local_data_get(parse::token::interner_key) };
(*intr.get()).intern(@d.read_str())
}
type ident = token::str_num;
// Functions may or may not have names.
#[auto_serialize]
@ -127,9 +137,9 @@ type meta_item = spanned<meta_item_>;
#[auto_serialize]
enum meta_item_ {
meta_word(ident),
meta_list(ident, ~[@meta_item]),
meta_name_value(ident, lit),
meta_word(~str),
meta_list(~str, ~[@meta_item]),
meta_name_value(~str, lit),
}
#[auto_serialize]
@ -815,36 +825,6 @@ enum inlined_item {
ii_dtor(class_dtor, ident, ~[ty_param], def_id /* parent id */)
}
// Convenience functions
pure fn simple_path(id: ident, span: span) -> @path {
@{span: span,
global: false,
idents: ~[id],
rp: none,
types: ~[]}
}
pure fn empty_span() -> span {
{lo: 0, hi: 0, expn_info: none}
}
// Convenience implementations
impl ident: ops::add<ident,@path> {
pure fn add(&&id: ident) -> @path {
simple_path(self, empty_span()) + id
}
}
impl @path: ops::add<ident,@path> {
pure fn add(&&id: ident) -> @path {
@{
idents: vec::append_one(self.idents, id)
with *self
}
}
}
//
// Local Variables:

37
src/libsyntax/ast_map.rs
View file

@ -4,31 +4,33 @@ import ast::*;
import print::pprust;
import ast_util::{path_to_ident, stmt_id};
import diagnostic::span_handler;
import parse::token::ident_interner;
enum path_elt { path_mod(ident), path_name(ident) }
type path = ~[path_elt];
/* FIXMEs that say "bad" are as per #2543 */
fn path_to_str_with_sep(p: path, sep: ~str) -> ~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) => /* FIXME (#2543) */ copy *s,
path_name(s) => /* FIXME (#2543) */ copy *s
path_mod(s) => *itr.get(s),
path_name(s) => *itr.get(s)
}
};
str::connect(strs, sep)
}
fn path_ident_to_str(p: path, i: ident) -> ~str {
fn path_ident_to_str(p: path, i: ident, itr: ident_interner) -> ~str {
if vec::is_empty(p) {
/* FIXME (#2543) */ copy *i
//FIXME /* FIXME (#2543) */ copy *i
*itr.get(i)
} else {
fmt!{"%s::%s", path_to_str(p), *i}
fmt!{"%s::%s", path_to_str(p, itr), *itr.get(i)}
}
}
fn path_to_str(p: path) -> ~str {
path_to_str_with_sep(p, ~"::")
fn path_to_str(p: path, itr: ident_interner) -> ~str {
path_to_str_with_sep(p, ~"::", itr)
}
enum ast_node {
@ -291,43 +293,42 @@ 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) -> ~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}
}
some(node_item(item, path)) => {
fmt!{"item %s (id=%?)", path_ident_to_str(*path, item.ident), id}
fmt!{"item %s (id=%?)", path_ident_to_str(*path, item.ident, itr), id}
}
some(node_foreign_item(item, abi, path)) => {
fmt!{"foreign item %s with abi %? (id=%?)",
path_ident_to_str(*path, item.ident), abi, id}
path_ident_to_str(*path, item.ident, itr), abi, id}
}
some(node_method(m, impl_did, path)) => {
fmt!{"method %s in %s (id=%?)",
*m.ident, path_to_str(*path), id}
*itr.get(m.ident), path_to_str(*path, itr), id}
}
some(node_trait_method(tm, impl_did, path)) => {
let m = ast_util::trait_method_to_ty_method(*tm);
fmt!{"method %s in %s (id=%?)",
*m.ident, path_to_str(*path), id}
*itr.get(m.ident), path_to_str(*path, itr), id}
}
some(node_variant(variant, def_id, path)) => {
fmt!{"variant %s in %s (id=%?)",
*variant.node.name, path_to_str(*path), id}
*itr.get(variant.node.name), path_to_str(*path, itr), id}
}
some(node_expr(expr)) => {
fmt!{"expr %s (id=%?)",
pprust::expr_to_str(expr), id}
fmt!{"expr %s (id=%?)", pprust::expr_to_str(expr, itr), id}
}
some(node_stmt(stmt)) => {
fmt!{"stmt %s (id=%?)",
pprust::stmt_to_str(*stmt), id}
pprust::stmt_to_str(*stmt, itr), id}
}
// FIXMEs are as per #2410
some(node_export(_, path)) => {
fmt!{"export %s (id=%?)", // add more info here
path_to_str(*path), id}
path_to_str(*path, itr), id}
}
some(node_arg(_, _)) => { // add more info here
fmt!{"arg (id=%?)", id}

10
src/libsyntax/ast_util.rs
View file

@ -21,13 +21,14 @@ pure fn mk_sp(lo: uint, hi: uint) -> span {
// make this a const, once the compiler supports it
pure fn dummy_sp() -> span { return mk_sp(0u, 0u); }
pure fn path_name(p: @path) -> ~str { path_name_i(p.idents) }
pure fn path_name_i(idents: ~[ident]) -> ~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|*i), ~"::")
str::connect(idents.map(|i| *intr.get(i)), ~"::")
}
pure fn path_to_ident(p: @path) -> ident { vec::last(p.idents) }
pure fn local_def(id: node_id) -> def_id { {crate: local_crate, node: id} }
@ -408,7 +409,8 @@ fn dtor_dec() -> fn_decl {
let nil_t = @{id: 0, node: ty_nil, span: dummy_sp()};
// dtor has one argument, of type ()
{inputs: ~[{mode: ast::expl(ast::by_ref),
ty: nil_t, ident: @~"_", id: 0}],
ty: nil_t, ident: parse::token::special_idents::underscore,
id: 0}],
output: nil_t, purity: impure_fn, cf: return_val}
}

106
src/libsyntax/attr.rs
View file

@ -49,23 +49,23 @@ export require_unique_names;
/* Constructors */
fn mk_name_value_item_str(+name: ast::ident, +value: ~str) ->
fn mk_name_value_item_str(name: ~str, +value: ~str) ->
@ast::meta_item {
let value_lit = dummy_spanned(ast::lit_str(@value));
return mk_name_value_item(name, value_lit);
}
fn mk_name_value_item(+name: ast::ident, +value: ast::lit)
fn mk_name_value_item(name: ~str, +value: ast::lit)
-> @ast::meta_item {
return @dummy_spanned(ast::meta_name_value(name, value));
}
fn mk_list_item(+name: ast::ident, +items: ~[@ast::meta_item]) ->
fn mk_list_item(name: ~str, +items: ~[@ast::meta_item]) ->
@ast::meta_item {
return @dummy_spanned(ast::meta_list(name, items));
}
fn mk_word_item(+name: ast::ident) -> @ast::meta_item {
fn mk_word_item(name: ~str) -> @ast::meta_item {
return @dummy_spanned(ast::meta_word(name));
}
@ -78,7 +78,7 @@ fn mk_sugared_doc_attr(text: ~str, lo: uint, hi: uint) -> ast::attribute {
let lit = spanned(lo, hi, ast::lit_str(@text));
let attr = {
style: doc_comment_style(text),
value: spanned(lo, hi, ast::meta_name_value(@~"doc", lit)),
value: spanned(lo, hi, ast::meta_name_value(~"doc", lit)),
is_sugared_doc: true
};
return spanned(lo, hi, attr);
@ -98,8 +98,8 @@ fn attr_metas(attrs: ~[ast::attribute]) -> ~[@ast::meta_item] {
fn desugar_doc_attr(attr: ast::attribute) -> ast::attribute {
if attr.node.is_sugared_doc {
let comment = get_meta_item_value_str(@attr.node.value).get();
let meta = mk_name_value_item_str(@~"doc",
strip_doc_comment_decoration(*comment));
let meta = mk_name_value_item_str(~"doc",
strip_doc_comment_decoration(comment));
return mk_attr(meta);
} else {
attr
@ -108,16 +108,15 @@ fn desugar_doc_attr(attr: ast::attribute) -> ast::attribute {
/* Accessors */
fn get_attr_name(attr: ast::attribute) -> ast::ident {
fn get_attr_name(attr: ast::attribute) -> ~str {
get_meta_item_name(@attr.node.value)
}
// All "bad" FIXME copies are as per #2543
fn get_meta_item_name(meta: @ast::meta_item) -> ast::ident {
fn get_meta_item_name(meta: @ast::meta_item) -> ~str {
match meta.node {
ast::meta_word(n) => /* FIXME (#2543) */ copy n,
ast::meta_name_value(n, _) => /* FIXME (#2543) */ copy n,
ast::meta_list(n, _) => /* FIXME (#2543) */ copy n
ast::meta_word(n) => n,
ast::meta_name_value(n, _) => n,
ast::meta_list(n, _) => n
}
}
@ -125,10 +124,10 @@ fn get_meta_item_name(meta: @ast::meta_item) -> ast::ident {
* Gets the string value if the meta_item is a meta_name_value variant
* containing a string, otherwise none
*/
fn get_meta_item_value_str(meta: @ast::meta_item) -> option<@~str> {
fn get_meta_item_value_str(meta: @ast::meta_item) -> option<~str> {
match meta.node {
ast::meta_name_value(_, v) => match v.node {
ast::lit_str(s) => option::some(s),
ast::lit_str(s) => option::some(*s),
_ => option::none
},
_ => option::none
@ -147,9 +146,7 @@ fn get_meta_item_list(meta: @ast::meta_item) -> option<~[@ast::meta_item]> {
* If the meta item is a nam-value type with a string value then returns
* a tuple containing the name and string value, otherwise `none`
*/
fn get_name_value_str_pair(
item: @ast::meta_item
) -> option<(ast::ident, @~str)> {
fn get_name_value_str_pair(item: @ast::meta_item) -> option<(~str, ~str)> {
match attr::get_meta_item_value_str(item) {
some(value) => {
let name = attr::get_meta_item_name(item);
@ -163,11 +160,11 @@ fn get_name_value_str_pair(
/* Searching */
/// Search a list of attributes and return only those with a specific name
fn find_attrs_by_name(attrs: ~[ast::attribute], +name: ~str) ->
fn find_attrs_by_name(attrs: ~[ast::attribute], name: ~str) ->
~[ast::attribute] {
let filter = (
fn@(a: ast::attribute) -> option<ast::attribute> {
if *get_attr_name(a) == name {
if get_attr_name(a) == name {
option::some(a)
} else { option::none }
}
@ -176,10 +173,10 @@ fn find_attrs_by_name(attrs: ~[ast::attribute], +name: ~str) ->
}
/// Searcha list of meta items and return only those with a specific name
fn find_meta_items_by_name(metas: ~[@ast::meta_item], +name: ~str) ->
fn find_meta_items_by_name(metas: ~[@ast::meta_item], name: ~str) ->
~[@ast::meta_item] {
let filter = fn@(&&m: @ast::meta_item) -> option<@ast::meta_item> {
if *get_meta_item_name(m) == name {
if get_meta_item_name(m) == name {
option::some(m)
} else { option::none }
};
@ -191,14 +188,9 @@ fn find_meta_items_by_name(metas: ~[@ast::meta_item], +name: ~str) ->
* comparison is performed structurally.
*/
fn contains(haystack: ~[@ast::meta_item], needle: @ast::meta_item) -> bool {
debug!{"looking for %s",
print::pprust::meta_item_to_str(*needle)};
for haystack.each |item| {
debug!{"looking in %s",
print::pprust::meta_item_to_str(*item)};
if eq(item, needle) { debug!{"found it!"}; return true; }
if eq(item, needle) { return true; }
}
#debug("found it not :(");
return false;
}
@ -223,17 +215,18 @@ fn eq(a: @ast::meta_item, b: @ast::meta_item) -> bool {
}
}
fn contains_name(metas: ~[@ast::meta_item], +name: ~str) -> bool {
fn contains_name(metas: ~[@ast::meta_item], name: ~str) -> bool {
let matches = find_meta_items_by_name(metas, name);
return vec::len(matches) > 0u;
}
fn attrs_contains_name(attrs: ~[ast::attribute], +name: ~str) -> bool {
fn attrs_contains_name(attrs: ~[ast::attribute], name: ~str) -> bool {
vec::is_not_empty(find_attrs_by_name(attrs, name))
}
fn first_attr_value_str_by_name(attrs: ~[ast::attribute], +name: ~str)
-> option<@~str> {
fn first_attr_value_str_by_name(attrs: ~[ast::attribute], name: ~str)
-> option<~str> {
let mattrs = find_attrs_by_name(attrs, name);
if vec::len(mattrs) > 0u {
return get_meta_item_value_str(attr_meta(mattrs[0]));
@ -241,18 +234,16 @@ fn first_attr_value_str_by_name(attrs: ~[ast::attribute], +name: ~str)
return option::none;
}
fn last_meta_item_by_name(
items: ~[@ast::meta_item],
+name: ~str
) -> option<@ast::meta_item> {
fn last_meta_item_by_name(items: ~[@ast::meta_item], name: ~str)
-> option<@ast::meta_item> {
let items = attr::find_meta_items_by_name(items, name);
vec::last_opt(items)
}
fn last_meta_item_value_str_by_name(
items: ~[@ast::meta_item],
+name: ~str
) -> option<@~str> {
fn last_meta_item_value_str_by_name(items: ~[@ast::meta_item], name: ~str)
-> option<~str> {
match last_meta_item_by_name(items, name) {
some(item) => match attr::get_meta_item_value_str(item) {
some(value) => some(value),
@ -262,10 +253,9 @@ fn last_meta_item_value_str_by_name(
}
}
fn last_meta_item_list_by_name(
items: ~[@ast::meta_item],
+name: ~str
) -> option<~[@ast::meta_item]> {
fn last_meta_item_list_by_name(items: ~[@ast::meta_item], name: ~str)
-> option<~[@ast::meta_item]> {
match last_meta_item_by_name(items, name) {
some(item) => attr::get_meta_item_list(item),
none => none
@ -279,11 +269,11 @@ fn last_meta_item_list_by_name(
// the item name (See [Fixme-sorting])
fn sort_meta_items(+items: ~[@ast::meta_item]) -> ~[@ast::meta_item] {
pure fn lteq(ma: &@ast::meta_item, mb: &@ast::meta_item) -> bool {
pure fn key(m: &ast::meta_item) -> ast::ident {
pure fn key(m: &ast::meta_item) -> ~str {
match m.node {
ast::meta_word(name) => /* FIXME (#2543) */ copy name,
ast::meta_name_value(name, _) => /* FIXME (#2543) */ copy name,
ast::meta_list(name, _) => /* FIXME (#2543) */ copy name
ast::meta_word(name) => name,
ast::meta_name_value(name, _) => name,
ast::meta_list(name, _) => name
}
}
key(*ma) <= key(*mb)
@ -295,7 +285,7 @@ fn sort_meta_items(+items: ~[@ast::meta_item]) -> ~[@ast::meta_item] {
return vec::from_mut(v);
}
fn remove_meta_items_by_name(items: ~[@ast::meta_item], name: ast::ident) ->
fn remove_meta_items_by_name(items: ~[@ast::meta_item], name: ~str) ->
~[@ast::meta_item] {
return vec::filter_map(items, |item| {
@ -335,17 +325,17 @@ fn foreign_abi(attrs: ~[ast::attribute]) -> Either<~str, ast::foreign_abi> {
option::none => {
either::Right(ast::foreign_abi_cdecl)
}
option::some(@~"rust-intrinsic") => {
option::some(~"rust-intrinsic") => {
either::Right(ast::foreign_abi_rust_intrinsic)
}
option::some(@~"cdecl") => {
option::some(~"cdecl") => {
either::Right(ast::foreign_abi_cdecl)
}
option::some(@~"stdcall") => {
option::some(~"stdcall") => {
either::Right(ast::foreign_abi_stdcall)
}
option::some(t) => {
either::Left(~"unsupported abi: " + *t)
either::Left(~"unsupported abi: " + t)
}
};
}
@ -362,8 +352,8 @@ fn find_inline_attr(attrs: ~[ast::attribute]) -> inline_attr {
// FIXME (#2809)---validate the usage of #[inline] and #[inline(always)]
do vec::foldl(ia_none, attrs) |ia,attr| {
match attr.node.value.node {
ast::meta_word(@~"inline") => ia_hint,
ast::meta_list(@~"inline", items) => {
ast::meta_word(~"inline") => ia_hint,
ast::meta_list(~"inline", items) => {
if !vec::is_empty(find_meta_items_by_name(items, ~"always")) {
ia_always
} else if !vec::is_empty(
@ -386,11 +376,11 @@ fn require_unique_names(diagnostic: span_handler,
let name = get_meta_item_name(meta);
// FIXME: How do I silence the warnings? --pcw (#2619)
if map.contains_key(*name) {
if map.contains_key(name) {
diagnostic.span_fatal(meta.span,
fmt!{"duplicate meta item `%s`", *name});
fmt!{"duplicate meta item `%s`", name});
}
map.insert(*name, ());
map.insert(name, ());
}
}

73
src/libsyntax/ext/auto_serialize.rs
View file

@ -84,15 +84,15 @@ mod syntax {
export parse;
}
type ser_tps_map = map::hashmap<~str, fn@(@ast::expr) -> ~[@ast::stmt]>;
type deser_tps_map = map::hashmap<~str, fn@() -> @ast::expr>;
type ser_tps_map = map::hashmap<ast::ident, fn@(@ast::expr) -> ~[@ast::stmt]>;
type deser_tps_map = map::hashmap<ast::ident, fn@() -> @ast::expr>;
fn expand(cx: ext_ctxt,
span: span,
_mitem: ast::meta_item,
in_items: ~[@ast::item]) -> ~[@ast::item] {
fn not_auto_serialize(a: ast::attribute) -> bool {
attr::get_attr_name(a) != @~"auto_serialize"
attr::get_attr_name(a) != ~"auto_serialize"
}
fn filter_attrs(item: @ast::item) -> @ast::item {
@ -156,7 +156,11 @@ impl ext_ctxt: ext_ctxt_helpers {
let head = vec::init(base_path.idents);
let tail = vec::last(base_path.idents);
self.path(base_path.span,
vec::append(head, ~[@(helper_name + ~"_" + *tail)]))
vec::append(head,
~[self.parse_sess().interner.
intern(@(helper_name + ~"_" +
*self.parse_sess().interner.get(
tail)))]))
}
fn path(span: span, strs: ~[ast::ident]) -> @ast::path {
@ -181,7 +185,7 @@ impl ext_ctxt: ext_ctxt_helpers {
let args = do vec::map(input_tys) |ty| {
{mode: ast::expl(ast::by_ref),
ty: ty,
ident: @~"",
ident: parse::token::special_idents::invalid,
id: self.next_id()}
};
@ -352,7 +356,7 @@ fn ser_variant(cx: ext_ctxt,
argfn: fn(-@ast::expr, uint, ast::blk) -> @ast::expr)
-> ast::arm {
let vnames = do vec::from_fn(vec::len(tys)) |i| {
@fmt!{"__v%u", i}
cx.parse_sess().interner.intern(@fmt!{"__v%u", i})
};
let pats = do vec::from_fn(vec::len(tys)) |i| {
cx.binder_pat(tys[i].span, vnames[i])
@ -384,7 +388,7 @@ fn is_vec_or_str(ty: @ast::ty) -> bool {
// This may be wrong if the user has shadowed (!) str
ast::ty_path(@{span: _, global: _, idents: ids,
rp: none, types: _}, _)
if ids == ~[@~"str"] => true,
if ids == ~[parse::token::special_idents::str] => true,
_ => false
}
}
@ -434,7 +438,8 @@ fn ser_ty(cx: ext_ctxt, tps: ser_tps_map,
fld.node.ident,
~[]));
let s = cx.clone(s);
let f = cx.lit_str(fld.span, fld.node.ident);
let f = cx.lit_str(fld.span, cx.parse_sess().interner.get(
fld.node.ident));
let i = cx.lit_uint(fld.span, fidx);
let l = ser_lambda(cx, tps, fld.node.mt.ty, cx.clone(s), vf);
#ast[stmt]{$(s).emit_rec_field($(f), $(i), $(l));}
@ -487,7 +492,7 @@ fn ser_ty(cx: ext_ctxt, tps: ser_tps_map,
vec::is_empty(path.types) {
let ident = path.idents[0];
match tps.find(*ident) {
match tps.find(ident) {
some(f) => f(v),
none => ser_path(cx, tps, path, s, v)
}
@ -545,7 +550,7 @@ fn mk_ser_fn(cx: ext_ctxt, span: span, name: ast::ident,
ty: cx.ty_fn(span,
~[cx.ty_path(span, ~[tp.ident], ~[])],
cx.ty_nil(span)),
ident: @(~"__s" + *tp.ident),
ident: cx.ident_of(~"__s" + cx.str_of(tp.ident)),
id: cx.next_id()});
debug!{"tp_inputs = %?", tp_inputs};
@ -553,35 +558,36 @@ fn mk_ser_fn(cx: ext_ctxt, span: span, name: ast::ident,
let ser_inputs: ~[ast::arg] =
vec::append(~[{mode: ast::expl(ast::by_ref),
ty: cx.ty_path(span, ~[@~"__S"], ~[]),
ident: @~"__s",
ty: cx.ty_path(span, ~[cx.ident_of(~"__S")], ~[]),
ident: cx.ident_of(~"__s"),
id: cx.next_id()},
{mode: ast::expl(ast::by_ref),
ty: v_ty,
ident: @~"__v",
ident: cx.ident_of(~"__v"),
id: cx.next_id()}],
tp_inputs);
let tps_map = map::str_hash();
let tps_map = map::uint_hash();
do vec::iter2(tps, tp_inputs) |tp, arg| {
let arg_ident = arg.ident;
tps_map.insert(
*tp.ident,
tp.ident,
fn@(v: @ast::expr) -> ~[@ast::stmt] {
let f = cx.var_ref(span, arg_ident);
debug!{"serializing type arg %s", *arg_ident};
debug!{"serializing type arg %s", cx.str_of(arg_ident)};
~[#ast[stmt]{$(f)($(v));}]
});
}
let ser_bnds = @~[
ast::bound_trait(cx.ty_path(span,
~[@~"std", @~"serialization",
@~"serializer"],
~[cx.ident_of(~"std"),
cx.ident_of(~"serialization"),
cx.ident_of(~"serializer")],
~[]))];
let ser_tps: ~[ast::ty_param] =
vec::append(~[{ident: @~"__S",
vec::append(~[{ident: cx.ident_of(~"__S"),
id: cx.next_id(),
bounds: ser_bnds}],
vec::map(tps, |tp| cx.clone_ty_param(tp)));
@ -593,7 +599,7 @@ fn mk_ser_fn(cx: ext_ctxt, span: span, name: ast::ident,
let ser_blk = cx.blk(span,
f(cx, tps_map, #ast{ __s }, #ast{ __v }));
@{ident: @(~"serialize_" + *name),
@{ident: cx.ident_of(~"serialize_" + cx.str_of(name)),
attrs: ~[],
id: cx.next_id(),
node: ast::item_fn({inputs: ser_inputs,
@ -670,7 +676,7 @@ fn deser_ty(cx: ext_ctxt, tps: deser_tps_map,
let fields = do vec::from_fn(vec::len(flds)) |fidx| {
let fld = flds[fidx];
let d = cx.clone(d);
let f = cx.lit_str(fld.span, fld.node.ident);
let f = cx.lit_str(fld.span, @cx.str_of(fld.node.ident));
let i = cx.lit_uint(fld.span, fidx);
let l = deser_lambda(cx, tps, fld.node.mt.ty, cx.clone(d));
{node: {mutbl: fld.node.mt.mutbl,
@ -713,7 +719,7 @@ fn deser_ty(cx: ext_ctxt, tps: deser_tps_map,
vec::is_empty(path.types) {
let ident = path.idents[0];
match tps.find(*ident) {
match tps.find(ident) {
some(f) => f(),
none => deser_path(cx, tps, path, d)
}
@ -756,23 +762,23 @@ fn mk_deser_fn(cx: ext_ctxt, span: span,
ty: cx.ty_fn(span,
~[],
cx.ty_path(span, ~[tp.ident], ~[])),
ident: @(~"__d" + *tp.ident),
ident: cx.ident_of(~"__d" + cx.str_of(tp.ident)),
id: cx.next_id()});
debug!{"tp_inputs = %?", tp_inputs};
let deser_inputs: ~[ast::arg] =
vec::append(~[{mode: ast::expl(ast::by_ref),
ty: cx.ty_path(span, ~[@~"__D"], ~[]),
ident: @~"__d",
ty: cx.ty_path(span, ~[cx.ident_of(~"__D")], ~[]),
ident: cx.ident_of(~"__d"),
id: cx.next_id()}],
tp_inputs);
let tps_map = map::str_hash();
let tps_map = map::uint_hash();
do vec::iter2(tps, tp_inputs) |tp, arg| {
let arg_ident = arg.ident;
tps_map.insert(
*tp.ident,
tp.ident,
fn@() -> @ast::expr {
let f = cx.var_ref(span, arg_ident);
#ast{ $(f)() }
@ -782,11 +788,12 @@ fn mk_deser_fn(cx: ext_ctxt, span: span,
let deser_bnds = @~[
ast::bound_trait(cx.ty_path(
span,
~[@~"std", @~"serialization", @~"deserializer"],
~[cx.ident_of(~"std"), cx.ident_of(~"serialization"),
cx.ident_of(~"deserializer")],
~[]))];
let deser_tps: ~[ast::ty_param] =
vec::append(~[{ident: @~"__D",
vec::append(~[{ident: cx.ident_of(~"__D"),
id: cx.next_id(),
bounds: deser_bnds}],
vec::map(tps, |tp| {
@ -798,7 +805,7 @@ fn mk_deser_fn(cx: ext_ctxt, span: span,
let deser_blk = cx.expr_blk(f(cx, tps_map, #ast[expr]{__d}));
@{ident: @(~"deserialize_" + *name),
@{ident: cx.ident_of(~"deserialize_" + cx.str_of(name)),
attrs: ~[],
id: cx.next_id(),
node: ast::item_fn({inputs: deser_inputs,
@ -853,7 +860,7 @@ fn ser_enum(cx: ext_ctxt, tps: ser_tps_map, e_name: ast::ident,
// Generate body s.emit_enum_variant("foo", 0u,
// 3u, {|| blk })
|-s, blk| {
let v_name = cx.lit_str(v_span, v_name);
let v_name = cx.lit_str(v_span, @cx.str_of(v_name));
let v_id = cx.lit_uint(v_span, vidx);
let sz = cx.lit_uint(v_span, vec::len(variant_tys));
let body = cx.lambda(blk);
@ -877,7 +884,7 @@ fn ser_enum(cx: ext_ctxt, tps: ser_tps_map, e_name: ast::ident,
}
};
let lam = cx.lambda(cx.blk(e_span, ~[cx.alt_stmt(arms, e_span, v)]));
let e_name = cx.lit_str(e_span, e_name);
let e_name = cx.lit_str(e_span, @cx.str_of(e_name));
~[#ast[stmt]{ $(s).emit_enum($(e_name), $(lam)) }]
}
@ -935,7 +942,7 @@ fn deser_enum(cx: ext_ctxt, tps: deser_tps_map, e_name: ast::ident,
arms += ~[impossible_case];
// Generate code like:
let e_name = cx.lit_str(e_span, e_name);
let e_name = cx.lit_str(e_span, @cx.str_of(e_name));
let alt_expr = cx.expr(e_span,
ast::expr_match(#ast{__i}, arms, ast::alt_exhaustive));
let var_lambda = #ast{ |__i| $(alt_expr) };

28
src/libsyntax/ext/base.rs
View file

@ -23,7 +23,7 @@ type syntax_expander_ =
// second argument is the origin of the macro, if user-defined
type syntax_expander = {expander: syntax_expander_, span: option<span>};
type macro_def = {ident: ast::ident, ext: syntax_extension};
type macro_def = {name: ~str, ext: syntax_extension};
// macro_definer is obsolete, remove when #old_macros go away.
type macro_definer =
@ -141,6 +141,9 @@ trait ext_ctxt {
fn next_id() -> ast::node_id;
pure fn trace_macros() -> bool;
fn set_trace_macros(x: bool);
/* for unhygienic identifier transformation */
fn str_of(id: ast::ident) -> ~str;
fn ident_of(st: ~str) -> ast::ident;
}
fn mk_ctxt(parse_sess: parse::parse_sess,
@ -211,6 +214,13 @@ fn mk_ctxt(parse_sess: parse::parse_sess,
fn set_trace_macros(x: bool) {
self.trace_mac = x
}
fn str_of(id: ast::ident) -> ~str {
*self.parse_sess.interner.get(id)
}
fn ident_of(st: ~str) -> ast::ident {
self.parse_sess.interner.intern(@st)
}
}
let imp : ctxt_repr = {
parse_sess: parse_sess,
@ -264,7 +274,7 @@ fn get_mac_args(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
cx.span_fatal(sp, fmt!{"#%s needs at least %u arguments.",
name, min});
}
_ => return elts /* we're good */
_ => return elts /* we are good */
}
}
_ => {
@ -298,23 +308,25 @@ fn tt_args_to_original_flavor(cx: ext_ctxt, sp: span, arg: ~[ast::token_tree])
fn ms(m: matcher_) -> matcher {
{node: m, span: {lo: 0u, hi: 0u, expn_info: none}}
}
let arg_nm = cx.parse_sess().interner.gensym(@~"arg");
let argument_gram = ~[ms(match_seq(~[
ms(match_nonterminal(@~"arg",@~"expr", 0u))
ms(match_nonterminal(arg_nm, parse::token::special_idents::expr, 0u))
], some(parse::token::COMMA), true, 0u, 1u))];
let arg_reader = new_tt_reader(cx.parse_sess().span_diagnostic,
cx.parse_sess().interner, none, arg);
let args =
match parse_or_else(cx.parse_sess(), cx.cfg(), arg_reader as reader,
argument_gram).get(@~"arg") {
@matched_seq(s, _) => do s.map() |lf| {
argument_gram).get(arg_nm) {
@matched_seq(s, _) => {
do s.map() |lf| {
match lf {
@matched_nonterminal(parse::token::nt_expr(arg)) => {
arg /* whew! list of exprs, here we come! */
}
@matched_nonterminal(parse::token::nt_expr(arg)) =>
arg, /* whew! list of exprs, here we come! */
_ => fail ~"badly-structured parse result"
}
}
},
_ => fail ~"badly-structured parse result"
};

8
src/libsyntax/ext/concat_idents.rs
View file

@ -3,14 +3,16 @@ import base::*;
fn expand_syntax_ext(cx: ext_ctxt, sp: codemap::span, arg: ast::mac_arg,
_body: ast::mac_body) -> @ast::expr {
let args = get_mac_args_no_max(cx,sp,arg,1u,~"concat_idents");
let mut res = ~"";
let mut res_str = ~"";
for args.each |e| {
res += *expr_to_ident(cx, e, ~"expected an ident");
res_str += *cx.parse_sess().interner.get(
expr_to_ident(cx, e, ~"expected an ident"));
}
let res = cx.parse_sess().interner.intern(@res_str);
return @{id: cx.next_id(),
callee_id: cx.next_id(),
node: ast::expr_path(@{span: sp, global: false, idents: ~[@res],
node: ast::expr_path(@{span: sp, global: false, idents: ~[res],
rp: none, types: ~[]}),
span: sp};
}

16
src/libsyntax/ext/expand.rs
View file

@ -25,7 +25,9 @@ fn expand_expr(exts: hashmap<~str, syntax_extension>, cx: ext_ctxt,
match mac.node {
mac_invoc(pth, args, body) => {
assert (vec::len(pth.idents) > 0u);
let extname = pth.idents[0];
/* using idents and token::special_idents would make the
the macro names be hygienic */
let extname = cx.parse_sess().interner.get(pth.idents[0]);
match exts.find(*extname) {
none => {
cx.span_fatal(pth.span,
@ -49,7 +51,7 @@ fn expand_expr(exts: hashmap<~str, syntax_extension>, cx: ext_ctxt,
}
some(macro_defining(ext)) => {
let named_extension = ext(cx, mac.span, args, body);
exts.insert(*named_extension.ident, named_extension.ext);
exts.insert(named_extension.name, named_extension.ext);
(ast::expr_rec(~[], none), s)
}
some(expr_tt(_)) => {
@ -68,7 +70,9 @@ fn expand_expr(exts: hashmap<~str, syntax_extension>, cx: ext_ctxt,
// finished transitioning.
mac_invoc_tt(pth, tts) => {
assert (vec::len(pth.idents) == 1u);
let extname = pth.idents[0];
/* using idents and token::special_idents would make the
the macro names be hygienic */
let extname = cx.parse_sess().interner.get(pth.idents[0]);
match exts.find(*extname) {
none => {
cx.span_fatal(pth.span,
@ -146,7 +150,7 @@ fn expand_mod_items(exts: hashmap<~str, syntax_extension>, cx: ext_ctxt,
ast::meta_name_value(n, _) => n,
ast::meta_list(n, _) => n
};
match exts.find(*mname) {
match exts.find(mname) {
none | some(normal(_)) | some(macro_defining(_))
| some(expr_tt(_)) | some(item_tt(*)) => items,
some(item_decorator(dec_fn)) => {
@ -194,7 +198,7 @@ fn expand_item_mac(exts: hashmap<~str, syntax_extension>,
fld: ast_fold) -> option<@ast::item> {
match it.node {
item_mac({node: mac_invoc_tt(pth, tts), span}) => {
let extname = pth.idents[0];
let extname = cx.parse_sess().interner.get(pth.idents[0]);
match exts.find(*extname) {
none => {
cx.span_fatal(pth.span,
@ -211,7 +215,7 @@ fn expand_item_mac(exts: hashmap<~str, syntax_extension>,
~"expr macro in item position: " +
*extname),
mr_def(mdef) => {
exts.insert(*mdef.ident, mdef.ext);
exts.insert(mdef.name, mdef.ext);
none
}
};

26
src/libsyntax/ext/fmt.rs
View file

@ -37,12 +37,13 @@ fn expand_syntax_ext(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
fn pieces_to_expr(cx: ext_ctxt, sp: span,
pieces: ~[piece], args: ~[@ast::expr])
-> @ast::expr {
fn make_path_vec(_cx: ext_ctxt, ident: ast::ident) -> ~[ast::ident] {
return ~[@~"extfmt", @~"rt", ident];
fn make_path_vec(_cx: ext_ctxt, ident: @~str) -> ~[ast::ident] {
let intr = _cx.parse_sess().interner;
return ~[intr.intern(@~"extfmt"), intr.intern(@~"rt"),
intr.intern(ident)];
}
fn make_rt_path_expr(cx: ext_ctxt, sp: span,
ident: ast::ident) -> @ast::expr {
let path = make_path_vec(cx, ident);
fn make_rt_path_expr(cx: ext_ctxt, sp: span, nm: @~str) -> @ast::expr {
let path = make_path_vec(cx, nm);
return mk_path(cx, sp, path);
}
// Produces an AST expression that represents a RT::conv record,
@ -94,11 +95,13 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span,
fn make_conv_rec(cx: ext_ctxt, sp: span, flags_expr: @ast::expr,
width_expr: @ast::expr, precision_expr: @ast::expr,
ty_expr: @ast::expr) -> @ast::expr {
let intr = cx.parse_sess().interner;
return mk_rec_e(cx, sp,
~[{ident: @~"flags", ex: flags_expr},
{ident: @~"width", ex: width_expr},
{ident: @~"precision", ex: precision_expr},
{ident: @~"ty", ex: ty_expr}]);
~[{ident: intr.intern(@~"flags"), ex: flags_expr},
{ident: intr.intern(@~"width"), ex: width_expr},
{ident: intr.intern(@~"precision"),
ex: precision_expr},
{ident: intr.intern(@~"ty"), ex: ty_expr}]);
}
let rt_conv_flags = make_flags(cx, sp, cnv.flags);
let rt_conv_width = make_count(cx, sp, cnv.width);
@ -268,7 +271,10 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span,
}
let arg_vec = mk_fixed_vec_e(cx, fmt_sp, piece_exprs);
return mk_call(cx, fmt_sp, ~[@~"str", @~"concat"], ~[arg_vec]);
return mk_call(cx, fmt_sp,
~[cx.parse_sess().interner.intern(@~"str"),
cx.parse_sess().interner.intern(@~"concat")],
~[arg_vec]);
}
//
// Local Variables:

4
src/libsyntax/ext/ident_to_str.rs
View file

@ -6,6 +6,6 @@ fn expand_syntax_ext(cx: ext_ctxt, sp: codemap::span, arg: ast::mac_arg,
_body: ast::mac_body) -> @ast::expr {
let args = get_mac_args(cx,sp,arg,1u,option::some(1u),~"ident_to_str");
return mk_uniq_str(cx, sp, *expr_to_ident(cx, args[0u],
~"expected an ident"));
return mk_uniq_str(cx, sp, *cx.parse_sess().interner.get(
expr_to_ident(cx, args[0u], ~"expected an ident")));
}

3
src/libsyntax/ext/log_syntax.rs
View file

@ -6,8 +6,7 @@ fn expand_syntax_ext(cx: ext_ctxt, sp: codemap::span, tt: ~[ast::token_tree])
cx.print_backtrace();
io::stdout().write_line(
print::pprust::unexpanded_tt_to_str(ast::tt_delim(tt),
cx.parse_sess().interner));
print::pprust::tt_to_str(ast::tt_delim(tt),cx.parse_sess().interner));
//trivial expression
return mr_expr(@{id: cx.next_id(), callee_id: cx.next_id(),

2
src/libsyntax/ext/pipes.rs
View file

@ -54,7 +54,7 @@ fn expand_proto(cx: ext_ctxt, _sp: span, id: ast::ident,
let rdr = tt_rdr as reader;
let rust_parser = parser(sess, cfg, rdr.dup(), SOURCE_FILE);
let proto = rust_parser.parse_proto(id);
let proto = rust_parser.parse_proto(cx.str_of(id));
// check for errors
visit(proto, cx);

15
src/libsyntax/ext/pipes/ast_builder.rs
View file

@ -15,14 +15,10 @@ mod syntax {
export parse;
}
fn ident(s: &str) -> ast::ident {
@(s.to_unique())
}
fn path(id: ident, span: span) -> @ast::path {
fn path(ids: ~[ident], span: span) -> @ast::path {
@{span: span,
global: false,
idents: ~[id],
idents: ids,
rp: none,
types: ~[]}
}
@ -94,7 +90,8 @@ trait ext_ctxt_ast_builder {
impl ext_ctxt: ext_ctxt_ast_builder {
fn ty_option(ty: @ast::ty) -> @ast::ty {
self.ty_path_ast_builder(path(@~"option", self.empty_span())
self.ty_path_ast_builder(path(~[self.ident_of(~"option")],
self.empty_span())
.add_ty(ty))
}
@ -126,7 +123,7 @@ impl ext_ctxt: ext_ctxt_ast_builder {
ty: self.ty_infer(),
pat: @{id: self.next_id(),
node: ast::pat_ident(ast::bind_by_implicit_ref,
path(ident,
path(~[ident],
self.empty_span()),
none),
span: self.empty_span()},
@ -301,6 +298,6 @@ impl ext_ctxt: ext_ctxt_ast_builder {
fn ty_vars(+ty_params: ~[ast::ty_param]) -> ~[@ast::ty] {
ty_params.map(|p| self.ty_path_ast_builder(
path(p.ident, self.empty_span())))
path(~[p.ident], self.empty_span())))
}
}

10
src/libsyntax/ext/pipes/check.rs
View file

@ -21,8 +21,6 @@ that.
import ext::base::ext_ctxt;
import ast::{ident};
import proto::{state, protocol, next_state};
import ast_builder::empty_span;
@ -36,11 +34,11 @@ impl ext_ctxt: proto::visitor<(), (), ()> {
state.span, // use a real span!
fmt!{"state %s contains no messages, \
consider stepping to a terminal state instead",
*state.name})
state.name})
}
}
fn visit_message(name: ident, _span: span, _tys: &[@ast::ty],
fn visit_message(name: ~str, _span: span, _tys: &[@ast::ty],
this: state, next: next_state) {
match next {
some({state: next, tys: next_tys}) => {
@ -51,7 +49,7 @@ impl ext_ctxt: proto::visitor<(), (), ()> {
self.span_err(
proto.get_state(next).span,
fmt!{"message %s steps to undefined state, %s",
*name, *next});
name, next});
}
else {
let next = proto.get_state(next);
@ -61,7 +59,7 @@ impl ext_ctxt: proto::visitor<(), (), ()> {
next.span, // use a real span
fmt!{"message %s target (%s) \
needs %u type parameters, but got %u",
*name, *next.name,
name, next.name,
next.ty_params.len(),
next_tys.len()});
}

6
src/libsyntax/ext/pipes/liveness.rs
View file

@ -70,10 +70,10 @@ fn analyze(proto: protocol, _cx: ext_ctxt) {
}
if self_live.len() > 0 {
let states = str::connect(self_live.map(|s| *s.name), ~" ");
let states = str::connect(self_live.map(|s| s.name), ~" ");
debug!{"protocol %s is unbounded due to loops involving: %s",
*proto.name, states};
proto.name, states};
// Someday this will be configurable with a warning
//cx.span_warn(empty_span(),
@ -85,7 +85,7 @@ fn analyze(proto: protocol, _cx: ext_ctxt) {
proto.bounded = some(false);
}
else {
debug!{"protocol %s is bounded. yay!", *proto.name};
debug!{"protocol %s is bounded. yay!", proto.name};
proto.bounded = some(true);
}
}

15
src/libsyntax/ext/pipes/parse_proto.rs
View file

@ -1,18 +1,17 @@
// Parsing pipes protocols from token trees.
import parse::parser;
import ast::ident;
import parse::token;
import pipec::*;
trait proto_parser {
fn parse_proto(id: ident) -> protocol;
fn parse_proto(id: ~str) -> protocol;
fn parse_state(proto: protocol);
}
impl parser: proto_parser {
fn parse_proto(id: ident) -> protocol {
fn parse_proto(id: ~str) -> protocol {
let proto = protocol(id, self.span);
self.parse_seq_to_before_end(token::EOF,
@ -24,9 +23,11 @@ impl parser: proto_parser {
fn parse_state(proto: protocol) {
let id = self.parse_ident();
let name = *self.interner.get(id);
self.expect(token::COLON);
let dir = match copy self.token {
token::IDENT(n, _) => self.get_str(n),
token::IDENT(n, _) => self.interner.get(n),
_ => fail
};
self.bump();
@ -41,7 +42,7 @@ impl parser: proto_parser {
}
else { ~[] };
let state = proto.add_state_poly(id, dir, typarms);
let state = proto.add_state_poly(name, id, dir, typarms);
// parse the messages
self.parse_unspanned_seq(
@ -51,7 +52,7 @@ impl parser: proto_parser {
}
fn parse_message(state: state) {
let mname = self.parse_ident();
let mname = *self.interner.get(self.parse_ident());
let args = if self.token == token::LPAREN {
self.parse_unspanned_seq(token::LPAREN,
@ -66,7 +67,7 @@ impl parser: proto_parser {
let next = match copy self.token {
token::IDENT(_, _) => {
let name = self.parse_ident();
let name = *self.interner.get(self.parse_ident());
let ntys = if self.token == token::LT {
self.parse_unspanned_seq(token::LT,
token::GT,

140
src/libsyntax/ext/pipes/pipec.rs
View file

@ -13,8 +13,7 @@ import parse;
import parse::*;
import proto::*;
import ast_builder::append_types;
import ast_builder::path;
import ast_builder::{append_types, path, empty_span};
// Transitional reexports so qquote can find the paths it is looking for
mod syntax {
@ -47,17 +46,17 @@ impl message: gen_send {
debug!("pipec: next state exists");
let next = this.proto.get_state(next);
assert next_tys.len() == next.ty_params.len();
let arg_names = tys.mapi(|i, _ty| @(~"x_" + i.to_str()));
let arg_names = tys.mapi(|i, _ty| cx.ident_of(~"x_"+i.to_str()));
let args_ast = (arg_names, tys).map(
|n, t| cx.arg_mode(n, t, ast::by_copy)
);
let pipe_ty = cx.ty_path_ast_builder(
path(this.data_name(), span)
path(~[this.data_name()], span)
.add_tys(cx.ty_vars(this.ty_params)));
let args_ast = vec::append(
~[cx.arg_mode(@~"pipe",
~[cx.arg_mode(cx.ident_of(~"pipe"),
pipe_ty,
ast::by_copy)],
args_ast);
@ -75,10 +74,10 @@ impl message: gen_send {
body += ~"let b = pipe.reuse_buffer();\n";
body += fmt!("let %s = pipes::send_packet_buffered(\
ptr::addr_of(b.buffer.data.%s));\n",
sp, *next.name);
body += fmt!("let %s = pipes::recv_packet_buffered(\
sp, next.name);
body += fmt!{"let %s = pipes::recv_packet_buffered(\
ptr::addr_of(b.buffer.data.%s));\n",
rp, *next.name);
rp, next.name};
}
else {
let pat = match (this.dir, next.dir) {
@ -91,10 +90,10 @@ impl message: gen_send {
body += fmt!("let %s = pipes::entangle();\n", pat);
}
body += fmt!("let message = %s::%s(%s);\n",
*this.proto.name,
*self.name(),
str::connect(vec::append_one(arg_names, @~"s")
.map(|x| *x),
this.proto.name,
self.name(),
str::connect(vec::append_one(
arg_names.map(|x| cx.str_of(x)), ~"s"),
~", "));
if !try {
@ -110,17 +109,15 @@ impl message: gen_send {
let body = cx.parse_expr(body);
let mut rty = cx.ty_path_ast_builder(path(next.data_name(),
let mut rty = cx.ty_path_ast_builder(path(~[next.data_name()],
span)
.add_tys(next_tys));
if try {
rty = cx.ty_option(rty);
}
let name = if try {
@(~"try_" + *self.name())
}
else { self.name() };
let name = cx.ident_of(if try { ~"try_" + self.name()
} else { self.name() } );
cx.item_fn_poly(name,
args_ast,
@ -131,16 +128,16 @@ impl message: gen_send {
message(id, span, tys, this, none) => {
debug!{"pipec: no next state"};
let arg_names = tys.mapi(|i, _ty| @(~"x_" + i.to_str()));
let arg_names = tys.mapi(|i, _ty| (~"x_" + i.to_str()));
let args_ast = (arg_names, tys).map(
|n, t| cx.arg_mode(n, t, ast::by_copy)
|n, t| cx.arg_mode(cx.ident_of(n), t, ast::by_copy)
);
let args_ast = vec::append(
~[cx.arg_mode(@~"pipe",
~[cx.arg_mode(cx.ident_of(~"pipe"),
cx.ty_path_ast_builder(
path(this.data_name(), span)
path(~[this.data_name()], span)
.add_tys(cx.ty_vars(this.ty_params))),
ast::by_copy)],
args_ast);
@ -149,13 +146,13 @@ impl message: gen_send {
~""
}
else {
~"(" + str::connect(arg_names.map(|x| *x), ~", ") + ~")"
~"(" + str::connect(arg_names, ~", ") + ~")"
};
let mut body = ~"{ ";
body += fmt!{"let message = %s::%s%s;\n",
*this.proto.name,
*self.name(),
this.proto.name,
self.name(),
message_args};
if !try {
@ -170,11 +167,11 @@ impl message: gen_send {
let body = cx.parse_expr(body);
let name = if try {
@(~"try_" + *self.name())
~"try_" + self.name()
}
else { self.name() };
cx.item_fn_poly(name,
cx.item_fn_poly(cx.ident_of(name),
args_ast,
if try {
cx.ty_option(cx.ty_nil_ast_builder())
@ -188,7 +185,7 @@ impl message: gen_send {
}
fn to_ty(cx: ext_ctxt) -> @ast::ty {
cx.ty_path_ast_builder(path(self.name(), self.span())
cx.ty_path_ast_builder(path(~[cx.ident_of(self.name())], self.span())
.add_tys(cx.ty_vars(self.get_params())))
}
}
@ -212,21 +209,23 @@ impl state: to_type_decls {
let tys = match next {
some({state: next, tys: next_tys}) => {
let next = this.proto.get_state(next);
let next_name = next.data_name();
let next_name = cx.str_of(next.data_name());
let dir = match this.dir {
send => @~"server",
recv => @~"client"
send => ~"server",
recv => ~"client"
};
vec::append_one(tys,
cx.ty_path_ast_builder((dir + next_name)
cx.ty_path_ast_builder(
path(~[cx.ident_of(dir),
cx.ident_of(next_name)], span)
.add_tys(next_tys)))
}
none => tys
};
let v = cx.variant(name, span, tys);
let v = cx.variant(cx.ident_of(name), span, tys);
vec::push(items_msg, v);
}
@ -258,9 +257,13 @@ impl state: to_type_decls {
self.data_name(),
self.span,
cx.ty_path_ast_builder(
(@~"pipes" + @(dir.to_str() + ~"_packet"))
path(~[cx.ident_of(~"pipes"),
cx.ident_of(dir.to_str() + ~"_packet")],
empty_span())
.add_ty(cx.ty_path_ast_builder(
(self.proto.name + self.data_name())
path(~[cx.ident_of(self.proto.name),
self.data_name()],
empty_span())
.add_tys(cx.ty_vars(self.ty_params))))),
self.ty_params));
}
@ -270,10 +273,14 @@ impl state: to_type_decls {
self.data_name(),
self.span,
cx.ty_path_ast_builder(
(@~"pipes" + @(dir.to_str()
+ ~"_packet_buffered"))
path(~[cx.ident_of(~"pipes"),
cx.ident_of(dir.to_str()
+ ~"_packet_buffered")],
empty_span())
.add_tys(~[cx.ty_path_ast_builder(
(self.proto.name + self.data_name())
path(~[cx.ident_of(self.proto.name),
self.data_name()],
empty_span())
.add_tys(cx.ty_vars(self.ty_params))),
self.proto.buffer_ty_path(cx)])),
self.ty_params));
@ -315,16 +322,17 @@ impl protocol: gen_init {
cx.parse_item(fmt!{"fn init%s() -> (client::%s, server::%s)\
{ import pipes::has_buffer; %s }",
start_state.ty_params.to_source(),
start_state.to_ty(cx).to_source(),
start_state.to_ty(cx).to_source(),
body.to_source()})
start_state.ty_params.to_source(cx),
start_state.to_ty(cx).to_source(cx),
start_state.to_ty(cx).to_source(cx),
body.to_source(cx)})
}
fn gen_buffer_init(ext_cx: ext_ctxt) -> @ast::expr {
ext_cx.rec(self.states.map_to_vec(|s| {
let fty = s.to_ty(ext_cx);
ext_cx.field_imm(s.name, #ast { pipes::mk_packet::<$(fty)>() })
ext_cx.field_imm(ext_cx.ident_of(s.name),
#ast { pipes::mk_packet::<$(fty)>() })
}))
}
@ -341,9 +349,11 @@ impl protocol: gen_init {
ext_cx.block(
self.states.map_to_vec(
|s| ext_cx.parse_stmt(
fmt!{"data.%s.set_buffer(buffer)", *s.name})),
fmt!{"data.%s.set_buffer(buffer)",
s.name})),
ext_cx.parse_expr(
fmt!{"ptr::addr_of(data.%s)", *self.states[0].name})));
fmt!{"ptr::addr_of(data.%s)",
self.states[0].name})));
#ast {{
let buffer = $(buffer);
@ -357,14 +367,14 @@ impl protocol: gen_init {
let mut params: ~[ast::ty_param] = ~[];
for (copy self.states).each |s| {
for s.ty_params.each |tp| {
match params.find(|tpp| *tp.ident == *tpp.ident) {
match params.find(|tpp| tp.ident == tpp.ident) {
none => vec::push(params, tp),
_ => ()
}
}
}
cx.ty_path_ast_builder(path(@~"__Buffer", self.span)
cx.ty_path_ast_builder(path(~[cx.ident_of(~"__Buffer")], self.span)
.add_tys(cx.ty_vars(params)))
}
@ -373,7 +383,7 @@ impl protocol: gen_init {
let mut params: ~[ast::ty_param] = ~[];
let fields = do (copy self.states).map_to_vec |s| {
for s.ty_params.each |tp| {
match params.find(|tpp| *tp.ident == *tpp.ident) {
match params.find(|tpp| tp.ident == tpp.ident) {
none => vec::push(params, tp),
_ => ()
}
@ -382,11 +392,11 @@ impl protocol: gen_init {
let fty = #ast[ty] {
pipes::packet<$(ty)>
};
cx.ty_field_imm(s.name, fty)
cx.ty_field_imm(cx.ident_of(s.name), fty)
};
cx.item_ty_poly(
@~"__Buffer",
cx.ident_of(~"__Buffer"),
cx.empty_span(),
cx.ty_rec(fields),
params)
@ -410,56 +420,56 @@ impl protocol: gen_init {
}
vec::push(items,
cx.item_mod(@~"client",
cx.item_mod(cx.ident_of(~"client"),
self.span,
client_states));
vec::push(items,
cx.item_mod(@~"server",
cx.item_mod(cx.ident_of(~"server"),
self.span,
server_states));
cx.item_mod(self.name, self.span, items)
cx.item_mod(cx.ident_of(self.name), self.span, items)
}
}
trait to_source {
// Takes a thing and generates a string containing rust code for it.
fn to_source() -> ~str;
fn to_source(cx: ext_ctxt) -> ~str;
}
impl @ast::item: to_source {
fn to_source() -> ~str {
item_to_str(self)
fn to_source(cx: ext_ctxt) -> ~str {
item_to_str(self, cx.parse_sess().interner)
}
}
impl ~[@ast::item]: to_source {
fn to_source() -> ~str {
str::connect(self.map(|i| i.to_source()), ~"\n\n")
fn to_source(cx: ext_ctxt) -> ~str {
str::connect(self.map(|i| i.to_source(cx)), ~"\n\n")
}
}
impl @ast::ty: to_source {
fn to_source() -> ~str {
ty_to_str(self)
fn to_source(cx: ext_ctxt) -> ~str {
ty_to_str(self, cx.parse_sess().interner)
}
}
impl ~[@ast::ty]: to_source {
fn to_source() -> ~str {
str::connect(self.map(|i| i.to_source()), ~", ")
fn to_source(cx: ext_ctxt) -> ~str {
str::connect(self.map(|i| i.to_source(cx)), ~", ")
}
}
impl ~[ast::ty_param]: to_source {
fn to_source() -> ~str {
pprust::typarams_to_str(self)
fn to_source(cx: ext_ctxt) -> ~str {
pprust::typarams_to_str(self, cx.parse_sess().interner)
}
}
impl @ast::expr: to_source {
fn to_source() -> ~str {
pprust::expr_to_str(self)
fn to_source(cx: ext_ctxt) -> ~str {
pprust::expr_to_str(self, cx.parse_sess().interner)
}
}

41
src/libsyntax/ext/pipes/proto.rs
View file

@ -1,8 +1,6 @@
import to_str::ToStr;
import dvec::{DVec, dvec};
import ast::{ident};
import ast_builder::{path, append_types};
enum direction {
@ -27,15 +25,15 @@ impl direction {
}
}
type next_state = option<{state: ident, tys: ~[@ast::ty]}>;
type next_state = option<{state: ~str, tys: ~[@ast::ty]}>;
enum message {
// name, span, data, current state, next state
message(ident, span, ~[@ast::ty], state, next_state)
message(~str, span, ~[@ast::ty], state, next_state)
}
impl message {
fn name() -> ident {
fn name() -> ~str {
match self {
message(id, _, _, _, _) => id
}
@ -58,7 +56,8 @@ impl message {
enum state {
state_(@{
id: uint,
name: ident,
name: ~str,
ident: ast::ident,
span: span,
dir: direction,
ty_params: ~[ast::ty_param],
@ -68,7 +67,7 @@ enum state {
}
impl state {
fn add_message(name: ident, span: span,
fn add_message(name: ~str, span: span,
+data: ~[@ast::ty], next: next_state) {
self.messages.push(message(name, span, data, self,
next));
@ -78,14 +77,15 @@ impl state {
(*self).proto.filename()
}
fn data_name() -> ident {
self.name
fn data_name() -> ast::ident {
self.ident
}
/// Returns the type that is used for the messages.
fn to_ty(cx: ext_ctxt) -> @ast::ty {
cx.ty_path_ast_builder
(path(self.name, self.span).add_tys(cx.ty_vars(self.ty_params)))
(path(~[cx.ident_of(self.name)],self.span).add_tys(
cx.ty_vars(self.ty_params)))
}
/// Iterate over the states that can be reached in one message
@ -105,18 +105,18 @@ impl state {
type protocol = @protocol_;
fn protocol(name: ident, +span: span) -> protocol {
fn protocol(name: ~str, +span: span) -> protocol {
@protocol_(name, span)
}
struct protocol_ {
let name: ident;
let name: ~str;
let span: span;
let states: DVec<state>;
let mut bounded: option<bool>;
new(name: ident, span: span) {
new(name: ~str, span: span) {
self.name = name;
self.span = span;
self.states = dvec();
@ -124,18 +124,18 @@ struct protocol_ {
}
/// Get a state.
fn get_state(name: ident) -> state {
fn get_state(name: ~str) -> state {
self.states.find(|i| i.name == name).get()
}
fn get_state_by_id(id: uint) -> state { self.states[id] }
fn has_state(name: ident) -> bool {
fn has_state(name: ~str) -> bool {
self.states.find(|i| i.name == name) != none
}
fn filename() -> ~str {
~"proto://" + *self.name
~"proto://" + self.name
}
fn num_states() -> uint { self.states.len() }
@ -162,17 +162,14 @@ struct protocol_ {
}
impl protocol {
fn add_state(name: ident, dir: direction) -> state {
self.add_state_poly(name, dir, ~[])
}
fn add_state_poly(name: ident, dir: direction,
fn add_state_poly(name: ~str, ident: ast::ident, dir: direction,
+ty_params: ~[ast::ty_param]) -> state {
let messages = dvec();
let state = state_(@{
id: self.states.len(),
name: name,
ident: ident,
span: self.span,
dir: dir,
ty_params: ty_params,
@ -188,7 +185,7 @@ impl protocol {
trait visitor<Tproto, Tstate, Tmessage> {
fn visit_proto(proto: protocol, st: &[Tstate]) -> Tproto;
fn visit_state(state: state, m: &[Tmessage]) -> Tstate;
fn visit_message(name: ident, spane: span, tys: &[@ast::ty],
fn visit_message(name: ~str, spane: span, tys: &[@ast::ty],
this: state, next: next_state) -> Tmessage;
}

57
src/libsyntax/ext/qquote.rs
View file

@ -3,6 +3,7 @@ import ast::{crate, expr_, mac_invoc,
import parse::parser;
import parse::parser::parse_from_source_str;
import dvec::{DVec, dvec};
import parse::token::ident_interner;
import fold::*;
import visit::*;
@ -26,6 +27,14 @@ enum fragment {
from_ty(@ast::ty)
}
fn ids_ext(cx: ext_ctxt, strs: ~[~str]) -> ~[ast::ident] {
strs.map(|str| cx.parse_sess().interner.intern(@str))
}
fn id_ext(cx: ext_ctxt, str: ~str) -> ast::ident {
cx.parse_sess().interner.intern(@str)
}
trait qq_helper {
fn span() -> span;
fn visit(aq_ctxt, vt<aq_ctxt>);
@ -40,7 +49,7 @@ impl @ast::crate: qq_helper {
fn extract_mac() -> option<ast::mac_> {fail}
fn mk_parse_fn(cx: ext_ctxt, sp: span) -> @ast::expr {
mk_path(cx, sp,
~[@~"syntax", @~"ext", @~"qquote", @~"parse_crate"])
ids_ext(cx, ~[~"syntax", ~"ext", ~"qquote", ~"parse_crate"]))
}
fn get_fold_fn() -> ~str {~"fold_crate"}
}
@ -55,7 +64,7 @@ impl @ast::expr: qq_helper {
}
fn mk_parse_fn(cx: ext_ctxt, sp: span) -> @ast::expr {
mk_path(cx, sp,
~[@~"syntax", @~"ext", @~"qquote", @~"parse_expr"])
ids_ext(cx, ~[~"syntax", ~"ext", ~"qquote", ~"parse_expr"]))
}
fn get_fold_fn() -> ~str {~"fold_expr"}
}
@ -70,7 +79,7 @@ impl @ast::ty: qq_helper {
}
fn mk_parse_fn(cx: ext_ctxt, sp: span) -> @ast::expr {
mk_path(cx, sp,
~[@~"syntax", @~"ext", @~"qquote", @~"parse_ty"])
ids_ext(cx, ~[~"syntax", ~"ext", ~"qquote", ~"parse_ty"]))
}
fn get_fold_fn() -> ~str {~"fold_ty"}
}
@ -80,7 +89,7 @@ impl @ast::item: qq_helper {
fn extract_mac() -> option<ast::mac_> {fail}
fn mk_parse_fn(cx: ext_ctxt, sp: span) -> @ast::expr {
mk_path(cx, sp,
~[@~"syntax", @~"ext", @~"qquote", @~"parse_item"])
ids_ext(cx, ~[~"syntax", ~"ext", ~"qquote", ~"parse_item"]))
}
fn get_fold_fn() -> ~str {~"fold_item"}
}
@ -90,7 +99,7 @@ impl @ast::stmt: qq_helper {
fn extract_mac() -> option<ast::mac_> {fail}
fn mk_parse_fn(cx: ext_ctxt, sp: span) -> @ast::expr {
mk_path(cx, sp,
~[@~"syntax", @~"ext", @~"qquote", @~"parse_stmt"])
ids_ext(cx, ~[~"syntax", ~"ext", ~"qquote", ~"parse_stmt"]))
}
fn get_fold_fn() -> ~str {~"fold_stmt"}
}
@ -99,7 +108,8 @@ impl @ast::pat: qq_helper {
fn visit(cx: aq_ctxt, v: vt<aq_ctxt>) {visit_pat(self, cx, v);}
fn extract_mac() -> option<ast::mac_> {fail}
fn mk_parse_fn(cx: ext_ctxt, sp: span) -> @ast::expr {
mk_path(cx, sp, ~[@~"syntax", @~"ext", @~"qquote", @~"parse_pat"])
mk_path(cx, sp, ids_ext(cx, ~[~"syntax", ~"ext", ~"qquote",
~"parse_pat"]))
}
fn get_fold_fn() -> ~str {~"fold_pat"}
}
@ -159,7 +169,7 @@ fn expand_ast(ecx: ext_ctxt, _sp: span,
}
match (args[0].node) {
ast::expr_path(@{idents: id, _}) if vec::len(id) == 1u
=> what = *id[0],
=> what = *ecx.parse_sess().interner.get(id[0]),
_ => ecx.span_fatal(args[0].span, ~"expected an identifier")
}
}
@ -243,19 +253,21 @@ fn finish<T: qq_helper>
let cx = ecx;
let cfg_call = || mk_call_(
cx, sp, mk_access(cx, sp, ~[@~"ext_cx"], @~"cfg"), ~[]);
cx, sp, mk_access(cx, sp, ids_ext(cx, ~[~"ext_cx"]),
id_ext(cx, ~"cfg")), ~[]);
let parse_sess_call = || mk_call_(
cx, sp, mk_access(cx, sp, ~[@~"ext_cx"], @~"parse_sess"), ~[]);
cx, sp, mk_access(cx, sp, ids_ext(cx, ~[~"ext_cx"]),
id_ext(cx, ~"parse_sess")), ~[]);
let pcall = mk_call(cx,sp,
~[@~"syntax", @~"parse", @~"parser",
@~"parse_from_source_str"],
ids_ext(cx, ~[~"syntax", ~"parse", ~"parser",
~"parse_from_source_str"]),
~[node.mk_parse_fn(cx,sp),
mk_uniq_str(cx,sp, fname),
mk_call(cx,sp,
~[@~"syntax",@~"ext",
@~"qquote", @~"mk_file_substr"],
ids_ext(cx, ~[~"syntax",~"ext",
~"qquote", ~"mk_file_substr"]),
~[mk_uniq_str(cx,sp, loc.file.name),
mk_uint(cx,sp, loc.line),
mk_uint(cx,sp, loc.col)]),
@ -267,16 +279,17 @@ fn finish<T: qq_helper>
let mut rcall = pcall;
if (g_len > 0u) {
rcall = mk_call(cx,sp,
~[@~"syntax", @~"ext", @~"qquote", @~"replace"],
ids_ext(cx, ~[~"syntax", ~"ext", ~"qquote",
~"replace"]),
~[pcall,
mk_uniq_vec_e(cx,sp, qcx.gather.map_to_vec(|g| {
mk_call(cx,sp,
~[@~"syntax", @~"ext",
@~"qquote", @g.constr],
ids_ext(cx, ~[~"syntax", ~"ext",
~"qquote", g.constr]),
~[g.e])})),
mk_path(cx,sp,
~[@~"syntax", @~"ext", @~"qquote",
@node.get_fold_fn()])]);
ids_ext(cx, ~[~"syntax", ~"ext", ~"qquote",
node.get_fold_fn()]))]);
}
return rcall;
}
@ -331,14 +344,6 @@ fn replace_ty(repls: ~[fragment],
}
}
fn print_expr(expr: @ast::expr) {
let stdout = io::stdout();
let pp = pprust::rust_printer(stdout);
pprust::print_expr(pp, expr);
pp::eof(pp.s);
stdout.write_str(~"\n");
}
fn mk_file_substr(fname: ~str, line: uint, col: uint) ->
codemap::file_substr {
codemap::fss_external({filename: fname, line: line, col: col})

33
src/libsyntax/ext/simplext.rs
View file

@ -1,5 +1,5 @@
import codemap::span;
import std::map::{hashmap, str_hash, box_str_hash};
import std::map::{hashmap, str_hash, uint_hash};
import dvec::{DVec, dvec};
import base::*;
@ -135,7 +135,7 @@ fn acumm_bindings(_cx: ext_ctxt, _b_dest: bindings, _b_src: bindings) { }
fn pattern_to_selectors(cx: ext_ctxt, e: @expr) -> binders {
let res: binders =
{real_binders: box_str_hash::<selector>(),
{real_binders: uint_hash::<selector>(),
literal_ast_matchers: dvec()};
//this oughta return binders instead, but macro args are a sequence of
//expressions, rather than a single expression
@ -153,7 +153,7 @@ bindings. Most of the work is done in p_t_s, which generates the
selectors. */
fn use_selectors_to_bind(b: binders, e: @expr) -> option<bindings> {
let res = box_str_hash::<arb_depth<matchable>>();
let res = uint_hash::<arb_depth<matchable>>();
//need to do this first, to check vec lengths.
for b.literal_ast_matchers.each |sel| {
match sel(match_expr(e)) { none => return none, _ => () }
@ -237,7 +237,7 @@ fn follow_for_trans(cx: ext_ctxt, mmaybe: option<arb_depth<matchable>>,
/* helper for transcribe_exprs: what vars from `b` occur in `e`? */
fn free_vars(b: bindings, e: @expr, it: fn(ident)) {
let idents: hashmap<ident, ()> = box_str_hash::<()>();
let idents: hashmap<ident, ()> = uint_hash::<()>();
fn mark_ident(&&i: ident, _fld: ast_fold, b: bindings,
idents: hashmap<ident, ()>) -> ident {
if b.contains_key(i) { idents.insert(i, ()); }
@ -253,6 +253,12 @@ fn free_vars(b: bindings, e: @expr, it: fn(ident)) {
for idents.each_key |x| { it(x); };
}
fn wrong_occurs(cx: ext_ctxt, l: ident, l_c: uint, r: ident, r_c: uint)
-> ~str {
fmt!{"'%s' occurs %u times, but '%s' occurs %u times",
*cx.parse_sess().interner.get(l), l_c,
*cx.parse_sess().interner.get(r), r_c}
}
/* handle sequences (anywhere in the AST) of exprs, either real or ...ed */
fn transcribe_exprs(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint],
@ -279,10 +285,8 @@ fn transcribe_exprs(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint],
some({rep_count: old_len, name: old_name}) => {
let len = vec::len(*ms);
if old_len != len {
let msg =
fmt!{"'%s' occurs %u times, but ", *fv, len} +
fmt!{"'%s' occurs %u times", *old_name,
old_len};
let msg = wrong_occurs(cx, fv, len,
old_name, old_len);
cx.span_fatal(repeat_me.span, msg);
}
}
@ -626,7 +630,7 @@ fn add_new_extension(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
_body: ast::mac_body) -> base::macro_def {
let args = get_mac_args_no_max(cx, sp, arg, 0u, ~"macro");
let mut macro_name: option<@~str> = none;
let mut macro_name: option<~str> = none;
let mut clauses: ~[@clause] = ~[];
for args.each |arg| {
match arg.node {
@ -643,13 +647,16 @@ fn add_new_extension(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
match mac.node {
mac_invoc(pth, invoc_arg, body) => {
match path_to_ident(pth) {
some(id) => match macro_name {
none => macro_name = some(id),
some(other_id) => if id != other_id {
some(id) => {
let id_str = cx.str_of(id);
match macro_name {
none => macro_name = some(id_str),
some(other_id) => if id_str != other_id {
cx.span_fatal(pth.span,
~"macro name must be " +
~"consistent");
}
}
},
none => cx.span_fatal(pth.span,
~"macro name must not be a path")
@ -688,7 +695,7 @@ fn add_new_extension(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
let ext = |a,b,c,d, move clauses| generic_extension(a,b,c,d,clauses);
return {ident:
return {name:
match macro_name {
some(id) => id,
none => cx.span_fatal(sp, ~"macro definition must have " +

5
src/libsyntax/ext/source_util.rs
View file

@ -43,14 +43,15 @@ fn expand_file(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
fn expand_stringify(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
_body: ast::mac_body) -> @ast::expr {
let args = get_mac_args(cx, sp, arg, 1u, option::some(1u), ~"stringify");
return mk_uniq_str(cx, sp, pprust::expr_to_str(args[0]));
let s = pprust::expr_to_str(args[0], cx.parse_sess().interner);
return mk_uniq_str(cx, sp, s);
}
fn expand_mod(cx: ext_ctxt, sp: span, arg: ast::mac_arg, _body: ast::mac_body)
-> @ast::expr {
get_mac_args(cx, sp, arg, 0u, option::some(0u), ~"file");
return mk_uniq_str(cx, sp,
str::connect(cx.mod_path().map(|x|*x), ~"::"));
str::connect(cx.mod_path().map(|x| cx.str_of(x)), ~"::"));
}
fn expand_include(cx: ext_ctxt, sp: span, arg: ast::mac_arg,

6
src/libsyntax/ext/trace_macros.rs
View file

@ -15,10 +15,10 @@ fn expand_trace_macros(cx: ext_ctxt, sp: span,
let rdr = tt_rdr as reader;
let rust_parser = parser(sess, cfg, rdr.dup(), SOURCE_FILE);
let arg = rust_parser.parse_ident();
let arg = cx.str_of(rust_parser.parse_ident());
match arg {
@~"true" => cx.set_trace_macros(true),
@~"false" => cx.set_trace_macros(false),
~"true" => cx.set_trace_macros(true),
~"false" => cx.set_trace_macros(false),
_ => cx.span_fatal(sp, ~"trace_macros! only accepts `true` or `false`")
}
let rust_parser = parser(sess, cfg, rdr.dup(), SOURCE_FILE);

13
src/libsyntax/ext/tt/earley_parser.rs
View file

@ -10,7 +10,7 @@ import parse::parse_sess;
import dvec::{DVec, dvec};
import ast::{matcher, match_tok, match_seq, match_nonterminal, ident};
import ast_util::mk_sp;
import std::map::{hashmap, box_str_hash};
import std::map::{hashmap, uint_hash};
/* This is an Earley-like parser, without support for in-grammar nonterminals,
onlyl calling out to the main rust parser for named nonterminals (which it
@ -120,14 +120,14 @@ fn nameize(p_s: parse_sess, ms: ~[matcher], res: ~[@named_match])
}
{node: match_nonterminal(bind_name, _, idx), span: sp} => {
if ret_val.contains_key(bind_name) {
p_s.span_diagnostic.span_fatal(sp, ~"Duplicated bind name: "
+ *bind_name)
p_s.span_diagnostic.span_fatal(sp, ~"Duplicated bind name: "+
*p_s.interner.get(bind_name))
}
ret_val.insert(bind_name, res[idx]);
}
}
}
let ret_val = box_str_hash::<@named_match>();
let ret_val = uint_hash::<@named_match>();
for ms.each() |m| { n_rec(p_s, m, res, ret_val) }
return ret_val;
}
@ -274,7 +274,8 @@ fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher])
let nts = str::connect(vec::map(bb_eis, |ei| {
match ei.elts[ei.idx].node {
match_nonterminal(bind,name,_) => {
fmt!{"%s ('%s')", *name, *bind}
fmt!{"%s ('%s')", *sess.interner.get(name),
*sess.interner.get(bind)}
}
_ => fail
} }), ~" or ");
@ -298,7 +299,7 @@ fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher])
match ei.elts[ei.idx].node {
match_nonterminal(_, name, idx) => {
ei.matches[idx].push(@matched_nonterminal(
parse_nt(rust_parser, *name)));
parse_nt(rust_parser, *sess.interner.get(name))));
ei.idx += 1u;
}
_ => fail

19
src/libsyntax/ext/tt/macro_rules.rs
View file

@ -8,6 +8,7 @@ import parse::parser::{parser, SOURCE_FILE};
import earley_parser::{parse, parse_or_else, success, failure, named_match,
matched_seq, matched_nonterminal, error};
import std::map::hashmap;
import parse::token::special_idents;
fn add_new_extension(cx: ext_ctxt, sp: span, name: ident,
arg: ~[ast::token_tree]) -> base::mac_result {
@ -16,14 +17,17 @@ fn add_new_extension(cx: ext_ctxt, sp: span, name: ident,
{node: m, span: {lo: 0u, hi: 0u, expn_info: none}}
}
let lhs_nm = cx.parse_sess().interner.gensym(@~"lhs");
let rhs_nm = cx.parse_sess().interner.gensym(@~"rhs");
// The grammar for macro_rules! is:
// $( $lhs:mtcs => $rhs:tt );+
// ...quasiquoting this would be nice.
let argument_gram = ~[
ms(match_seq(~[
ms(match_nonterminal(@~"lhs",@~"matchers", 0u)),
ms(match_nonterminal(lhs_nm, special_idents::matchers, 0u)),
ms(match_tok(FAT_ARROW)),
ms(match_nonterminal(@~"rhs",@~"tt", 1u)),
ms(match_nonterminal(rhs_nm, special_idents::tt, 1u)),
], some(SEMI), false, 0u, 2u)),
//to phase into semicolon-termination instead of
//semicolon-separation
@ -37,11 +41,11 @@ fn add_new_extension(cx: ext_ctxt, sp: span, name: ident,
arg_reader as reader, argument_gram);
// Extract the arguments:
let lhses:~[@named_match] = match argument_map.get(@~"lhs") {
let lhses:~[@named_match] = match argument_map.get(lhs_nm) {
@matched_seq(s, sp) => s,
_ => cx.span_bug(sp, ~"wrong-structured lhs")
};
let rhses:~[@named_match] = match argument_map.get(@~"rhs") {
let rhses:~[@named_match] = match argument_map.get(rhs_nm) {
@matched_seq(s, sp) => s,
_ => cx.span_bug(sp, ~"wrong-structured rhs")
};
@ -53,8 +57,9 @@ fn add_new_extension(cx: ext_ctxt, sp: span, name: ident,
-> mac_result {
if cx.trace_macros() {
io::println(fmt!("%s! { %s }", *name,
print::pprust::unexpanded_tt_to_str(
io::println(fmt!("%s! { %s }",
cx.str_of(name),
print::pprust::tt_to_str(
ast::tt_delim(arg),
cx.parse_sess().interner)));
}
@ -103,7 +108,7 @@ fn add_new_extension(cx: ext_ctxt, sp: span, name: ident,
arg, lhses, rhses);
return mr_def({
ident: name,
name: *cx.parse_sess().interner.get(name),
ext: expr_tt({expander: exp, span: some(sp)})
});
}

14
src/libsyntax/ext/tt/transcribe.rs
View file

@ -47,7 +47,7 @@ fn new_tt_reader(sp_diag: span_handler, itr: ident_interner,
mut cur: @{readme: src, mut idx: 0u, dotdotdoted: false,
sep: none, up: tt_frame_up(option::none)},
interpolations: match interp { /* just a convienience */
none => std::map::box_str_hash::<@named_match>(),
none => std::map::uint_hash::<@named_match>(),
some(x) => x
},
mut repeat_idx: ~[mut], mut repeat_len: ~[],
@ -100,8 +100,8 @@ enum lis {
lis_unconstrained, lis_constraint(uint, ident), lis_contradiction(~str)
}
fn lockstep_iter_size(&&t: token_tree, &&r: tt_reader) -> lis {
fn lis_merge(lhs: lis, rhs: lis) -> lis {
fn lockstep_iter_size(t: token_tree, r: tt_reader) -> lis {
fn lis_merge(lhs: lis, rhs: lis, r: tt_reader) -> lis {
match lhs {
lis_unconstrained => rhs,
lis_contradiction(_) => lhs,
@ -110,9 +110,11 @@ fn lockstep_iter_size(&&t: token_tree, &&r: tt_reader) -> lis {
lis_contradiction(_) => rhs,
lis_constraint(r_len, _) if l_len == r_len => lhs,
lis_constraint(r_len, r_id) => {
let l_n = *r.interner.get(l_id);
let r_n = *r.interner.get(r_id);
lis_contradiction(fmt!{"Inconsistent lockstep iteration: \
'%s' has %u items, but '%s' has %u",
*l_id, l_len, *r_id, r_len})
l_n, l_len, r_n, r_len})
}
}
}
@ -120,7 +122,7 @@ fn lockstep_iter_size(&&t: token_tree, &&r: tt_reader) -> lis {
match t {
tt_delim(tts) | tt_seq(_, tts, _, _) => {
vec::foldl(lis_unconstrained, tts, {|lis, tt|
lis_merge(lis, lockstep_iter_size(tt, r)) })
lis_merge(lis, lockstep_iter_size(tt, r), r) })
}
tt_tok(*) => lis_unconstrained,
tt_nonterminal(_, name) => match *lookup_cur_matched(r, name) {
@ -230,7 +232,7 @@ fn tt_next_token(&&r: tt_reader) -> {tok: token, sp: span} {
r.sp_diag.span_fatal(
copy r.cur_span, /* blame the macro writer */
fmt!{"variable '%s' is still repeating at this depth",
*ident});
*r.interner.get(ident)});
}
}
}

5
src/libsyntax/fold.rs
View file

@ -81,15 +81,14 @@ type ast_fold_precursor = @{
fn fold_meta_item_(&&mi: @meta_item, fld: ast_fold) -> @meta_item {
return @{node:
match mi.node {
meta_word(id) => meta_word(fld.fold_ident(id)),
meta_word(id) => meta_word(id),
meta_list(id, mis) => {
let fold_meta_item = |x|fold_meta_item_(x, fld);
meta_list(/* FIXME: (#2543) */ copy id,
vec::map(mis, fold_meta_item))
}
meta_name_value(id, s) => {
meta_name_value(fld.fold_ident(id),
/* FIXME (#2543) */ copy s)
meta_name_value(id, /* FIXME (#2543) */ copy s)
}
},
span: fld.new_span(mi.span)};

12
src/libsyntax/parse/attr.rs
View file

@ -66,7 +66,7 @@ impl parser: parser_attr {
}
token::DOC_COMMENT(s) => {
let attr = ::attr::mk_sugared_doc_attr(
*self.get_str(s), self.span.lo, self.span.hi);
*self.id_to_str(s), self.span.lo, self.span.hi);
if attr.node.style != ast::attr_outer {
self.fatal(~"expected outer comment");
}
@ -128,7 +128,7 @@ impl parser: parser_attr {
}
token::DOC_COMMENT(s) => {
let attr = ::attr::mk_sugared_doc_attr(
*self.get_str(s), self.span.lo, self.span.hi);
*self.id_to_str(s), self.span.lo, self.span.hi);
self.bump();
if attr.node.style == ast::attr_inner {
inner_attrs += ~[attr];
@ -145,22 +145,22 @@ impl parser: parser_attr {
fn parse_meta_item() -> @ast::meta_item {
let lo = self.span.lo;
let ident = self.parse_ident();
let name = *self.id_to_str(self.parse_ident());
match self.token {
token::EQ => {
self.bump();
let lit = self.parse_lit();
let mut hi = self.span.hi;
return @spanned(lo, hi, ast::meta_name_value(ident, lit));
return @spanned(lo, hi, ast::meta_name_value(name, lit));
}
token::LPAREN => {
let inner_items = self.parse_meta_seq();
let mut hi = self.span.hi;
return @spanned(lo, hi, ast::meta_list(ident, inner_items));
return @spanned(lo, hi, ast::meta_list(name, inner_items));
}
_ => {
let mut hi = self.span.hi;
return @spanned(lo, hi, ast::meta_word(ident));
return @spanned(lo, hi, ast::meta_word(name));
}
}
}

2
src/libsyntax/parse/comments.rs
View file

@ -276,7 +276,7 @@ fn gather_comments_and_literals(span_diagnostic: diagnostic::span_handler,
srdr: io::Reader) ->
{cmnts: ~[cmnt], lits: ~[lit]} {
let src = @str::from_bytes(srdr.read_whole_stream());
let itr = parse::token::mk_ident_interner();
let itr = parse::token::mk_fake_ident_interner();
let rdr = lexer::new_low_level_string_reader
(span_diagnostic, codemap::new_filemap(path, src, 0u, 0u), itr);

10
src/libsyntax/parse/common.rs
View file

@ -85,7 +85,7 @@ impl parser: parser_common {
fn parse_ident() -> ast::ident {
match copy self.token {
token::IDENT(i, _) => { self.bump(); return self.get_str(i); }
token::IDENT(i, _) => { self.bump(); return i; }
token::INTERPOLATED(token::nt_ident(*)) => { self.bug(
~"ident interpolation not converted to real token"); }
_ => { self.fatal(~"expected ident, found `"
@ -110,6 +110,8 @@ impl parser: parser_common {
return if self.token == tok { self.bump(); true } else { false };
}
// Storing keywords as interned idents instead of strings would be nifty.
// A sanity check that the word we are asking for is a known keyword
fn require_keyword(word: ~str) {
if !self.keywords.contains_key_ref(&word) {
@ -119,7 +121,7 @@ impl parser: parser_common {
fn token_is_word(word: ~str, ++tok: token::token) -> bool {
match tok {
token::IDENT(sid, false) => { word == *self.get_str(sid) }
token::IDENT(sid, false) => { *self.id_to_str(sid) == word }
_ => { false }
}
}
@ -136,7 +138,7 @@ impl parser: parser_common {
fn is_any_keyword(tok: token::token) -> bool {
match tok {
token::IDENT(sid, false) => {
self.keywords.contains_key_ref(self.get_str(sid))
self.keywords.contains_key_ref(self.id_to_str(sid))
}
_ => false
}
@ -148,7 +150,7 @@ impl parser: parser_common {
let mut bump = false;
let val = match self.token {
token::IDENT(sid, false) => {
if word == *self.get_str(sid) {
if word == *self.id_to_str(sid) {
bump = true;
true
} else { false }

23
src/libsyntax/parse/eval.rs
View file

@ -78,10 +78,10 @@ fn parse_companion_mod(cx: ctx, prefix: ~str, suffix: option<~str>)
}
}
fn cdir_path_opt(id: ast::ident, attrs: ~[ast::attribute]) -> @~str {
fn cdir_path_opt(default: ~str, attrs: ~[ast::attribute]) -> ~str {
match ::attr::first_attr_value_str_by_name(attrs, ~"path") {
some(d) => return d,
none => return id
some(d) => d,
none => default
}
}
@ -90,11 +90,12 @@ fn eval_crate_directive(cx: ctx, cdir: @ast::crate_directive, prefix: ~str,
&items: ~[@ast::item]) {
match cdir.node {
ast::cdir_src_mod(id, attrs) => {
let file_path = cdir_path_opt(@(*id + ~".rs"), attrs);
let file_path = cdir_path_opt((cx.sess.interner.get(id) + ~".rs"),
attrs);
let full_path =
if path::path_is_absolute(*file_path) {
*file_path
} else { prefix + path::path_sep() + *file_path };
if path::path_is_absolute(file_path) {
file_path
} else { prefix + path::path_sep() + file_path };
let (p0, r0) =
new_parser_etc_from_file(cx.sess, cx.cfg, full_path, SOURCE_FILE);
let inner_attrs = p0.parse_inner_attrs_and_next();
@ -111,11 +112,11 @@ fn eval_crate_directive(cx: ctx, cdir: @ast::crate_directive, prefix: ~str,
vec::push(items, i);
}
ast::cdir_dir_mod(id, cdirs, attrs) => {
let path = cdir_path_opt(id, attrs);
let path = cdir_path_opt(*cx.sess.interner.get(id), attrs);
let full_path =
if path::path_is_absolute(*path) {
*path
} else { prefix + path::path_sep() + *path };
if path::path_is_absolute(path) {
path
} else { prefix + path::path_sep() + path };
let (m0, a0) = eval_crate_directives_to_mod(
cx, cdirs, full_path, none);
let i =

55
src/libsyntax/parse/parser.rs
View file

@ -6,7 +6,7 @@ import std::map::{hashmap, str_hash};
import token::{can_begin_expr, is_ident, is_ident_or_path, is_plain_ident,
INTERPOLATED};
import codemap::{span,fss_none};
import util::interner;
import util::interner::interner;
import ast_util::{spanned, respan, mk_sp, ident_to_path, operator_prec};
import lexer::reader;
import prec::{as_prec, token_to_binop};
@ -193,12 +193,14 @@ struct parser {
let mut restriction: restriction;
let mut quote_depth: uint; // not (yet) related to the quasiquoter
let reader: reader;
let interner: interner<@~str>;
let keywords: hashmap<~str, ()>;
let restricted_keywords: hashmap<~str, ()>;
new(sess: parse_sess, cfg: ast::crate_cfg, +rdr: reader, ftype: file_type)
{
self.reader <- rdr;
self.interner = self.reader.interner();
let tok0 = self.reader.next_token();
let span0 = tok0.sp;
self.sess = sess;
@ -268,11 +270,10 @@ struct parser {
fn warn(m: ~str) {
self.sess.span_diagnostic.span_warn(copy self.span, m)
}
pure fn get_str(i: token::str_num) -> @~str {
self.reader.interner().get(i)
}
fn get_id() -> node_id { next_node_id(self.sess) }
pure fn id_to_str(id: ident) -> @~str { self.sess.interner.get(id) }
fn parse_ty_fn(purity: ast::purity) -> ty_ {
let proto, bounds;
if self.eat_keyword(~"extern") {
@ -398,9 +399,9 @@ struct parser {
}
}
fn region_from_name(s: option<@~str>) -> @region {
fn region_from_name(s: option<ident>) -> @region {
let r = match s {
some (string) => re_named(string),
some (id) => re_named(id),
none => re_anon
};
@ -414,8 +415,7 @@ struct parser {
match copy self.token {
token::IDENT(sid, _) => {
self.bump();
let n = self.get_str(sid);
self.region_from_name(some(n))
self.region_from_name(some(sid))
}
_ => {
self.region_from_name(none)
@ -430,7 +430,7 @@ struct parser {
token::IDENT(sid, _) => {
if self.look_ahead(1u) == token::BINOP(token::SLASH) {
self.bump(); self.bump();
some(self.get_str(sid))
some(sid)
} else {
none
}
@ -583,7 +583,7 @@ struct parser {
let name = self.parse_value_ident();
self.bump();
name
} else { @~"" }
} else { token::special_idents::invalid }
};
let t = self.parse_ty(false);
@ -678,10 +678,10 @@ struct parser {
token::LIT_INT(i, it) => lit_int(i, it),
token::LIT_UINT(u, ut) => lit_uint(u, ut),
token::LIT_INT_UNSUFFIXED(i) => lit_int_unsuffixed(i),
token::LIT_FLOAT(s, ft) => lit_float(self.get_str(s), ft),
token::LIT_STR(s) => lit_str(self.get_str(s)),
token::LPAREN => { self.expect(token::RPAREN); lit_nil }
_ => self.unexpected_last(tok)
token::LIT_FLOAT(s, ft) => lit_float(self.id_to_str(s), ft),
token::LIT_STR(s) => lit_str(self.id_to_str(s)),
token::LPAREN => { self.expect(token::RPAREN); lit_nil },
_ => { self.unexpected_last(tok); }
}
}
@ -1140,8 +1140,7 @@ struct parser {
self.parse_seq_to_gt(some(token::COMMA),
|p| p.parse_ty(false))
} else { ~[] };
e = self.mk_pexpr(lo, hi, expr_field(self.to_expr(e),
self.get_str(i),
e = self.mk_pexpr(lo, hi, expr_field(self.to_expr(e), i,
tys));
}
_ => self.unexpected()
@ -2123,9 +2122,6 @@ struct parser {
}
fn expr_is_complete(e: pexpr) -> bool {
log(debug, (~"expr_is_complete", self.restriction,
print::pprust::expr_to_str(*e),
classify::expr_requires_semi_to_be_stmt(*e)));
return self.restriction == RESTRICT_STMT_EXPR &&
!classify::expr_requires_semi_to_be_stmt(*e);
}
@ -2306,7 +2302,8 @@ struct parser {
fn is_self_ident() -> bool {
match self.token {
token::IDENT(sid, false) if ~"self" == *self.get_str(sid) => true,
token::IDENT(id, false) if id == token::special_idents::self_
=> true,
_ => false
}
}
@ -2522,11 +2519,13 @@ struct parser {
}
// This is a new-style impl declaration.
let ident = @~"__extensions__"; // XXX: clownshoes
// XXX: clownshoes
let ident = token::special_idents::clownshoes_extensions;
// Parse the type.
let ty = self.parse_ty(false);
// Parse traits, if necessary.
let traits = if self.token == token::COLON {
self.bump();
@ -2595,7 +2594,8 @@ struct parser {
match the_ctor {
some((_, _, _, s_first)) => {
self.span_note(s, #fmt("Duplicate constructor \
declaration for class %s", *class_name));
declaration for class %s",
*self.interner.get(class_name)));
self.span_fatal(copy s_first, ~"First constructor \
declared here");
}
@ -2608,7 +2608,8 @@ struct parser {
match the_dtor {
some((_, _, s_first)) => {
self.span_note(s, #fmt("Duplicate destructor \
declaration for class %s", *class_name));
declaration for class %s",
*self.interner.get(class_name)));
self.span_fatal(copy s_first, ~"First destructor \
declared here");
}
@ -3081,7 +3082,7 @@ struct parser {
let ty_params = self.parse_ty_params();
// Newtype syntax
if self.token == token::EQ {
self.check_restricted_keywords_(*id);
self.check_restricted_keywords_(*self.id_to_str(id));
self.bump();
let ty = self.parse_ty(false);
self.expect(token::SEMI);
@ -3297,7 +3298,7 @@ struct parser {
let lo = self.span.lo;
let first_ident = self.parse_ident();
let mut path = ~[first_ident];
debug!{"parsed view_path: %s", *first_ident};
debug!{"parsed view_path: %s", *self.id_to_str(first_ident)};
match self.token {
token::EQ => {
// x = foo::bar
@ -3323,7 +3324,7 @@ struct parser {
token::IDENT(i, _) => {
self.bump();
vec::push(path, self.get_str(i));
vec::push(path, i);
}
// foo::bar::{a,b,c}
@ -3458,7 +3459,7 @@ struct parser {
fn parse_str() -> @~str {
match copy self.token {
token::LIT_STR(s) => { self.bump(); self.get_str(s) }
token::LIT_STR(s) => { self.bump(); self.id_to_str(s) }
_ => self.fatal(~"expected string literal")
}
}

72
src/libsyntax/parse/token.rs
View file

@ -277,23 +277,83 @@ pure fn is_bar(t: token) -> bool {
match t { BINOP(OR) | OROR => true, _ => false }
}
type ident_interner = util::interner::interner<@~str>;
mod special_idents {
const underscore : uint = 0u;
const anon : uint = 1u;
const destr : uint = 2u; // 'drop', but that's reserved
import 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 self_ : ident = 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 str : ident = 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;
}
type ident_interner = util::interner::interner<@~str>;
/** Key for thread-local data for sneaking interner information to the
* serializer/deserializer. It sounds like a hack because it is one. */
fn interner_key(+_x: @@ident_interner) { }
fn mk_ident_interner() -> ident_interner {
/* the indices here must correspond to the numbers in special_idents */
let init_vec = ~[@~"_", @~"anon", @~"drop"];
let init_vec = ~[@~"_", @~"anon", @~"drop", @~"", @~"unary", @~"!",
@~"[]", @~"unary-", @~"__extensions__", @~"self",
@~"item", @~"block", @~"stmt", @~"pat", @~"expr",
@~"ty", @~"ident", @~"path", @~"tt", @~"matchers",
@~"str", @~"ty_visitor", @~"arg", @~"descrim",
@~"__rust_abi", @~"__rust_stack_shim", @~"tydesc",
@~"dtor", @~"main", @~"<opaque>", @~"blk", @~"static",
@~"intrinsic"];
let rv = @interner::mk_prefill::<@~str>(|x| str::hash(*x),
let rv = interner::mk_prefill::<@~str>(|x| str::hash(*x),
|x,y| str::eq(*x, *y), init_vec);
/* having multiple interners will just confuse the serializer */
unsafe{ assert task::local_data_get(interner_key) == none };
unsafe{ task::local_data_set(interner_key, @rv) };
rv
}
/* 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>(|x| str::hash(*x), |x,y| str::eq(*x, *y))
}
/**
* All the valid words that have meaning in the Rust language.
*

189
src/libsyntax/print/pprust.rs
View file

@ -8,9 +8,7 @@ import ast::{required, provided};
import ast_util::{operator_prec};
import dvec::{DVec, dvec};
import parse::classify::*;
import util::interner;
type ident_interner = interner::interner<@~str>;
import parse::token::ident_interner;
// The ps is stored here to prevent recursive type.
enum ann_node {
@ -47,19 +45,7 @@ fn end(s: ps) {
pp::end(s.s);
}
fn rust_printer(writer: io::Writer) -> ps {
return @{s: pp::mk_printer(writer, default_columns),
cm: none::<codemap>,
intr: token::mk_ident_interner(),
comments: none::<~[comments::cmnt]>,
literals: none::<~[comments::lit]>,
mut cur_cmnt: 0u,
mut cur_lit: 0u,
boxes: dvec(),
ann: no_ann()};
}
fn unexpanded_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,
@ -79,7 +65,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: interner::interner<@~str>,
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) {
@ -107,41 +93,46 @@ fn print_crate_(s: ps, &&crate: @ast::crate) {
eof(s.s);
}
fn ty_to_str(ty: @ast::ty) -> ~str { return to_str(ty, print_type); }
fn pat_to_str(pat: @ast::pat) -> ~str { return to_str(pat, print_pat); }
fn expr_to_str(e: @ast::expr) -> ~str { return to_str(e, print_expr); }
fn unexpanded_tt_to_str(tt: ast::token_tree, intr: ident_interner)
-> ~str {
let buffer = io::mem_buffer();
let s = unexpanded_rust_printer(io::mem_buffer_writer(buffer), intr);
print_tt(s, tt);
eof(s.s);
io::mem_buffer_str(buffer)
fn ty_to_str(ty: @ast::ty, intr: ident_interner) -> ~str {
to_str(ty, print_type, intr)
}
fn stmt_to_str(s: ast::stmt) -> ~str { return to_str(s, print_stmt); }
fn item_to_str(i: @ast::item) -> ~str { return to_str(i, print_item); }
fn attr_to_str(i: ast::attribute) -> ~str {
return to_str(i, print_attribute);
fn pat_to_str(pat: @ast::pat, intr: ident_interner) -> ~str {
to_str(pat, print_pat, intr)
}
fn typarams_to_str(tps: ~[ast::ty_param]) -> ~str {
return to_str(tps, print_type_params)
fn expr_to_str(e: @ast::expr, intr: ident_interner) -> ~str {
to_str(e, print_expr, intr)
}
fn path_to_str(&&p: @ast::path) -> ~str {
return to_str(p, |a,b| print_path(a, b, false));
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 {
to_str(s, print_stmt, intr)
}
fn item_to_str(i: @ast::item, intr: ident_interner) -> ~str {
to_str(i, print_item, intr)
}
fn attr_to_str(i: ast::attribute, intr: ident_interner) -> ~str {
to_str(i, print_attribute, intr)
}
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 {
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]) -> ~str {
params: ~[ast::ty_param], intr: ident_interner) -> ~str {
let buffer = io::mem_buffer();
let s = rust_printer(io::mem_buffer_writer(buffer));
let s = rust_printer(io::mem_buffer_writer(buffer), intr);
print_fn(s, decl, name, params, none);
end(s); // Close the head box
end(s); // Close the outer box
@ -162,9 +153,9 @@ fn test_fun_to_str() {
assert fun_to_str(decl, "a", ~[]) == "fn a()";
}
fn block_to_str(blk: ast::blk) -> ~str {
fn block_to_str(blk: ast::blk, intr: ident_interner) -> ~str {
let buffer = io::mem_buffer();
let s = rust_printer(io::mem_buffer_writer(buffer));
let s = rust_printer(io::mem_buffer_writer(buffer), intr);
// containing cbox, will be closed by print-block at }
cbox(s, indent_unit);
// head-ibox, will be closed by print-block after {
@ -174,16 +165,16 @@ fn block_to_str(blk: ast::blk) -> ~str {
io::mem_buffer_str(buffer)
}
fn meta_item_to_str(mi: ast::meta_item) -> ~str {
return to_str(@mi, print_meta_item);
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) -> ~str {
return to_str(attr, print_attribute);
fn attribute_to_str(attr: ast::attribute, intr: ident_interner) -> ~str {
to_str(attr, print_attribute, intr)
}
fn variant_to_str(var: ast::variant) -> ~str {
return to_str(var, print_variant);
fn variant_to_str(var: ast::variant, intr: ident_interner) -> ~str {
to_str(var, print_variant, intr)
}
#[test]
@ -349,7 +340,7 @@ fn print_region(s: ps, region: @ast::region) {
ast::re_anon => word_space(s, ~"&"),
ast::re_named(name) => {
word(s.s, ~"&");
word(s.s, *name);
print_ident(s, name);
}
}
}
@ -389,7 +380,7 @@ fn print_type_ex(s: ps, &&ty: @ast::ty, print_colons: bool) {
fn print_field(s: ps, f: ast::ty_field) {
cbox(s, indent_unit);
print_mutability(s, f.node.mt.mutbl);
word(s.s, *f.node.ident);
print_ident(s, f.node.ident);
word_space(s, ~":");
print_type(s, f.node.mt.ty);
end(s);
@ -446,7 +437,8 @@ fn print_item(s: ps, &&item: @ast::item) {
match item.node {
ast::item_const(ty, expr) => {
head(s, ~"const");
word_space(s, *item.ident + ~":");
print_ident(s, item.ident);
word_space(s, ~":");
print_type(s, ty);
space(s.s);
end(s); // end the head-ibox
@ -464,7 +456,8 @@ fn print_item(s: ps, &&item: @ast::item) {
}
ast::item_mod(_mod) => {
head(s, ~"mod");
word_nbsp(s, *item.ident);
print_ident(s, item.ident);
nbsp(s);
bopen(s);
print_mod(s, _mod, item.attrs);
bclose(s, item.span);
@ -472,7 +465,8 @@ fn print_item(s: ps, &&item: @ast::item) {
ast::item_foreign_mod(nmod) => {
head(s, ~"extern");
word_nbsp(s, ~"mod");
word_nbsp(s, *item.ident);
print_ident(s, item.ident);
nbsp(s);
bopen(s);
print_foreign_mod(s, nmod, item.attrs);
bclose(s, item.span);
@ -481,7 +475,7 @@ fn print_item(s: ps, &&item: @ast::item) {
ibox(s, indent_unit);
ibox(s, 0u);
word_nbsp(s, ~"type");
word(s.s, *item.ident);
print_ident(s, item.ident);
print_type_params(s, params);
end(s); // end the inner ibox
@ -498,6 +492,7 @@ fn print_item(s: ps, &&item: @ast::item) {
head(s, ~"struct");
print_struct(s, struct_def, tps, item.ident, item.span);
}
ast::item_impl(tps, traits, ty, methods) => {
head(s, ~"impl");
if tps.is_not_empty() {
@ -522,7 +517,7 @@ fn print_item(s: ps, &&item: @ast::item) {
}
ast::item_trait(tps, traits, methods) => {
head(s, ~"trait");
word(s.s, *item.ident);
print_ident(s, item.ident);
print_type_params(s, tps);
if vec::len(traits) != 0u {
word_space(s, ~":");
@ -535,7 +530,9 @@ fn print_item(s: ps, &&item: @ast::item) {
bclose(s, item.span);
}
ast::item_mac({node: ast::mac_invoc_tt(pth, tts), _}) => {
head(s, path_to_str(pth) + ~"! " + *item.ident);
print_path(s, pth, false);
head(s, ~"! ");
print_ident(s, item.ident);
bopen(s);
for tts.each |tt| { print_tt(s, tt); }
bclose(s, item.span);
@ -552,7 +549,7 @@ fn print_enum_def(s: ps, enum_definition: ast::enum_def,
span: ast::span) {
let mut newtype =
vec::len(enum_definition.variants) == 1u &&
str::eq(ident, enum_definition.variants[0].node.name);
ident == enum_definition.variants[0].node.name;
if newtype {
match enum_definition.variants[0].node.kind {
ast::tuple_variant_kind(args) if args.len() == 1 => {}
@ -566,7 +563,7 @@ fn print_enum_def(s: ps, enum_definition: ast::enum_def,
head(s, ~"enum");
}
word(s.s, *ident);
print_ident(s, ident);
print_type_params(s, params);
space(s.s);
if newtype {
@ -599,7 +596,8 @@ fn print_variants(s: ps, variants: ~[ast::variant], span: ast::span) {
fn print_struct(s: ps, struct_def: @ast::struct_def, tps: ~[ast::ty_param],
ident: ast::ident, span: ast::span) {
word_nbsp(s, *ident);
print_ident(s, ident);
nbsp(s);
print_type_params(s, tps);
if vec::len(struct_def.traits) != 0u {
word_space(s, ~":");
@ -639,7 +637,7 @@ fn print_struct(s: ps, struct_def: @ast::struct_def, tps: ~[ast::ty_param],
if mutability == ast::class_mutable {
word_nbsp(s, ~"mut");
}
word(s.s, *ident);
print_ident(s, ident);
word_nbsp(s, ~":");
print_type(s, field.node.ty);
word(s.s, ~";");
@ -684,7 +682,8 @@ fn print_tt(s: ps, tt: ast::token_tree) {
s.s.token_tree_last_was_ident = false;
}
ast::tt_nonterminal(_, name) => {
word(s.s, ~"$" + *name);
word(s.s, ~"$");
print_ident(s, name);
s.s.token_tree_last_was_ident = true;
}
}
@ -693,7 +692,7 @@ fn print_tt(s: ps, tt: ast::token_tree) {
fn print_variant(s: ps, v: ast::variant) {
match v.node.kind {
ast::tuple_variant_kind(args) => {
word(s.s, *v.node.name);
print_ident(s, v.node.name);
if vec::len(args) > 0u {
popen(s);
fn print_variant_arg(s: ps, arg: ast::variant_arg) {
@ -780,7 +779,7 @@ fn print_attribute(s: ps, attr: ast::attribute) {
if attr.node.is_sugared_doc {
let meta = attr::attr_meta(attr);
let comment = attr::get_meta_item_value_str(meta).get();
word(s.s, *comment);
word(s.s, comment);
} else {
word(s.s, ~"#[");
print_meta_item(s, @attr.node.value);
@ -935,7 +934,8 @@ fn print_mac(s: ps, m: ast::mac) {
// FIXME: extension 'body' (#2339)
}
ast::mac_invoc_tt(pth, tts) => {
head(s, path_to_str(pth) + ~"!");
print_path(s, pth, false);
head(s, ~"!");
bopen(s);
for tts.each() |tt| { print_tt(s, tt); }
bclose(s, m.span);
@ -956,7 +956,7 @@ fn print_vstore(s: ps, t: ast::vstore) {
ast::re_anon => word(s.s, ~"&"),
ast::re_named(name) => {
word(s.s, ~"&");
word(s.s, *name);
print_ident(s, name);
word(s.s, ~".");
}
}
@ -967,7 +967,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
fn print_field(s: ps, field: ast::field) {
ibox(s, indent_unit);
if field.node.mutbl == ast::m_mutbl { word_nbsp(s, ~"mut"); }
word(s.s, *field.node.ident);
print_ident(s, field.node.ident);
word_space(s, ~":");
print_expr(s, field.node.expr);
end(s);
@ -1125,7 +1125,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
ast::expr_loop(blk, opt_ident) => {
head(s, ~"loop");
space(s.s);
option::iter(opt_ident, |ident| word_space(s, *ident));
option::iter(opt_ident, |ident| {print_ident(s, ident); space(s.s)});
print_block(s, blk);
}
ast::expr_match(expr, arms, mode) => {
@ -1270,7 +1270,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
print_expr_parens_if_not_bot(s, expr);
}
word(s.s, ~".");
word(s.s, *id);
print_ident(s, id);
if vec::len(tys) > 0u {
word(s.s, ~"::<");
commasep(s, inconsistent, tys, print_type);
@ -1294,12 +1294,12 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
ast::expr_break(opt_ident) => {
word(s.s, ~"break");
space(s.s);
option::iter(opt_ident, |ident| word_space(s, *ident));
option::iter(opt_ident, |ident| {print_ident(s, ident); space(s.s)});
}
ast::expr_again(opt_ident) => {
word(s.s, ~"again");
space(s.s);
option::iter(opt_ident, |ident| word_space(s, *ident));
option::iter(opt_ident, |ident| {print_ident(s, ident); space(s.s)});
}
ast::expr_ret(result) => {
word(s.s, ~"return");
@ -1395,7 +1395,7 @@ fn print_decl(s: ps, decl: @ast::decl) {
}
}
fn print_ident(s: ps, ident: ast::ident) { word(s.s, *ident); }
fn print_ident(s: ps, ident: ast::ident) { word(s.s, *s.intr.get(ident)); }
fn print_for_decl(s: ps, loc: @ast::local, coll: @ast::expr) {
print_local_decl(s, loc);
@ -1410,7 +1410,7 @@ fn print_path(s: ps, &&path: @ast::path, colons_before_params: bool) {
let mut first = true;
for path.idents.each |id| {
if first { first = false; } else { word(s.s, ~"::"); }
word(s.s, *id);
print_ident(s, id);
}
if path.rp.is_some() || !path.types.is_empty() {
if colons_before_params { word(s.s, ~"::"); }
@ -1471,7 +1471,7 @@ fn print_pat(s: ps, &&pat: @ast::pat) {
word(s.s, ~"{");
fn print_field(s: ps, f: ast::field_pat) {
cbox(s, indent_unit);
word(s.s, *f.ident);
print_ident(s, f.ident);
word_space(s, ~":");
print_pat(s, f.pat);
end(s);
@ -1489,7 +1489,7 @@ fn print_pat(s: ps, &&pat: @ast::pat) {
word(s.s, ~"{");
fn print_field(s: ps, f: ast::field_pat) {
cbox(s, indent_unit);
word(s.s, *f.ident);
print_ident(s, f.ident);
word_space(s, ~":");
print_pat(s, f.pat);
end(s);
@ -1542,7 +1542,7 @@ fn print_fn(s: ps, decl: ast::fn_decl, name: ast::ident,
typarams: ~[ast::ty_param],
opt_self_ty: option<ast::self_ty_>) {
head(s, fn_header_info_to_str(opt_self_ty, decl.purity, none));
word(s.s, *name);
print_ident(s, name);
print_type_params(s, typarams);
print_fn_args_and_ret(s, decl, ~[], opt_self_ty);
}
@ -1568,7 +1568,7 @@ fn print_fn_args(s: ps, decl: ast::fn_decl,
if first { first = false; } else { word_space(s, ~","); }
if cap_item.is_move { word_nbsp(s, ~"move") }
else { word_nbsp(s, ~"copy") }
word(s.s, *cap_item.name);
print_ident(s, cap_item.name);
}
end(s);
@ -1638,7 +1638,7 @@ fn print_type_params(s: ps, &&params: ~[ast::ty_param]) {
if vec::len(params) > 0u {
word(s.s, ~"<");
fn printParam(s: ps, param: ast::ty_param) {
word(s.s, *param.ident);
print_ident(s, param.ident);
print_bounds(s, param.bounds);
}
commasep(s, inconsistent, params, printParam);
@ -1649,14 +1649,14 @@ fn print_type_params(s: ps, &&params: ~[ast::ty_param]) {
fn print_meta_item(s: ps, &&item: @ast::meta_item) {
ibox(s, indent_unit);
match item.node {
ast::meta_word(name) => word(s.s, *name),
ast::meta_word(name) => word(s.s, name),
ast::meta_name_value(name, value) => {
word_space(s, *name);
word_space(s, name);
word_space(s, ~"=");
print_literal(s, @value);
}
ast::meta_list(name, items) => {
word(s.s, *name);
word(s.s, name);
popen(s);
commasep(s, consistent, items, print_meta_item);
pclose(s);
@ -1669,7 +1669,8 @@ fn print_view_path(s: ps, &&vp: @ast::view_path) {
match vp.node {
ast::view_path_simple(ident, path, _) => {
if path.idents[vec::len(path.idents)-1u] != ident {
word_space(s, *ident);
print_ident(s, ident);
space(s.s);
word_space(s, ~"=");
}
print_path(s, path, false);
@ -1684,7 +1685,7 @@ fn print_view_path(s: ps, &&vp: @ast::view_path) {
print_path(s, path, false);
word(s.s, ~"::{");
do commasep(s, inconsistent, idents) |s, w| {
word(s.s, *w.node.name)
print_ident(s, w.node.name);
}
word(s.s, ~"}");
}
@ -1702,7 +1703,7 @@ fn print_view_item(s: ps, item: @ast::view_item) {
match item.node {
ast::view_item_use(id, mta, _) => {
head(s, ~"use");
word(s.s, *id);
print_ident(s, id);
if vec::len(mta) > 0u {
popen(s);
commasep(s, consistent, mta, print_meta_item);
@ -1749,10 +1750,12 @@ fn print_arg(s: ps, input: ast::arg) {
ibox(s, indent_unit);
print_arg_mode(s, input.mode);
match input.ty.node {
ast::ty_infer => word(s.s, *input.ident),
ast::ty_infer => print_ident(s, input.ident),
_ => {
if str::len(*input.ident) > 0u {
word_space(s, *input.ident + ~":");
if input.ident != parse::token::special_idents::invalid {
print_ident(s, input.ident);
word(s.s, ~":");
space(s.s);
}
print_type(s, input.ty);
}
@ -1768,7 +1771,7 @@ fn print_ty_fn(s: ps, opt_proto: option<ast::proto>,
ibox(s, indent_unit);
word(s.s, fn_header_info_to_str(opt_self_ty, decl.purity, opt_proto));
print_bounds(s, bounds);
match id { some(id) => { word(s.s, ~" "); word(s.s, *id); } _ => () }
match id { some(id) => { word(s.s, ~" "); print_ident(s, id); } _ => () }
match tps { some(tps) => print_type_params(s, tps), _ => () }
zerobreak(s.s);
@ -1880,7 +1883,9 @@ fn print_literal(s: ps, &&lit: @ast::lit) {
}
}
fn lit_to_str(l: @ast::lit) -> ~str { return to_str(l, print_literal); }
fn lit_to_str(l: @ast::lit) -> ~str {
return to_str(l, print_literal, parse::token::mk_fake_ident_interner());
}
fn next_lit(s: ps, pos: uint) -> option<comments::lit> {
match s.literals {
@ -1961,9 +1966,9 @@ fn print_string(s: ps, st: ~str) {
word(s.s, ~"\"");
}
fn to_str<T>(t: T, f: fn@(ps, T)) -> ~str {
fn to_str<T>(t: T, f: fn@(ps, T), intr: ident_interner) -> ~str {
let buffer = io::mem_buffer();
let s = rust_printer(io::mem_buffer_writer(buffer));
let s = rust_printer(io::mem_buffer_writer(buffer), intr);
f(s, t);
eof(s.s);
io::mem_buffer_str(buffer)

9
src/libsyntax/util/interner.rs
View file

@ -21,7 +21,7 @@ fn mk<T: const copy>(+hasher: hashfn<T>, +eqer: eqfn<T>) -> interner<T> {
fn mk_prefill<T: const copy>(hasher: hashfn<T>, eqer: eqfn<T>,
init: ~[T]) -> interner<T> {
let rv = mk(hasher, eqer);
let rv = mk(copy hasher, copy eqer);
for init.each() |v| { rv.intern(v); }
return rv;
}
@ -30,6 +30,7 @@ fn mk_prefill<T: const copy>(hasher: hashfn<T>, eqer: eqfn<T>,
/* when traits can extend traits, we should extend index<uint,T> to get [] */
trait interner<T: const copy> {
fn intern(T) -> uint;
fn gensym(T) -> uint;
pure fn get(uint) -> T;
fn len() -> uint;
}
@ -46,6 +47,12 @@ impl <T: const copy> hash_interner<T>: interner<T> {
}
}
}
fn gensym(val: T) -> uint {
let new_idx = self.vect.len();
// leave out of .map to avoid colliding
self.vect.push(val);
return new_idx;
}
// this isn't "pure" in the traditional sense, because it can go from
// failing to returning a value as items are interned. But for typestate,

4
src/libsyntax/visit.rs
View file

@ -28,8 +28,8 @@ fn name_of_fn(fk: fn_kind) -> ident {
match fk {
fk_item_fn(name, _) | fk_method(name, _, _)
| fk_ctor(name, _, _, _, _) => /* FIXME (#2543) */ copy name,
fk_anon(*) | fk_fn_block(*) => @~"anon",
fk_dtor(*) => @~"drop"
fk_anon(*) | fk_fn_block(*) => parse::token::special_idents::anon,
fk_dtor(*) => parse::token::special_idents::dtor
}
}

71
src/rustc/back/link.rs
View file

@ -310,24 +310,24 @@ fn build_link_meta(sess: session, c: ast::crate, output: ~str,
symbol_hasher: &hash::State) -> link_meta {
type provided_metas =
{name: option<@~str>,
vers: option<@~str>,
{name: option<~str>,
vers: option<~str>,
cmh_items: ~[@ast::meta_item]};
fn provided_link_metas(sess: session, c: ast::crate) ->
provided_metas {
let mut name: option<@~str> = none;
let mut vers: option<@~str> = none;
let mut name: option<~str> = none;
let mut vers: option<~str> = none;
let mut cmh_items: ~[@ast::meta_item] = ~[];
let linkage_metas = attr::find_linkage_metas(c.node.attrs);
attr::require_unique_names(sess.diagnostic(), linkage_metas);
for linkage_metas.each |meta| {
if *attr::get_meta_item_name(meta) == ~"name" {
if attr::get_meta_item_name(meta) == ~"name" {
match attr::get_meta_item_value_str(meta) {
some(v) => { name = some(v); }
none => vec::push(cmh_items, meta)
}
} else if *attr::get_meta_item_name(meta) == ~"vers" {
} else if attr::get_meta_item_name(meta) == ~"vers" {
match attr::get_meta_item_value_str(meta) {
some(v) => { vers = some(v); }
none => vec::push(cmh_items, meta)
@ -341,7 +341,7 @@ fn build_link_meta(sess: session, c: ast::crate, output: ~str,
fn crate_meta_extras_hash(symbol_hasher: &hash::State,
_crate: ast::crate,
metas: provided_metas,
dep_hashes: ~[@~str]) -> ~str {
dep_hashes: ~[~str]) -> ~str {
fn len_and_str(s: ~str) -> ~str {
return fmt!{"%u_%s", str::len(s), s};
}
@ -357,11 +357,11 @@ fn build_link_meta(sess: session, c: ast::crate, output: ~str,
let m = m_;
match m.node {
ast::meta_name_value(key, value) => {
symbol_hasher.write_str(len_and_str(*key));
symbol_hasher.write_str(len_and_str(key));
symbol_hasher.write_str(len_and_str_lit(value));
}
ast::meta_word(name) => {
symbol_hasher.write_str(len_and_str(*name));
symbol_hasher.write_str(len_and_str(name));
}
ast::meta_list(_, _) => {
// FIXME (#607): Implement this
@ -371,7 +371,7 @@ fn build_link_meta(sess: session, c: ast::crate, output: ~str,
}
for dep_hashes.each |dh| {
symbol_hasher.write_str(len_and_str(*dh));
symbol_hasher.write_str(len_and_str(dh));
}
return truncated_hash_result(symbol_hasher);
@ -384,7 +384,7 @@ fn build_link_meta(sess: session, c: ast::crate, output: ~str,
}
fn crate_meta_name(sess: session, _crate: ast::crate,
output: ~str, metas: provided_metas) -> @~str {
output: ~str, metas: provided_metas) -> ~str {
return match metas.name {
some(v) => v,
none => {
@ -400,19 +400,19 @@ fn build_link_meta(sess: session, c: ast::crate, output: ~str,
str::connect(os, ~".")
};
warn_missing(sess, ~"name", name);
@name
name
}
};
}
fn crate_meta_vers(sess: session, _crate: ast::crate,
metas: provided_metas) -> @~str {
metas: provided_metas) -> ~str {
return match metas.vers {
some(v) => v,
none => {
let vers = ~"0.0";
warn_missing(sess, ~"vers", vers);
@vers
vers
}
};
}
@ -439,7 +439,7 @@ fn symbol_hash(tcx: ty::ctxt, symbol_hasher: &hash::State, t: ty::t,
// to be independent of one another in the crate.
symbol_hasher.reset();
symbol_hasher.write_str(*link_meta.name);
symbol_hasher.write_str(link_meta.name);
symbol_hasher.write_str(~"-");
symbol_hasher.write_str(link_meta.extras_hash);
symbol_hasher.write_str(~"-");
@ -497,14 +497,14 @@ fn sanitize(s: ~str) -> ~str {
return result;
}
fn mangle(ss: path) -> ~str {
fn mangle(sess: session, ss: path) -> ~str {
// Follow C++ namespace-mangling style
let mut n = ~"_ZN"; // Begin name-sequence.
for ss.each |s| {
match s { path_name(s) | path_mod(s) => {
let sani = sanitize(*s);
let sani = sanitize(sess.str_of(s));
n += fmt!{"%u%s", str::len(sani), sani};
} }
}
@ -512,36 +512,41 @@ fn mangle(ss: path) -> ~str {
n
}
fn exported_name(path: path, hash: @~str, vers: @~str) -> ~str {
return mangle(
vec::append_one(vec::append_one(path, path_name(hash)),
path_name(vers)));
fn exported_name(sess: session, path: path, hash: ~str, vers: ~str) -> ~str {
return mangle(sess,
vec::append_one(
vec::append_one(path, path_name(sess.ident_of(hash))),
path_name(sess.ident_of(vers))));
}
fn mangle_exported_name(ccx: @crate_ctxt, path: path, t: ty::t) -> ~str {
let hash = get_symbol_hash(ccx, t);
return exported_name(path, @hash, ccx.link_meta.vers);
return exported_name(ccx.sess, path, hash, ccx.link_meta.vers);
}
fn mangle_internal_name_by_type_only(ccx: @crate_ctxt,
t: ty::t, name: @~str) ->
t: ty::t, name: ~str) ->
~str {
let s = @util::ppaux::ty_to_short_str(ccx.tcx, t);
let s = util::ppaux::ty_to_short_str(ccx.tcx, t);
let hash = get_symbol_hash(ccx, t);
return mangle(~[path_name(name), path_name(s), path_name(@hash)]);
return mangle(ccx.sess,
~[path_name(ccx.sess.ident_of(name)),
path_name(ccx.sess.ident_of(s)),
path_name(ccx.sess.ident_of(hash))]);
}
fn mangle_internal_name_by_path_and_seq(ccx: @crate_ctxt, path: path,
flav: @~str) -> ~str {
return mangle(vec::append_one(path, path_name(@ccx.names(*flav))));
flav: ~str) -> ~str {
return mangle(ccx.sess,
vec::append_one(path, path_name(ccx.names(flav))));
}
fn mangle_internal_name_by_path(_ccx: @crate_ctxt, path: path) -> ~str {
return mangle(path);
fn mangle_internal_name_by_path(ccx: @crate_ctxt, path: path) -> ~str {
return mangle(ccx.sess, path);
}
fn mangle_internal_name_by_seq(ccx: @crate_ctxt, flav: @~str) -> ~str {
return ccx.names(*flav);
fn mangle_internal_name_by_seq(ccx: @crate_ctxt, flav: ~str) -> ~str {
return fmt!("%s_%u", flav, ccx.names(flav));
}
// If the user wants an exe generated we need to invoke
@ -577,8 +582,8 @@ fn link_binary(sess: session,
let output = if sess.building_library {
let long_libname =
os::dll_filename(fmt!{"%s-%s-%s",
*lm.name, lm.extras_hash, *lm.vers});
debug!{"link_meta.name: %s", *lm.name};
lm.name, lm.extras_hash, lm.vers});
debug!{"link_meta.name: %s", lm.name};
debug!{"long_libname: %s", long_libname};
debug!{"out_filename: %s", out_filename};
debug!{"dirname(out_filename): %s", path::dirname(out_filename)};

33
src/rustc/driver/driver.rs
View file

@ -51,15 +51,15 @@ fn default_configuration(sess: session, argv0: ~str, input: input) ->
};
return ~[ // Target bindings.
attr::mk_word_item(@os::family()),
mk(@~"target_os", os::sysname()),
mk(@~"target_family", os::family()),
mk(@~"target_arch", arch),
mk(@~"target_word_size", wordsz),
mk(@~"target_libc", libc),
attr::mk_word_item(os::family()),
mk(~"target_os", os::sysname()),
mk(~"target_family", os::family()),
mk(~"target_arch", arch),
mk(~"target_word_size", wordsz),
mk(~"target_libc", libc),
// Build bindings.
mk(@~"build_compiler", argv0),
mk(@~"build_input", source_name(input))];
mk(~"build_compiler", argv0),
mk(~"build_input", source_name(input))];
}
fn build_configuration(sess: session, argv0: ~str, input: input) ->
@ -72,9 +72,9 @@ fn build_configuration(sess: session, argv0: ~str, input: input) ->
let gen_cfg =
{
if sess.opts.test && !attr::contains_name(user_cfg, ~"test") {
~[attr::mk_word_item(@~"test")]
~[attr::mk_word_item(~"test")]
} else {
~[attr::mk_word_item(@~"notest")]
~[attr::mk_word_item(~"notest")]
}
};
return vec::append(vec::append(user_cfg, gen_cfg), default_cfg);
@ -86,7 +86,7 @@ fn parse_cfgspecs(cfgspecs: ~[~str]) -> ast::crate_cfg {
// varieties of meta_item here. At the moment we just support the
// meta_word variant.
let mut words = ~[];
for cfgspecs.each |s| { vec::push(words, attr::mk_word_item(@s)); }
for cfgspecs.each |s| { vec::push(words, attr::mk_word_item(s)); }
return words;
}
@ -169,7 +169,8 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg,
creader::read_crates(sess.diagnostic(), *crate, sess.cstore,
sess.filesearch,
session::sess_os_to_meta_os(sess.targ_cfg.os),
sess.opts.static));
sess.opts.static,
sess.parse_sess.interner));
let lang_items = time(time_passes, ~"language item collection", ||
middle::lang_items::collect_language_items(crate, sess));
@ -552,7 +553,9 @@ fn build_session_(sopts: @session::options,
-> session {
let target_cfg = build_target_config(sopts, demitter);
let cstore = cstore::mk_cstore();
let p_s = parse::new_parse_sess_special_handler(span_diagnostic_handler,
cm);
let cstore = cstore::mk_cstore(p_s.interner);
let filesearch = filesearch::mk_filesearch(
sopts.maybe_sysroot,
sopts.target_triple,
@ -561,8 +564,7 @@ fn build_session_(sopts: @session::options,
session_(@{targ_cfg: target_cfg,
opts: sopts,
cstore: cstore,
parse_sess:
parse::new_parse_sess_special_handler(span_diagnostic_handler, cm),
parse_sess: p_s,
codemap: cm,
// For a library crate, this is always none
mut main_fn: none,
@ -701,6 +703,7 @@ fn early_error(emitter: diagnostic::emitter, msg: ~str) -> ! {
fn list_metadata(sess: session, path: ~str, out: io::Writer) {
metadata::loader::list_file_metadata(
sess.parse_sess.interner,
session::sess_os_to_meta_os(sess.targ_cfg.os), path, out);
}

14
src/rustc/driver/session.rs
View file

@ -204,6 +204,16 @@ impl session {
fn borrowck_stats() -> bool { self.debugging_opt(borrowck_stats) }
fn borrowck_note_pure() -> bool { self.debugging_opt(borrowck_note_pure) }
fn borrowck_note_loan() -> bool { self.debugging_opt(borrowck_note_loan) }
fn str_of(id: ast::ident) -> ~str {
*self.parse_sess.interner.get(id)
}
fn ident_of(st: ~str) -> ast::ident {
self.parse_sess.interner.intern(@st)
}
fn intr() -> syntax::parse::token::ident_interner {
self.parse_sess.interner
}
}
/// Some reasonable defaults
@ -245,7 +255,7 @@ fn building_library(req_crate_type: crate_type, crate: @ast::crate,
match syntax::attr::first_attr_value_str_by_name(
crate.node.attrs,
~"crate_type") {
option::some(@~"lib") => true,
option::some(~"lib") => true,
_ => false
}
}
@ -273,7 +283,7 @@ mod test {
style: ast::attr_outer,
value: ast_util::respan(ast_util::dummy_sp(),
ast::meta_name_value(
@~"crate_type",
~"crate_type",
ast_util::respan(ast_util::dummy_sp(),
ast::lit_str(@t)))),
is_sugared_doc: false

5
src/rustc/front/core_inject.rs
View file

@ -30,11 +30,12 @@ fn inject_libcore_ref(sess: session,
let n1 = sess.next_node_id();
let n2 = sess.next_node_id();
let vi1 = @{node: ast::view_item_use(@~"core", ~[], n1),
let vi1 = @{node: ast::view_item_use(sess.ident_of(~"core"), ~[], n1),
attrs: ~[],
vis: ast::public,
span: dummy_sp()};
let vp = spanned(ast::view_path_glob(ident_to_path(dummy_sp(), @~"core"),
let vp = spanned(ast::view_path_glob(
ident_to_path(dummy_sp(), sess.ident_of(~"core")),
n2));
let vi2 = @{node: ast::view_item_import(~[vp]),
attrs: ~[],

59
src/rustc/front/test.rs
View file

@ -62,17 +62,17 @@ fn strip_test_functions(crate: @ast::crate) -> @ast::crate {
}
}
fn fold_mod(_cx: test_ctxt, m: ast::_mod, fld: fold::ast_fold) -> ast::_mod {
fn fold_mod(cx: test_ctxt, m: ast::_mod, fld: fold::ast_fold) -> ast::_mod {
// Remove any defined main function from the AST so it doesn't clash with
// the one we're going to add.
// FIXME (#2403): This is sloppy. Instead we should have some mechanism to
// indicate to the translation pass which function we want to be main.
fn nomain(&&item: @ast::item) -> option<@ast::item> {
fn nomain(cx: test_ctxt, item: @ast::item) -> option<@ast::item> {
match item.node {
ast::item_fn(_, _, _) => {
if *item.ident == ~"main" {
if item.ident == cx.sess.ident_of(~"main") {
option::none
} else { option::some(item) }
}
@ -81,7 +81,8 @@ fn fold_mod(_cx: test_ctxt, m: ast::_mod, fld: fold::ast_fold) -> ast::_mod {
}
let mod_nomain =
{view_items: m.view_items, items: vec::filter_map(m.items, nomain)};
{view_items: m.view_items, items: vec::filter_map(m.items,
|i| nomain(cx, i))};
return fold::noop_fold_mod(mod_nomain, fld);
}
@ -99,7 +100,8 @@ fn fold_item(cx: test_ctxt, &&i: @ast::item, fld: fold::ast_fold) ->
option<@ast::item> {
vec::push(cx.path, i.ident);
debug!{"current path: %s", ast_util::path_name_i(cx.path)};
debug!{"current path: %s",
ast_util::path_name_i(cx.path, cx.sess.parse_sess.interner)};
if is_test_fn(i) {
match i.node {
@ -192,16 +194,17 @@ fn mk_test_module(cx: test_ctxt) -> @ast::item {
let item_ = ast::item_mod(testmod);
// This attribute tells resolve to let us call unexported functions
let resolve_unexported_attr =
attr::mk_attr(attr::mk_word_item(@~"!resolve_unexported"));
attr::mk_attr(attr::mk_word_item(~"!resolve_unexported"));
let item: ast::item =
{ident: @~"__test",
{ident: cx.sess.ident_of(~"__test"),
attrs: ~[resolve_unexported_attr],
id: cx.sess.next_node_id(),
node: item_,
vis: ast::public,
span: dummy_sp()};
debug!{"Synthetic test module:\n%s\n", pprust::item_to_str(@item)};
debug!{"Synthetic test module:\n%s\n",
pprust::item_to_str(@item, cx.sess.intr())};
return @item;
}
@ -232,7 +235,7 @@ fn mk_tests(cx: test_ctxt) -> @ast::item {
let item_ = ast::item_fn(decl, ~[], body);
let item: ast::item =
{ident: @~"tests",
{ident: cx.sess.ident_of(~"tests"),
attrs: ~[],
id: cx.sess.next_node_id(),
node: item_,
@ -247,18 +250,19 @@ fn mk_path(cx: test_ctxt, path: ~[ast::ident]) -> ~[ast::ident] {
let is_std = {
let items = attr::find_linkage_metas(cx.crate.node.attrs);
match attr::last_meta_item_value_str_by_name(items, ~"name") {
some(@~"std") => true,
some(~"std") => true,
_ => false
}
};
if is_std { path }
else { vec::append(~[@~"std"], path) }
else { vec::append(~[cx.sess.ident_of(~"std")], path) }
}
// The ast::ty of ~[std::test::test_desc]
fn mk_test_desc_vec_ty(cx: test_ctxt) -> @ast::ty {
let test_desc_ty_path =
path_node(mk_path(cx, ~[@~"test", @~"test_desc"]));
path_node(mk_path(cx, ~[cx.sess.ident_of(~"test"),
cx.sess.ident_of(~"test_desc")]));
let test_desc_ty: ast::ty =
{id: cx.sess.next_node_id(),
@ -296,10 +300,12 @@ fn mk_test_desc_rec(cx: test_ctxt, test: test) -> @ast::expr {
let span = test.span;
let path = test.path;
debug!{"encoding %s", ast_util::path_name_i(path)};
debug!{"encoding %s", ast_util::path_name_i(path,
cx.sess.parse_sess.interner)};
let name_lit: ast::lit =
nospan(ast::lit_str(@ast_util::path_name_i(path)));
nospan(ast::lit_str(@ast_util::path_name_i(path, cx.sess.parse_sess
.interner)));
let name_expr_inner: @ast::expr =
@{id: cx.sess.next_node_id(),
callee_id: cx.sess.next_node_id(),
@ -313,7 +319,8 @@ fn mk_test_desc_rec(cx: test_ctxt, test: test) -> @ast::expr {
let name_field: ast::field =
nospan({mutbl: ast::m_imm, ident: @~"name", expr: @name_expr});
nospan({mutbl: ast::m_imm, ident: cx.sess.ident_of(~"name"),
expr: @name_expr});
let fn_path = path_node(path);
@ -326,7 +333,8 @@ fn mk_test_desc_rec(cx: test_ctxt, test: test) -> @ast::expr {
let fn_wrapper_expr = mk_test_wrapper(cx, fn_expr, span);
let fn_field: ast::field =
nospan({mutbl: ast::m_imm, ident: @~"fn", expr: fn_wrapper_expr});
nospan({mutbl: ast::m_imm, ident: cx.sess.ident_of(~"fn"),
expr: fn_wrapper_expr});
let ignore_lit: ast::lit = nospan(ast::lit_bool(test.ignore));
@ -337,7 +345,8 @@ fn mk_test_desc_rec(cx: test_ctxt, test: test) -> @ast::expr {
span: span};
let ignore_field: ast::field =
nospan({mutbl: ast::m_imm, ident: @~"ignore", expr: @ignore_expr});
nospan({mutbl: ast::m_imm, ident: cx.sess.ident_of(~"ignore"),
expr: @ignore_expr});
let fail_lit: ast::lit = nospan(ast::lit_bool(test.should_fail));
@ -349,7 +358,7 @@ fn mk_test_desc_rec(cx: test_ctxt, test: test) -> @ast::expr {
let fail_field: ast::field =
nospan({mutbl: ast::m_imm,
ident: @~"should_fail",
ident: cx.sess.ident_of(~"should_fail"),
expr: @fail_expr});
let desc_rec_: ast::expr_ =
@ -404,7 +413,7 @@ fn mk_test_wrapper(cx: test_ctxt,
}
fn mk_main(cx: test_ctxt) -> @ast::item {
let str_pt = path_node(~[@~"str"]);
let str_pt = path_node(~[cx.sess.ident_of(~"str")]);
let str_ty_inner = @{id: cx.sess.next_node_id(),
node: ast::ty_path(str_pt, cx.sess.next_node_id()),
span: dummy_sp()};
@ -423,7 +432,7 @@ fn mk_main(cx: test_ctxt) -> @ast::item {
let args_arg: ast::arg =
{mode: ast::expl(ast::by_val),
ty: @args_ty,
ident: @~"args",
ident: cx.sess.ident_of(~"args"),
id: cx.sess.next_node_id()};
let ret_ty = {id: cx.sess.next_node_id(),
@ -445,7 +454,7 @@ fn mk_main(cx: test_ctxt) -> @ast::item {
let item_ = ast::item_fn(decl, ~[], body);
let item: ast::item =
{ident: @~"main",
{ident: cx.sess.ident_of(~"main"),
attrs: ~[],
id: cx.sess.next_node_id(),
node: item_,
@ -457,7 +466,7 @@ fn mk_main(cx: test_ctxt) -> @ast::item {
fn mk_test_main_call(cx: test_ctxt) -> @ast::expr {
// Get the args passed to main so we can pass the to test_main
let args_path = path_node(~[@~"args"]);
let args_path = path_node(~[cx.sess.ident_of(~"args")]);
let args_path_expr_: ast::expr_ = ast::expr_path(args_path);
@ -466,7 +475,7 @@ fn mk_test_main_call(cx: test_ctxt) -> @ast::expr {
node: args_path_expr_, span: dummy_sp()};
// Call __test::test to generate the vector of test_descs
let test_path = path_node(~[@~"tests"]);
let test_path = path_node(~[cx.sess.ident_of(~"tests")]);
let test_path_expr_: ast::expr_ = ast::expr_path(test_path);
@ -481,7 +490,9 @@ fn mk_test_main_call(cx: test_ctxt) -> @ast::expr {
node: test_call_expr_, span: dummy_sp()};
// Call std::test::test_main
let test_main_path = path_node(mk_path(cx, ~[@~"test", @~"test_main"]));
let test_main_path = path_node(
mk_path(cx, ~[cx.sess.ident_of(~"test"),
cx.sess.ident_of(~"test_main")]));
let test_main_path_expr_: ast::expr_ = ast::expr_path(test_main_path);

2
src/rustc/metadata/common.rs
View file

@ -134,5 +134,5 @@ fn hash_path(&&s: ~str) -> uint {
return h;
}
type link_meta = {name: @~str, vers: @~str, extras_hash: ~str};
type link_meta = {name: ~str, vers: ~str, extras_hash: ~str};

77
src/rustc/metadata/creader.rs
View file

@ -10,6 +10,7 @@ import syntax::print::pprust;
import filesearch::filesearch;
import common::*;
import dvec::{DVec, dvec};
import syntax::parse::token::ident_interner;
export read_crates;
@ -17,14 +18,15 @@ 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) {
os: loader::os, static: bool, intr: ident_interner) {
let e = @{diag: diag,
filesearch: filesearch,
cstore: cstore,
os: os,
static: static,
crate_cache: dvec(),
mut next_crate_num: 1};
mut next_crate_num: 1,
intr: intr};
let v =
visit::mk_simple_visitor(@{visit_view_item:
|a| visit_view_item(e, a),
@ -32,13 +34,13 @@ fn read_crates(diag: span_handler, crate: ast::crate,
with *visit::default_simple_visitor()});
visit::visit_crate(crate, (), v);
dump_crates(e.crate_cache);
warn_if_multiple_versions(diag, e.crate_cache.get());
warn_if_multiple_versions(e, diag, e.crate_cache.get());
}
type cache_entry = {
cnum: int,
span: span,
hash: @~str,
hash: ~str,
metas: @~[@ast::meta_item]
};
@ -48,16 +50,10 @@ fn dump_crates(crate_cache: DVec<cache_entry>) {
debug!{"cnum: %?", entry.cnum};
debug!{"span: %?", entry.span};
debug!{"hash: %?", entry.hash};
let attrs = ~[
attr::mk_attr(attr::mk_list_item(@~"link", *entry.metas))
];
for attr::find_linkage_attrs(attrs).each |attr| {
debug!{"meta: %s", pprust::attr_to_str(attr)};
}
}
}
fn warn_if_multiple_versions(diag: span_handler,
fn warn_if_multiple_versions(e: env, diag: span_handler,
crate_cache: ~[cache_entry]) {
import either::*;
@ -77,17 +73,17 @@ fn warn_if_multiple_versions(diag: span_handler,
if matches.len() != 1u {
diag.handler().warn(
fmt!{"using multiple versions of crate `%s`", *name});
fmt!{"using multiple versions of crate `%s`", name});
for matches.each |match_| {
diag.span_note(match_.span, ~"used here");
let attrs = ~[
attr::mk_attr(attr::mk_list_item(@~"link", *match_.metas))
attr::mk_attr(attr::mk_list_item(~"link", *match_.metas))
];
loader::note_linkage_attrs(diag, attrs);
loader::note_linkage_attrs(e.intr, diag, attrs);
}
}
warn_if_multiple_versions(diag, non_matches);
warn_if_multiple_versions(e, diag, non_matches);
}
}
@ -97,7 +93,8 @@ type env = @{diag: span_handler,
os: loader::os,
static: bool,
crate_cache: DVec<cache_entry>,
mut next_crate_num: ast::crate_num};
mut next_crate_num: ast::crate_num,
intr: ident_interner};
fn visit_view_item(e: env, i: @ast::view_item) {
match i.node {
@ -125,28 +122,28 @@ fn visit_item(e: env, i: @ast::item) {
let foreign_name =
match attr::first_attr_value_str_by_name(i.attrs, ~"link_name") {
some(nn) => {
if *nn == ~"" {
if nn == ~"" {
e.diag.span_fatal(
i.span,
~"empty #[link_name] not allowed; use #[nolink].");
}
nn
}
none => i.ident
none => *e.intr.get(i.ident)
};
let mut already_added = false;
if vec::len(attr::find_attrs_by_name(i.attrs, ~"nolink")) == 0u {
already_added = !cstore::add_used_library(cstore, *foreign_name);
already_added = !cstore::add_used_library(cstore, foreign_name);
}
let link_args = attr::find_attrs_by_name(i.attrs, ~"link_args");
if vec::len(link_args) > 0u && already_added {
e.diag.span_fatal(i.span, ~"library '" + *foreign_name +
e.diag.span_fatal(i.span, ~"library '" + foreign_name +
~"' already added: can't specify link_args.");
}
for link_args.each |a| {
match attr::get_meta_item_value_str(attr::attr_meta(a)) {
some(linkarg) => {
cstore::add_used_link_args(cstore, *linkarg);
cstore::add_used_link_args(cstore, linkarg);
}
none => {/* fallthrough */ }
}
@ -156,19 +153,19 @@ fn visit_item(e: env, i: @ast::item) {
}
}
fn metas_with(ident: ast::ident, key: ast::ident,
metas: ~[@ast::meta_item]) -> ~[@ast::meta_item] {
let name_items = attr::find_meta_items_by_name(metas, *key);
fn metas_with(ident: ~str, key: ~str, metas: ~[@ast::meta_item])
-> ~[@ast::meta_item] {
let name_items = attr::find_meta_items_by_name(metas, key);
if name_items.is_empty() {
vec::append_one(metas, attr::mk_name_value_item_str(key, *ident))
vec::append_one(metas, attr::mk_name_value_item_str(key, ident))
} else {
metas
}
}
fn metas_with_ident(ident: ast::ident,
metas: ~[@ast::meta_item]) -> ~[@ast::meta_item] {
metas_with(ident, @~"name", metas)
fn metas_with_ident(ident: ~str, metas: ~[@ast::meta_item])
-> ~[@ast::meta_item] {
metas_with(ident, ~"name", metas)
}
fn existing_match(e: env, metas: ~[@ast::meta_item], hash: ~str) ->
@ -176,7 +173,7 @@ fn existing_match(e: env, metas: ~[@ast::meta_item], hash: ~str) ->
for e.crate_cache.each |c| {
if loader::metadata_matches(*c.metas, metas)
&& (hash.is_empty() || *c.hash == hash) {
&& (hash.is_empty() || c.hash == hash) {
return some(c.cnum);
}
}
@ -185,7 +182,7 @@ fn existing_match(e: env, metas: ~[@ast::meta_item], hash: ~str) ->
fn resolve_crate(e: env, ident: ast::ident, metas: ~[@ast::meta_item],
hash: ~str, span: span) -> ast::crate_num {
let metas = metas_with_ident(ident, metas);
let metas = metas_with_ident(*e.intr.get(ident), metas);
match existing_match(e, metas, hash) {
none => {
@ -197,7 +194,8 @@ fn resolve_crate(e: env, ident: ast::ident, metas: ~[@ast::meta_item],
metas: metas,
hash: hash,
os: e.os,
static: e.static
static: e.static,
intr: e.intr
};
let cinfo = loader::load_library_crate(load_ctxt);
@ -220,9 +218,9 @@ fn resolve_crate(e: env, ident: ast::ident, metas: ~[@ast::meta_item],
let cname =
match attr::last_meta_item_value_str_by_name(metas, ~"name") {
option::some(v) => v,
option::none => ident
option::none => *e.intr.get(ident)
};
let cmeta = @{name: *cname, data: cdata,
let cmeta = @{name: cname, data: cdata,
cnum_map: cnum_map, cnum: cnum};
let cstore = e.cstore;
@ -242,13 +240,14 @@ fn resolve_crate_deps(e: env, cdata: @~[u8]) -> cstore::cnum_map {
// The map from crate numbers in the crate we're resolving to local crate
// numbers
let cnum_map = int_hash::<ast::crate_num>();
for decoder::get_crate_deps(cdata).each |dep| {
for decoder::get_crate_deps(e.intr, cdata).each |dep| {
let extrn_cnum = dep.cnum;
let cname = dep.name;
let cmetas = metas_with(dep.vers, @~"vers", ~[]);
let cmetas = metas_with(dep.vers, ~"vers", ~[]);
debug!{"resolving dep crate %s ver: %s hash: %s",
*dep.name, *dep.vers, *dep.hash};
match existing_match(e, metas_with_ident(cname, cmetas), *dep.hash) {
*e.intr.get(dep.name), dep.vers, dep.hash};
match existing_match(e, metas_with_ident(*e.intr.get(cname), cmetas),
dep.hash) {
some(local_cnum) => {
debug!{"already have it"};
// We've already seen this crate
@ -260,8 +259,8 @@ fn resolve_crate_deps(e: env, cdata: @~[u8]) -> cstore::cnum_map {
// FIXME (#2404): Need better error reporting than just a bogus
// span.
let fake_span = ast_util::dummy_sp();
let local_cnum =
resolve_crate(e, cname, cmetas, *dep.hash, fake_span);
let local_cnum = resolve_crate(e, cname, cmetas, dep.hash,
fake_span);
cnum_map.insert(extrn_cnum, local_cnum);
}
}

24
src/rustc/metadata/csearch.rs
View file

@ -54,17 +54,17 @@ fn lookup_method_purity(cstore: cstore::cstore, did: ast::def_id)
fn each_path(cstore: cstore::cstore, cnum: ast::crate_num,
f: fn(decoder::path_entry) -> bool) {
let crate_data = cstore::get_crate_data(cstore, cnum);
decoder::each_path(crate_data, f);
decoder::each_path(cstore.intr, crate_data, f);
}
fn get_item_path(tcx: ty::ctxt, def: ast::def_id) -> ast_map::path {
let cstore = tcx.cstore;
let cdata = cstore::get_crate_data(cstore, def.crate);
let path = decoder::get_item_path(cdata, def.node);
let path = decoder::get_item_path(cstore.intr, cdata, def.node);
// FIXME #1920: This path is not always correct if the crate is not linked
// into the root namespace.
vec::append(~[ast_map::path_mod(@cdata.name)], path)
vec::append(~[ast_map::path_mod(tcx.sess.ident_of(cdata.name))], path)
}
enum found_ast {
@ -81,7 +81,7 @@ fn maybe_get_item_ast(tcx: ty::ctxt, def: ast::def_id,
-> found_ast {
let cstore = tcx.cstore;
let cdata = cstore::get_crate_data(cstore, def.crate);
decoder::maybe_get_item_ast(cdata, tcx, def.node,
decoder::maybe_get_item_ast(cstore.intr, cdata, tcx, def.node,
decode_inlined_item)
}
@ -89,14 +89,14 @@ fn get_enum_variants(tcx: ty::ctxt, def: ast::def_id)
-> ~[ty::variant_info] {
let cstore = tcx.cstore;
let cdata = cstore::get_crate_data(cstore, def.crate);
return decoder::get_enum_variants(cdata, def.node, tcx)
return decoder::get_enum_variants(cstore.intr, cdata, def.node, tcx)
}
fn get_impls_for_mod(cstore: cstore::cstore, def: ast::def_id,
name: option<ast::ident>)
-> @~[@decoder::_impl] {
let cdata = cstore::get_crate_data(cstore, def.crate);
do decoder::get_impls_for_mod(cdata, def.node, name) |cnum| {
do decoder::get_impls_for_mod(cstore.intr, cdata, def.node, name) |cnum| {
cstore::get_crate_data(cstore, cnum)
}
}
@ -104,14 +104,14 @@ fn get_impls_for_mod(cstore: cstore::cstore, def: ast::def_id,
fn get_trait_methods(tcx: ty::ctxt, def: ast::def_id) -> @~[ty::method] {
let cstore = tcx.cstore;
let cdata = cstore::get_crate_data(cstore, def.crate);
decoder::get_trait_methods(cdata, def.node, tcx)
decoder::get_trait_methods(cstore.intr, cdata, def.node, tcx)
}
fn get_method_names_if_trait(cstore: cstore::cstore, def: ast::def_id)
-> option<@DVec<(@~str, ast::self_ty_)>> {
-> option<@DVec<(ast::ident, ast::self_ty_)>> {
let cdata = cstore::get_crate_data(cstore, def.crate);
return decoder::get_method_names_if_trait(cdata, def.node);
return decoder::get_method_names_if_trait(cstore.intr, cdata, def.node);
}
fn get_item_attrs(cstore: cstore::cstore,
@ -125,7 +125,7 @@ fn get_item_attrs(cstore: cstore::cstore,
fn get_class_fields(tcx: ty::ctxt, def: ast::def_id) -> ~[ty::field_ty] {
let cstore = tcx.cstore;
let cdata = cstore::get_crate_data(cstore, def.crate);
decoder::get_class_fields(cdata, def.node)
decoder::get_class_fields(cstore.intr, cdata, def.node)
}
fn get_type(tcx: ty::ctxt, def: ast::def_id) -> ty::ty_param_bounds_and_ty {
@ -173,7 +173,7 @@ fn get_impl_method(cstore: cstore::cstore,
def: ast::def_id, mname: ast::ident)
-> ast::def_id {
let cdata = cstore::get_crate_data(cstore, def.crate);
decoder::get_impl_method(cdata, def.node, mname)
decoder::get_impl_method(cstore.intr, cdata, def.node, mname)
}
/* Because classes use the trait format rather than the impl format
@ -184,7 +184,7 @@ fn get_class_method(cstore: cstore::cstore,
def: ast::def_id, mname: ast::ident)
-> ast::def_id {
let cdata = cstore::get_crate_data(cstore, def.crate);
decoder::get_class_method(cdata, def.node, mname)
decoder::get_class_method(cstore.intr, cdata, def.node, mname)
}
/* If def names a class with a dtor, return it. Otherwise, return none. */

36
src/rustc/metadata/cstore.rs
View file

@ -5,6 +5,7 @@ import std::map;
import std::map::hashmap;
import syntax::{ast, attr};
import syntax::ast_util::new_def_hash;
import syntax::parse::token::ident_interner;
export cstore;
export cnum_map;
@ -57,7 +58,8 @@ type cstore_private =
mod_path_map: mod_path_map,
mut used_crate_files: ~[~str],
mut used_libraries: ~[~str],
mut used_link_args: ~[~str]};
mut used_link_args: ~[~str],
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>;
@ -67,7 +69,7 @@ pure fn p(cstore: cstore) -> cstore_private {
match cstore { private(p) => p }
}
fn mk_cstore() -> cstore {
fn mk_cstore(intr: ident_interner) -> cstore {
let meta_cache = map::int_hash::<crate_metadata>();
let crate_map = map::int_hash::<ast::crate_num>();
let mod_path_map = new_def_hash();
@ -76,19 +78,20 @@ fn mk_cstore() -> cstore {
mod_path_map: mod_path_map,
mut used_crate_files: ~[],
mut used_libraries: ~[],
mut used_link_args: ~[]});
mut used_link_args: ~[],
intr: intr});
}
fn get_crate_data(cstore: cstore, cnum: ast::crate_num) -> crate_metadata {
return p(cstore).metas.get(cnum);
}
fn get_crate_hash(cstore: cstore, cnum: ast::crate_num) -> @~str {
fn get_crate_hash(cstore: cstore, cnum: ast::crate_num) -> ~str {
let cdata = get_crate_data(cstore, cnum);
return decoder::get_crate_hash(cdata.data);
}
fn get_crate_vers(cstore: cstore, cnum: ast::crate_num) -> @~str {
fn get_crate_vers(cstore: cstore, cnum: ast::crate_num) -> ~str {
let cdata = get_crate_data(cstore, cnum);
return decoder::get_crate_vers(cdata.data);
}
@ -96,7 +99,7 @@ fn get_crate_vers(cstore: cstore, cnum: ast::crate_num) -> @~str {
fn set_crate_data(cstore: cstore, cnum: ast::crate_num,
data: crate_metadata) {
p(cstore).metas.insert(cnum, data);
do vec::iter(decoder::get_crate_module_paths(data)) |dp| {
do vec::iter(decoder::get_crate_module_paths(cstore.intr, data)) |dp| {
let (did, path) = dp;
let d = {crate: cnum, node: did.node};
p(cstore).mod_path_map.insert(d, @path);
@ -153,32 +156,29 @@ fn find_use_stmt_cnum(cstore: cstore,
// returns hashes of crates directly used by this crate. Hashes are
// sorted by crate name.
fn get_dep_hashes(cstore: cstore) -> ~[@~str] {
type crate_hash = {name: @~str, hash: @~str};
fn get_dep_hashes(cstore: cstore) -> ~[~str] {
type crate_hash = {name: ~str, hash: ~str};
let mut result = ~[];
for p(cstore).use_crate_map.each_value |cnum| {
let cdata = cstore::get_crate_data(cstore, cnum);
let hash = decoder::get_crate_hash(cdata.data);
debug!{"Add hash[%s]: %s", cdata.name, *hash};
vec::push(result, {name: @cdata.name, hash: hash});
debug!{"Add hash[%s]: %s", cdata.name, hash};
vec::push(result, {name: cdata.name, hash: hash});
};
pure fn lteq(a: &crate_hash, b: &crate_hash) -> bool {
*a.name <= *b.name
}
pure fn lteq(a: &crate_hash, b: &crate_hash) -> bool {a.name <= b.name}
let sorted = std::sort::merge_sort(lteq, result);
debug!{"sorted:"};
for sorted.each |x| {
debug!{" hash[%s]: %s", *x.name, *x.hash};
debug!{" hash[%s]: %s", x.name, x.hash};
}
fn mapper(ch: crate_hash) -> @~str { return ch.hash; }
fn mapper(ch: crate_hash) -> ~str { return ch.hash; }
return vec::map(sorted, mapper);
}
fn get_path(cstore: cstore, d: ast::def_id) -> ~[ast::ident] {
// let f = bind str::split_str(_, "::");
fn get_path(cstore: cstore, d: ast::def_id) -> ~[~str] {
option::map_default(p(cstore).mod_path_map.find(d), ~[],
|ds| str::split_str(*ds, ~"::").map(|x| @x ) )
|ds| str::split_str(*ds, ~"::"))
}
// Local Variables:
// mode: rust

145
src/rustc/metadata/decoder.rs
View file

@ -15,6 +15,8 @@ import cmd=cstore::crate_metadata;
import util::ppaux::ty_to_str;
import syntax::diagnostic::span_handler;
import common::*;
import syntax::parse::token::ident_interner;
export class_dtor;
export get_class_fields;
@ -212,7 +214,7 @@ fn enum_variant_ids(item: ebml::doc, cdata: cmd) -> ~[ast::def_id] {
return ids;
}
fn item_path(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);
@ -224,10 +226,10 @@ fn item_path(item_doc: ebml::doc) -> ast_map::path {
for ebml::docs(path_doc) |tag, elt_doc| {
if tag == tag_path_elt_mod {
let str = ebml::doc_as_str(elt_doc);
vec::push(result, ast_map::path_mod(@str));
vec::push(result, ast_map::path_mod(intr.intern(@str)));
} else if tag == tag_path_elt_name {
let str = ebml::doc_as_str(elt_doc);
vec::push(result, ast_map::path_name(@str));
vec::push(result, ast_map::path_name(intr.intern(@str)));
} else {
// ignore tag_path_len element
}
@ -236,9 +238,9 @@ fn item_path(item_doc: ebml::doc) -> ast_map::path {
return result;
}
fn item_name(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);
@str::from_bytes(ebml::doc_data(name))
intr.intern(@str::from_bytes(ebml::doc_data(name)))
}
fn item_to_def_like(item: ebml::doc, did: ast::def_id, cnum: ast::crate_num)
@ -304,37 +306,38 @@ 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(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;
for ebml::tagged_docs(find_item(id, items), tag_item_impl_method) |mid| {
let m_did = ebml::with_doc_data(mid, |d| parse_def_id(d));
if item_name(find_item(m_did.node, items)) == name {
if item_name(intr, find_item(m_did.node, items)) == name {
found = some(translate_def_id(cdata, m_did));
}
}
option::get(found)
}
fn get_class_method(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;
let cls_items = match maybe_find_item(id, items) {
some(it) => it,
none => fail (fmt!{"get_class_method: class id not found \
when looking up method %s", *name})
when looking up method %s", *intr.get(name)})
};
for ebml::tagged_docs(cls_items, tag_item_trait_method) |mid| {
let m_did = item_def_id(mid, cdata);
if item_name(mid) == name {
if item_name(intr, mid) == name {
found = some(m_did);
}
}
match found {
some(found) => found,
none => fail (fmt!{"get_class_method: no method named %s", *name})
none => fail (fmt!{"get_class_method: no method named %s",
*intr.get(name)})
}
}
@ -387,7 +390,7 @@ struct path_entry {
}
/// Iterates over all the paths in the given crate.
fn each_path(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);
@ -397,8 +400,8 @@ fn each_path(cdata: cmd, f: fn(path_entry) -> bool) {
// First, go through all the explicit items.
for ebml::tagged_docs(items_data, tag_items_data_item) |item_doc| {
if !broken {
let path = ast_map::path_to_str_with_sep(item_path(item_doc),
~"::");
let path = ast_map::path_to_str_with_sep(
item_path(intr, item_doc), ~"::", intr);
if path != ~"" {
// Extract the def ID.
let def_id = item_def_id(item_doc, cdata);
@ -467,8 +470,9 @@ fn each_path(cdata: cmd, f: fn(path_entry) -> bool) {
}
}
fn get_item_path(cdata: cmd, id: ast::node_id) -> ast_map::path {
item_path(lookup_item(id, cdata.data))
fn get_item_path(intr: ident_interner, cdata: cmd, id: ast::node_id)
-> ast_map::path {
item_path(intr, lookup_item(id, cdata.data))
}
type decode_inlined_item = fn(
@ -477,13 +481,13 @@ type decode_inlined_item = fn(
path: ast_map::path,
par_doc: ebml::doc) -> option<ast::inlined_item>;
fn maybe_get_item_ast(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 {
debug!{"Looking up item: %d", id};
let item_doc = lookup_item(id, cdata.data);
let path = vec::init(item_path(item_doc));
let path = vec::init(item_path(intr, item_doc));
match decode_inlined_item(cdata, tcx, path, item_doc) {
some(ii) => csearch::found(ii),
none => {
@ -503,8 +507,8 @@ fn maybe_get_item_ast(cdata: cmd, tcx: ty::ctxt,
}
}
fn get_enum_variants(cdata: cmd, id: ast::node_id, tcx: ty::ctxt)
-> ~[ty::variant_info] {
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);
let item = find_item(id, items);
@ -515,7 +519,7 @@ fn get_enum_variants(cdata: cmd, id: ast::node_id, tcx: ty::ctxt)
let item = find_item(did.node, items);
let ctor_ty = item_type({crate: cdata.cnum, node: id}, item,
tcx, cdata);
let name = item_name(item);
let name = item_name(intr, item);
let mut arg_tys: ~[ty::t] = ~[];
match ty::get(ctor_ty).struct {
ty::ty_fn(f) => {
@ -573,8 +577,8 @@ fn get_self_ty(item: ebml::doc) -> ast::self_ty_ {
}
}
fn item_impl_methods(cdata: cmd, item: ebml::doc, base_tps: uint)
-> ~[@method_info] {
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| {
let m_did = ebml::with_doc_data(doc, |d| parse_def_id(d));
@ -583,15 +587,14 @@ fn item_impl_methods(cdata: cmd, item: ebml::doc, base_tps: uint)
vec::push(rslt, @{did: translate_def_id(cdata, m_did),
/* FIXME (maybe #2323) tjc: take a look at this. */
n_tps: item_ty_param_count(mth_item) - base_tps,
ident: item_name(mth_item),
ident: item_name(intr, mth_item),
self_type: self_ty});
}
rslt
}
fn get_impls_for_mod(cdata: cmd,
m_id: ast::node_id,
name: option<ast::ident>,
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] {
@ -608,12 +611,12 @@ fn get_impls_for_mod(cdata: cmd,
let impl_cdata = get_cdata(local_did.crate);
let impl_data = impl_cdata.data;
let item = lookup_item(local_did.node, impl_data);
let nm = item_name(item);
let nm = item_name(intr, item);
if match name { some(n) => { n == nm } none => { true } } {
let base_tps = item_ty_param_count(item);
vec::push(result, @{
did: local_did, ident: nm,
methods: item_impl_methods(impl_cdata, item, base_tps)
methods: item_impl_methods(intr, impl_cdata, item, base_tps)
});
};
}
@ -621,14 +624,14 @@ fn get_impls_for_mod(cdata: cmd,
}
/* Works for both classes and traits */
fn get_trait_methods(cdata: cmd, id: ast::node_id, tcx: ty::ctxt)
-> @~[ty::method] {
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);
let mut result = ~[];
for ebml::tagged_docs(item, tag_item_trait_method) |mth| {
let bounds = item_ty_param_bounds(mth, tcx, cdata);
let name = item_name(mth);
let name = item_name(intr, mth);
let ty = doc_type(mth, tcx, cdata);
let fty = match ty::get(ty).struct {
ty::ty_fn(f) => f,
@ -651,8 +654,9 @@ fn get_trait_methods(cdata: cmd, id: ast::node_id, tcx: ty::ctxt)
// 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(cdata: cmd, node_id: ast::node_id)
-> option<@DVec<(@~str, ast::self_ty_)>> {
fn get_method_names_if_trait(intr: ident_interner, cdata: cmd,
node_id: ast::node_id)
-> option<@DVec<(ast::ident, ast::self_ty_)>> {
let item = lookup_item(node_id, cdata.data);
if item_family(item) != 'I' {
@ -662,7 +666,7 @@ fn get_method_names_if_trait(cdata: cmd, node_id: ast::node_id)
let resulting_methods = @dvec();
for ebml::tagged_docs(item, tag_item_trait_method) |method| {
resulting_methods.push(
(item_name(method), get_self_ty(method)));
(item_name(intr, method), get_self_ty(method)));
}
return some(resulting_methods);
}
@ -680,7 +684,7 @@ fn get_item_attrs(cdata: cmd,
}
// Helper function that gets either fields or methods
fn get_class_members(cdata: cmd, id: ast::node_id,
fn get_class_members(intr: ident_interner, cdata: cmd, id: ast::node_id,
p: fn(char) -> bool) -> ~[ty::field_ty] {
let data = cdata.data;
let item = lookup_item(id, data);
@ -688,7 +692,7 @@ fn get_class_members(cdata: cmd, id: ast::node_id,
for ebml::tagged_docs(item, tag_item_field) |an_item| {
let f = item_family(an_item);
if p(f) {
let name = item_name(an_item);
let name = item_name(intr, an_item);
let did = item_def_id(an_item, cdata);
let mt = field_mutability(an_item);
vec::push(result, {ident: name, id: did, vis:
@ -708,8 +712,9 @@ pure fn family_to_visibility(family: char) -> ast::visibility {
}
/* 'g' for public field, 'j' for private field, 'N' for inherited field */
fn get_class_fields(cdata: cmd, id: ast::node_id) -> ~[ty::field_ty] {
get_class_members(cdata, id, |f| f == 'g' || f == 'j' || f == 'N')
fn get_class_fields(intr: ident_interner, cdata: cmd, id: ast::node_id)
-> ~[ty::field_ty] {
get_class_members(intr, cdata, id, |f| f == 'g' || f == 'j' || f == 'N')
}
fn family_has_type_params(fam_ch: char) -> bool {
@ -774,7 +779,7 @@ fn get_meta_items(md: ebml::doc) -> ~[@ast::meta_item] {
for ebml::tagged_docs(md, tag_meta_item_word) |meta_item_doc| {
let nd = ebml::get_doc(meta_item_doc, tag_meta_item_name);
let n = str::from_bytes(ebml::doc_data(nd));
vec::push(items, attr::mk_word_item(@n));
vec::push(items, attr::mk_word_item(n));
};
for ebml::tagged_docs(md, tag_meta_item_name_value) |meta_item_doc| {
let nd = ebml::get_doc(meta_item_doc, tag_meta_item_name);
@ -783,13 +788,13 @@ fn get_meta_items(md: ebml::doc) -> ~[@ast::meta_item] {
let v = str::from_bytes(ebml::doc_data(vd));
// FIXME (#623): Should be able to decode meta_name_value variants,
// but currently the encoder just drops them
vec::push(items, attr::mk_name_value_item_str(@n, v));
vec::push(items, attr::mk_name_value_item_str(n, v));
};
for ebml::tagged_docs(md, tag_meta_item_list) |meta_item_doc| {
let nd = ebml::get_doc(meta_item_doc, tag_meta_item_name);
let n = str::from_bytes(ebml::doc_data(nd));
let subitems = get_meta_items(meta_item_doc);
vec::push(items, attr::mk_list_item(@n, subitems));
vec::push(items, attr::mk_list_item(n, subitems));
};
return items;
}
@ -815,17 +820,19 @@ fn get_attributes(md: ebml::doc) -> ~[ast::attribute] {
return attrs;
}
fn list_meta_items(meta_items: ebml::doc, out: io::Writer) {
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)});
out.write_str(fmt!{"%s\n", pprust::meta_item_to_str(*mi, intr)});
}
}
fn list_crate_attributes(md: ebml::doc, hash: @~str, out: io::Writer) {
out.write_str(fmt!{"=Crate Attributes (%s)=\n", *hash});
fn list_crate_attributes(intr: ident_interner, md: ebml::doc, hash: ~str,
out: io::Writer) {
out.write_str(fmt!{"=Crate Attributes (%s)=\n", hash});
for get_attributes(md).each |attr| {
out.write_str(fmt!{"%s\n", pprust::attribute_to_str(attr)});
out.write_str(fmt!{"%s\n", pprust::attribute_to_str(attr, intr)});
}
out.write_str(~"\n\n");
@ -836,9 +843,9 @@ fn get_crate_attributes(data: @~[u8]) -> ~[ast::attribute] {
}
type crate_dep = {cnum: ast::crate_num, name: ast::ident,
vers: @~str, hash: @~str};
vers: ~str, hash: ~str};
fn get_crate_deps(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);
@ -848,42 +855,44 @@ fn get_crate_deps(data: @~[u8]) -> ~[crate_dep] {
}
for ebml::tagged_docs(depsdoc, tag_crate_dep) |depdoc| {
vec::push(deps, {cnum: crate_num,
name: @docstr(depdoc, tag_crate_dep_name),
vers: @docstr(depdoc, tag_crate_dep_vers),
hash: @docstr(depdoc, tag_crate_dep_hash)});
name: intr.intern(@docstr(depdoc, tag_crate_dep_name)),
vers: docstr(depdoc, tag_crate_dep_vers),
hash: docstr(depdoc, tag_crate_dep_hash)});
crate_num += 1;
};
return deps;
}
fn list_crate_deps(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(data).each |dep| {
out.write_str(fmt!{"%d %s-%s-%s\n",
dep.cnum, *dep.name, *dep.hash, *dep.vers});
for get_crate_deps(intr, data).each |dep| {
out.write_str(
fmt!{"%d %s-%s-%s\n",
dep.cnum, *intr.get(dep.name), dep.hash, dep.vers});
}
out.write_str(~"\n");
}
fn get_crate_hash(data: @~[u8]) -> @~str {
fn get_crate_hash(data: @~[u8]) -> ~str {
let cratedoc = ebml::doc(data);
let hashdoc = ebml::get_doc(cratedoc, tag_crate_hash);
return @str::from_bytes(ebml::doc_data(hashdoc));
return str::from_bytes(ebml::doc_data(hashdoc));
}
fn get_crate_vers(data: @~[u8]) -> @~str {
fn get_crate_vers(data: @~[u8]) -> ~str {
let attrs = decoder::get_crate_attributes(data);
return match attr::last_meta_item_value_str_by_name(
attr::find_linkage_metas(attrs), ~"vers") {
some(ver) => ver,
none => @~"0.0"
none => ~"0.0"
};
}
fn iter_crate_items(cdata: cmd, proc: fn(~str, ast::def_id)) {
for each_path(cdata) |path_entry| {
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 {
dl_impl(*) | dl_field => {}
dl_def(def) => {
@ -893,7 +902,8 @@ fn iter_crate_items(cdata: cmd, proc: fn(~str, ast::def_id)) {
}
}
fn get_crate_module_paths(cdata: cmd) -> ~[(ast::def_id, ~str)] {
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, ~"::")), ~"::")
}
@ -902,7 +912,7 @@ fn get_crate_module_paths(cdata: cmd) -> ~[(ast::def_id, ~str)] {
// fowarded path due to renamed import or reexport
let mut res = ~[];
let mods = map::str_hash();
do iter_crate_items(cdata) |path, did| {
do iter_crate_items(intr, cdata) |path, did| {
let m = mod_of_path(path);
if str::is_not_empty(m) {
// if m has a sub-item, it must be a module
@ -919,11 +929,12 @@ fn get_crate_module_paths(cdata: cmd) -> ~[(ast::def_id, ~str)] {
}
}
fn list_crate_metadata(bytes: @~[u8], out: io::Writer) {
fn list_crate_metadata(intr: ident_interner, bytes: @~[u8],
out: io::Writer) {
let hash = get_crate_hash(bytes);
let md = ebml::doc(bytes);
list_crate_attributes(md, hash, out);
list_crate_deps(bytes, out);
list_crate_attributes(intr, md, hash, out);
list_crate_deps(intr, bytes, out);
}
// Translates a def_id from an external crate to a def_id for the current

160
src/rustc/metadata/encoder.rs
View file

@ -71,8 +71,8 @@ fn reachable(ecx: @encode_ctxt, id: node_id) -> bool {
ecx.reachable.contains_key(id)
}
fn encode_name(ebml_w: ebml::writer, name: ident) {
ebml_w.wr_tagged_str(tag_paths_data_name, *name);
fn encode_name(ecx: @encode_ctxt, ebml_w: ebml::writer, name: ident) {
ebml_w.wr_tagged_str(tag_paths_data_name, ecx.tcx.sess.str_of(name));
}
fn encode_def_id(ebml_w: ebml::writer, id: def_id) {
@ -97,12 +97,14 @@ fn encode_mutability(ebml_w: ebml::writer, mt: class_mutability) {
type entry<T> = {val: T, pos: uint};
fn add_to_index(ebml_w: ebml::writer, path: &[ident], &index: ~[entry<~str>],
name: ident) {
fn add_to_index(ecx: @encode_ctxt, ebml_w: ebml::writer, path: &[ident],
&index: ~[entry<~str>], name: ident) {
let mut full_path = ~[];
vec::push_all(full_path, path);
vec::push(full_path, name);
vec::push(index, {val: ast_util::path_name_i(full_path),
vec::push(index,
{val: ast_util::path_name_i(full_path,
ecx.tcx.sess.parse_sess.interner),
pos: ebml_w.writer.tell()});
}
@ -209,7 +211,7 @@ fn encode_enum_variant_info(ecx: @encode_ctxt, ebml_w: ebml::writer,
ebml_w.start_tag(tag_items_data_item);
encode_def_id(ebml_w, local_def(variant.node.id));
encode_family(ebml_w, 'v');
encode_name(ebml_w, variant.node.name);
encode_name(ecx, ebml_w, variant.node.name);
encode_parent_item(ebml_w, local_def(id));
encode_type(ecx, ebml_w,
node_id_to_type(ecx.tcx, variant.node.id));
@ -227,29 +229,29 @@ fn encode_enum_variant_info(ecx: @encode_ctxt, ebml_w: ebml::writer,
disr_val = vi[i].disr_val;
}
encode_type_param_bounds(ebml_w, ecx, ty_params);
encode_path(ebml_w, path, ast_map::path_name(variant.node.name));
encode_path(ecx, ebml_w, path, ast_map::path_name(variant.node.name));
ebml_w.end_tag();
disr_val += 1;
i += 1;
}
}
fn encode_path(ebml_w: ebml::writer,
path: ast_map::path,
fn encode_path(ecx: @encode_ctxt, ebml_w: ebml::writer, path: ast_map::path,
name: ast_map::path_elt) {
fn encode_path_elt(ebml_w: ebml::writer, elt: ast_map::path_elt) {
fn encode_path_elt(ecx: @encode_ctxt, ebml_w: ebml::writer,
elt: ast_map::path_elt) {
let (tag, name) = match elt {
ast_map::path_mod(name) => (tag_path_elt_mod, name),
ast_map::path_name(name) => (tag_path_elt_name, name)
};
ebml_w.wr_tagged_str(tag, *name);
ebml_w.wr_tagged_str(tag, ecx.tcx.sess.str_of(name));
}
do ebml_w.wr_tag(tag_path) {
ebml_w.wr_tagged_u32(tag_path_len, (vec::len(path) + 1u) as u32);
do vec::iter(path) |pe| { encode_path_elt(ebml_w, pe); }
encode_path_elt(ebml_w, name);
do vec::iter(path) |pe| { encode_path_elt(ecx, ebml_w, pe); }
encode_path_elt(ecx, ebml_w, name);
}
}
@ -258,7 +260,7 @@ fn encode_info_for_mod(ecx: @encode_ctxt, ebml_w: ebml::writer, md: _mod,
ebml_w.start_tag(tag_items_data_item);
encode_def_id(ebml_w, local_def(id));
encode_family(ebml_w, 'm');
encode_name(ebml_w, name);
encode_name(ecx, ebml_w, name);
debug!{"(encoding info for module) encoding info for module ID %d", id};
// Encode info about all the module children.
@ -268,9 +270,10 @@ fn encode_info_for_mod(ecx: @encode_ctxt, ebml_w: ebml::writer, md: _mod,
let (ident, did) = (item.ident, item.id);
debug!{"(encoding info for module) ... encoding impl %s \
(%?/%?), exported? %?",
*ident,
ecx.tcx.sess.str_of(ident),
did,
ast_map::node_id_to_str(ecx.tcx.items, did),
ast_map::node_id_to_str(ecx.tcx.items, did, ecx.tcx
.sess.parse_sess.interner),
ast_util::is_exported(ident, md)};
ebml_w.start_tag(tag_mod_impl);
@ -281,7 +284,7 @@ fn encode_info_for_mod(ecx: @encode_ctxt, ebml_w: ebml::writer, md: _mod,
}
}
encode_path(ebml_w, path, ast_map::path_mod(name));
encode_path(ecx, ebml_w, path, ast_map::path_mod(name));
// Encode the reexports of this module.
debug!("(encoding info for module) encoding reexports for %d", id);
@ -371,10 +374,11 @@ fn encode_info_for_class(ecx: @encode_ctxt, ebml_w: ebml::writer,
vec::push(*global_index, {val: id,
pos: ebml_w.writer.tell()});
ebml_w.start_tag(tag_items_data_item);
debug!{"encode_info_for_class: doing %s %d", *nm, id};
debug!{"encode_info_for_class: doing %s %d",
tcx.sess.str_of(nm), id};
encode_visibility(ebml_w, vis);
encode_name(ebml_w, nm);
encode_path(ebml_w, path, ast_map::path_name(nm));
encode_name(ecx, ebml_w, nm);
encode_path(ecx, ebml_w, path, ast_map::path_name(nm));
encode_type(ecx, ebml_w, node_id_to_type(tcx, id));
encode_mutability(ebml_w, mt);
encode_def_id(ebml_w, local_def(id));
@ -392,7 +396,8 @@ fn encode_info_for_class(ecx: @encode_ctxt, ebml_w: ebml::writer,
{val: m.id, pos: ebml_w.writer.tell()});
let impl_path = vec::append_one(path,
ast_map::path_name(m.ident));
debug!{"encode_info_for_class: doing %s %d", *m.ident, m.id};
debug!{"encode_info_for_class: doing %s %d",
ecx.tcx.sess.str_of(m.ident), m.id};
encode_info_for_method(ecx, ebml_w, impl_path,
should_inline(m.attrs), id, m,
vec::append(class_tps, m.tps));
@ -409,15 +414,16 @@ fn encode_info_for_fn(ecx: @encode_ctxt, ebml_w: ebml::writer,
item: option<inlined_item>, tps: ~[ty_param],
decl: fn_decl) {
ebml_w.start_tag(tag_items_data_item);
encode_name(ebml_w, ident);
encode_name(ecx, ebml_w, ident);
encode_def_id(ebml_w, local_def(id));
encode_family(ebml_w, purity_fn_family(decl.purity));
encode_type_param_bounds(ebml_w, ecx, tps);
let its_ty = node_id_to_type(ecx.tcx, id);
debug!{"fn name = %s ty = %s its node id = %d", *ident,
debug!{"fn name = %s ty = %s its node id = %d",
ecx.tcx.sess.str_of(ident),
util::ppaux::ty_to_str(ecx.tcx, its_ty), id};
encode_type(ecx, ebml_w, its_ty);
encode_path(ebml_w, path, ast_map::path_name(ident));
encode_path(ecx, ebml_w, path, ast_map::path_name(ident));
match item {
some(it) => {
ecx.encode_inlined_item(ecx, ebml_w, path, it);
@ -433,14 +439,15 @@ fn encode_info_for_method(ecx: @encode_ctxt, ebml_w: ebml::writer,
impl_path: ast_map::path, should_inline: bool,
parent_id: node_id,
m: @method, all_tps: ~[ty_param]) {
debug!{"encode_info_for_method: %d %s %u", m.id, *m.ident, all_tps.len()};
debug!{"encode_info_for_method: %d %s %u", m.id,
ecx.tcx.sess.str_of(m.ident), all_tps.len()};
ebml_w.start_tag(tag_items_data_item);
encode_def_id(ebml_w, local_def(m.id));
encode_family(ebml_w, purity_fn_family(m.decl.purity));
encode_type_param_bounds(ebml_w, ecx, all_tps);
encode_type(ecx, ebml_w, node_id_to_type(ecx.tcx, m.id));
encode_name(ebml_w, m.ident);
encode_path(ebml_w, impl_path, ast_map::path_name(m.ident));
encode_name(ecx, ebml_w, m.ident);
encode_path(ecx, ebml_w, impl_path, ast_map::path_name(m.ident));
encode_self_type(ebml_w, m.self_ty.node);
if all_tps.len() > 0u || should_inline {
ecx.encode_inlined_item(
@ -504,7 +511,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
encode_family(ebml_w, 'c');
encode_type(ecx, ebml_w, node_id_to_type(tcx, item.id));
encode_symbol(ecx, ebml_w, item.id);
encode_path(ebml_w, path, ast_map::path_name(item.ident));
encode_path(ecx, ebml_w, path, ast_map::path_name(item.ident));
ebml_w.end_tag();
}
item_fn(decl, tps, _) => {
@ -514,7 +521,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
encode_family(ebml_w, purity_fn_family(decl.purity));
encode_type_param_bounds(ebml_w, ecx, tps);
encode_type(ecx, ebml_w, node_id_to_type(tcx, item.id));
encode_path(ebml_w, path, ast_map::path_name(item.ident));
encode_path(ecx, ebml_w, path, ast_map::path_name(item.ident));
if tps.len() > 0u || should_inline(item.attrs) {
ecx.encode_inlined_item(ecx, ebml_w, path, ii_item(item));
} else {
@ -531,8 +538,8 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
ebml_w.start_tag(tag_items_data_item);
encode_def_id(ebml_w, local_def(item.id));
encode_family(ebml_w, 'n');
encode_name(ebml_w, item.ident);
encode_path(ebml_w, path, ast_map::path_name(item.ident));
encode_name(ecx, ebml_w, item.ident);
encode_path(ecx, ebml_w, path, ast_map::path_name(item.ident));
ebml_w.end_tag();
}
item_ty(_, tps) => {
@ -542,8 +549,8 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
encode_family(ebml_w, 'y');
encode_type_param_bounds(ebml_w, ecx, tps);
encode_type(ecx, ebml_w, node_id_to_type(tcx, item.id));
encode_name(ebml_w, item.ident);
encode_path(ebml_w, path, ast_map::path_name(item.ident));
encode_name(ecx, ebml_w, item.ident);
encode_path(ecx, ebml_w, path, ast_map::path_name(item.ident));
encode_region_param(ecx, ebml_w, item);
ebml_w.end_tag();
}
@ -554,12 +561,12 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
encode_family(ebml_w, 't');
encode_type_param_bounds(ebml_w, ecx, tps);
encode_type(ecx, ebml_w, node_id_to_type(tcx, item.id));
encode_name(ebml_w, item.ident);
encode_name(ecx, ebml_w, item.ident);
for enum_definition.variants.each |v| {
encode_variant_id(ebml_w, local_def(v.node.id));
}
ecx.encode_inlined_item(ecx, ebml_w, path, ii_item(item));
encode_path(ebml_w, path, ast_map::path_name(item.ident));
encode_path(ecx, ebml_w, path, ast_map::path_name(item.ident));
encode_region_param(ecx, ebml_w, item);
}
encode_enum_variant_info(ecx, ebml_w, item.id,
@ -576,8 +583,10 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
/* Encode the dtor */
do option::iter(struct_def.dtor) |dtor| {
vec::push(*index, {val: dtor.node.id, pos: ebml_w.writer.tell()});
encode_info_for_fn(ecx, ebml_w, dtor.node.id, @(*item.ident
+ ~"_dtor"), path, if tps.len() > 0u {
encode_info_for_fn(ecx, ebml_w, dtor.node.id,
ecx.tcx.sess.ident_of(
ecx.tcx.sess.str_of(item.ident) + ~"_dtor"),
path, if tps.len() > 0u {
some(ii_dtor(dtor, item.ident, tps,
local_def(item.id))) }
else { none }, tps, ast_util::dtor_dec());
@ -596,8 +605,8 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
encode_type_param_bounds(ebml_w, ecx, tps);
encode_type(ecx, ebml_w, node_id_to_type(tcx, item.id));
encode_name(ebml_w, item.ident);
encode_path(ebml_w, path, ast_map::path_name(item.ident));
encode_name(ecx, ebml_w, item.ident);
encode_path(ecx, ebml_w, path, ast_map::path_name(item.ident));
encode_region_param(ecx, ebml_w, item);
for struct_def.traits.each |t| {
encode_trait_ref(ebml_w, ecx, t);
@ -618,7 +627,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
named_field(ident, mutability, vis) => {
ebml_w.start_tag(tag_item_field);
encode_visibility(ebml_w, vis);
encode_name(ebml_w, ident);
encode_name(ecx, ebml_w, ident);
encode_def_id(ebml_w, local_def(f.node.id));
ebml_w.end_tag();
}
@ -634,7 +643,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
as a trait */
ebml_w.start_tag(tag_item_trait_method);
encode_family(ebml_w, purity_fn_family(m.decl.purity));
encode_name(ebml_w, m.ident);
encode_name(ecx, ebml_w, m.ident);
encode_type_param_bounds(ebml_w, ecx, m.tps);
encode_type(ecx, ebml_w, node_id_to_type(tcx, m.id));
encode_def_id(ebml_w, local_def(m.id));
@ -655,8 +664,8 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
/* Encode the constructor */
for struct_def.ctor.each |ctor| {
debug!{"encoding info for ctor %s %d", *item.ident,
ctor.node.id};
debug!{"encoding info for ctor %s %d",
ecx.tcx.sess.str_of(item.ident), ctor.node.id};
vec::push(*index, {
val: ctor.node.id,
pos: ebml_w.writer.tell()
@ -676,7 +685,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
encode_region_param(ecx, ebml_w, item);
encode_type_param_bounds(ebml_w, ecx, tps);
encode_type(ecx, ebml_w, node_id_to_type(tcx, item.id));
encode_name(ebml_w, item.ident);
encode_name(ecx, ebml_w, item.ident);
encode_attributes(ebml_w, item.attrs);
for methods.each |m| {
ebml_w.start_tag(tag_item_impl_method);
@ -689,7 +698,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
for traits.each |associated_trait| {
encode_trait_ref(ebml_w, ecx, associated_trait)
}
encode_path(ebml_w, path, ast_map::path_name(item.ident));
encode_path(ecx, ebml_w, path, ast_map::path_name(item.ident));
ebml_w.end_tag();
let impl_path = vec::append_one(path,
@ -709,7 +718,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
encode_region_param(ecx, ebml_w, item);
encode_type_param_bounds(ebml_w, ecx, tps);
encode_type(ecx, ebml_w, node_id_to_type(tcx, item.id));
encode_name(ebml_w, item.ident);
encode_name(ecx, ebml_w, item.ident);
encode_attributes(ebml_w, item.attrs);
let mut i = 0u;
for vec::each(*ty::trait_methods(tcx, local_def(item.id))) |mty| {
@ -717,7 +726,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
required(ty_m) => {
ebml_w.start_tag(tag_item_trait_method);
encode_def_id(ebml_w, local_def(ty_m.id));
encode_name(ebml_w, mty.ident);
encode_name(ecx, ebml_w, mty.ident);
encode_type_param_bounds(ebml_w, ecx, ty_m.tps);
encode_type(ecx, ebml_w, ty::mk_fn(tcx, mty.fty));
encode_family(ebml_w, purity_fn_family(mty.purity));
@ -732,7 +741,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
}
i += 1u;
}
encode_path(ebml_w, path, ast_map::path_name(item.ident));
encode_path(ecx, ebml_w, path, ast_map::path_name(item.ident));
for traits.each |associated_trait| {
encode_trait_ref(ebml_w, ecx, associated_trait)
}
@ -750,13 +759,13 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
ebml_w.start_tag(tag_items_data_item);
encode_def_id(ebml_w, local_def(ty_m.id));
encode_name(ebml_w, ty_m.ident);
encode_name(ecx, ebml_w, ty_m.ident);
encode_family(ebml_w,
purity_static_method_family(ty_m.decl.purity));
let polyty = ecx.tcx.tcache.get(local_def(ty_m.id));
encode_ty_type_param_bounds(ebml_w, ecx, polyty.bounds);
encode_type(ecx, ebml_w, polyty.ty);
encode_path(ebml_w, path, ast_map::path_name(ty_m.ident));
encode_path(ecx, ebml_w, path, ast_map::path_name(ty_m.ident));
ebml_w.end_tag();
}
@ -786,7 +795,7 @@ fn encode_info_for_foreign_item(ecx: @encode_ctxt, ebml_w: ebml::writer,
} else {
encode_symbol(ecx, ebml_w, nitem.id);
}
encode_path(ebml_w, path, ast_map::path_name(nitem.ident));
encode_path(ecx, ebml_w, path, ast_map::path_name(nitem.ident));
}
}
ebml_w.end_tag();
@ -798,7 +807,8 @@ fn encode_info_for_items(ecx: @encode_ctxt, ebml_w: ebml::writer,
ebml_w.start_tag(tag_items_data);
vec::push(*index, {val: crate_node_id, pos: ebml_w.writer.tell()});
encode_info_for_mod(ecx, ebml_w, crate.node.module,
crate_node_id, ~[], @~"");
crate_node_id, ~[],
syntax::parse::token::special_idents::invalid);
visit::visit_crate(*crate, (), visit::mk_vt(@{
visit_expr: |_e, _cx, _v| { },
visit_item: |i, cx, v, copy ebml_w| {
@ -883,7 +893,7 @@ fn encode_meta_item(ebml_w: ebml::writer, mi: meta_item) {
meta_word(name) => {
ebml_w.start_tag(tag_meta_item_word);
ebml_w.start_tag(tag_meta_item_name);
ebml_w.writer.write(str::bytes(*name));
ebml_w.writer.write(str::bytes(name));
ebml_w.end_tag();
ebml_w.end_tag();
}
@ -892,7 +902,7 @@ fn encode_meta_item(ebml_w: ebml::writer, mi: meta_item) {
lit_str(value) => {
ebml_w.start_tag(tag_meta_item_name_value);
ebml_w.start_tag(tag_meta_item_name);
ebml_w.writer.write(str::bytes(*name));
ebml_w.writer.write(str::bytes(name));
ebml_w.end_tag();
ebml_w.start_tag(tag_meta_item_value);
ebml_w.writer.write(str::bytes(*value));
@ -905,7 +915,7 @@ fn encode_meta_item(ebml_w: ebml::writer, mi: meta_item) {
meta_list(name, items) => {
ebml_w.start_tag(tag_meta_item_list);
ebml_w.start_tag(tag_meta_item_name);
ebml_w.writer.write(str::bytes(*name));
ebml_w.writer.write(str::bytes(name));
ebml_w.end_tag();
for items.each |inner_item| {
encode_meta_item(ebml_w, *inner_item);
@ -934,22 +944,22 @@ fn synthesize_crate_attrs(ecx: @encode_ctxt, crate: @crate) -> ~[attribute] {
fn synthesize_link_attr(ecx: @encode_ctxt, items: ~[@meta_item]) ->
attribute {
assert (*ecx.link_meta.name != ~"");
assert (*ecx.link_meta.vers != ~"");
assert (ecx.link_meta.name != ~"");
assert (ecx.link_meta.vers != ~"");
let name_item =
attr::mk_name_value_item_str(@~"name", *ecx.link_meta.name);
attr::mk_name_value_item_str(~"name", ecx.link_meta.name);
let vers_item =
attr::mk_name_value_item_str(@~"vers", *ecx.link_meta.vers);
attr::mk_name_value_item_str(~"vers", ecx.link_meta.vers);
let other_items =
{
let tmp = attr::remove_meta_items_by_name(items, @~"name");
attr::remove_meta_items_by_name(tmp, @~"vers")
let tmp = attr::remove_meta_items_by_name(items, ~"name");
attr::remove_meta_items_by_name(tmp, ~"vers")
};
let meta_items = vec::append(~[name_item, vers_item], other_items);
let link_item = attr::mk_list_item(@~"link", meta_items);
let link_item = attr::mk_list_item(~"link", meta_items);
return attr::mk_attr(link_item);
}
@ -959,7 +969,7 @@ fn synthesize_crate_attrs(ecx: @encode_ctxt, crate: @crate) -> ~[attribute] {
for crate.node.attrs.each |attr| {
vec::push(
attrs,
if *attr::get_attr_name(attr) != ~"link" {
if attr::get_attr_name(attr) != ~"link" {
attr
} else {
match attr.node.value.node {
@ -977,16 +987,19 @@ fn synthesize_crate_attrs(ecx: @encode_ctxt, crate: @crate) -> ~[attribute] {
return attrs;
}
fn encode_crate_deps(ebml_w: ebml::writer, cstore: cstore::cstore) {
fn encode_crate_deps(ecx: @encode_ctxt, ebml_w: ebml::writer,
cstore: cstore::cstore) {
fn get_ordered_deps(ecx: @encode_ctxt, cstore: cstore::cstore)
-> ~[decoder::crate_dep] {
fn get_ordered_deps(cstore: cstore::cstore) -> ~[decoder::crate_dep] {
type hashkv = @{key: crate_num, val: cstore::crate_metadata};
type numdep = decoder::crate_dep;
// Pull the cnums and name,vers,hash out of cstore
let mut deps: ~[mut numdep] = ~[mut];
do cstore::iter_crate_data(cstore) |key, val| {
let dep = {cnum: key, name: @val.name,
let dep = {cnum: key, name: ecx.tcx.sess.ident_of(val.name),
vers: decoder::get_crate_vers(val.data),
hash: decoder::get_crate_hash(val.data)};
vec::push(deps, dep);
@ -1014,22 +1027,23 @@ fn encode_crate_deps(ebml_w: ebml::writer, cstore: cstore::cstore) {
// FIXME (#2166): This is not nearly enough to support correct versioning
// but is enough to get transitive crate dependencies working.
ebml_w.start_tag(tag_crate_deps);
for get_ordered_deps(cstore).each |dep| {
encode_crate_dep(ebml_w, dep);
for get_ordered_deps(ecx, cstore).each |dep| {
encode_crate_dep(ecx, ebml_w, dep);
}
ebml_w.end_tag();
}
fn encode_crate_dep(ebml_w: ebml::writer, dep: decoder::crate_dep) {
fn encode_crate_dep(ecx: @encode_ctxt, ebml_w: ebml::writer,
dep: decoder::crate_dep) {
ebml_w.start_tag(tag_crate_dep);
ebml_w.start_tag(tag_crate_dep_name);
ebml_w.writer.write(str::bytes(*dep.name));
ebml_w.writer.write(str::bytes(ecx.tcx.sess.str_of(dep.name)));
ebml_w.end_tag();
ebml_w.start_tag(tag_crate_dep_vers);
ebml_w.writer.write(str::bytes(*dep.vers));
ebml_w.writer.write(str::bytes(dep.vers));
ebml_w.end_tag();
ebml_w.start_tag(tag_crate_dep_hash);
ebml_w.writer.write(str::bytes(*dep.hash));
ebml_w.writer.write(str::bytes(dep.hash));
ebml_w.end_tag();
ebml_w.end_tag();
}
@ -1064,7 +1078,7 @@ fn encode_metadata(parms: encode_parms, crate: @crate) -> ~[u8] {
let crate_attrs = synthesize_crate_attrs(ecx, crate);
encode_attributes(ebml_w, crate_attrs);
encode_crate_deps(ebml_w, ecx.cstore);
encode_crate_deps(ecx, ebml_w, ecx.cstore);
// Encode and index the items.
ebml_w.start_tag(tag_items);

34
src/rustc/metadata/loader.rs
View file

@ -7,6 +7,7 @@ import syntax::codemap::span;
import lib::llvm::{False, llvm, mk_object_file, mk_section_iter};
import filesearch::filesearch;
import io::WriterUtil;
import syntax::parse::token::ident_interner;
export os;
export os_macos, os_win32, os_linux, os_freebsd;
@ -33,7 +34,8 @@ type ctxt = {
metas: ~[@ast::meta_item],
hash: ~str,
os: os,
static: bool
static: bool,
intr: ident_interner
};
fn load_library_crate(cx: ctxt) -> {ident: ~str, data: @~[u8]} {
@ -41,7 +43,8 @@ fn load_library_crate(cx: ctxt) -> {ident: ~str, data: @~[u8]} {
some(t) => return t,
none => {
cx.diag.span_fatal(
cx.span, fmt!{"can't find crate for `%s`", *cx.ident});
cx.span, fmt!{"can't find crate for `%s`",
*cx.intr.get(cx.ident)});
}
}
}
@ -66,7 +69,7 @@ fn find_library_crate_aux(cx: ctxt,
filesearch: filesearch::filesearch) ->
option<{ident: ~str, data: @~[u8]}> {
let crate_name = crate_name_from_metas(cx.metas);
let prefix: ~str = nn.prefix + *crate_name + ~"-";
let prefix: ~str = nn.prefix + crate_name + ~"-";
let suffix: ~str = nn.suffix;
let mut matches = ~[];
@ -104,19 +107,19 @@ fn find_library_crate_aux(cx: ctxt,
some(matches[0])
} else {
cx.diag.span_err(
cx.span, fmt!{"multiple matching crates for `%s`", *crate_name});
cx.span, fmt!{"multiple matching crates for `%s`", crate_name});
cx.diag.handler().note(~"candidates:");
for matches.each |match_| {
cx.diag.handler().note(fmt!{"path: %s", match_.ident});
let attrs = decoder::get_crate_attributes(match_.data);
note_linkage_attrs(cx.diag, attrs);
note_linkage_attrs(cx.intr, cx.diag, attrs);
}
cx.diag.handler().abort_if_errors();
none
}
}
fn crate_name_from_metas(metas: ~[@ast::meta_item]) -> @~str {
fn crate_name_from_metas(metas: ~[@ast::meta_item]) -> ~str {
let name_items = attr::find_meta_items_by_name(metas, ~"name");
match vec::last_opt(name_items) {
some(i) => {
@ -131,9 +134,10 @@ fn crate_name_from_metas(metas: ~[@ast::meta_item]) -> @~str {
}
}
fn note_linkage_attrs(diag: span_handler, attrs: ~[ast::attribute]) {
fn note_linkage_attrs(intr: ident_interner, diag: span_handler,
attrs: ~[ast::attribute]) {
for attr::find_linkage_attrs(attrs).each |attr| {
diag.handler().note(fmt!{"meta: %s", pprust::attr_to_str(attr)});
diag.handler().note(fmt!{"meta: %s", pprust::attr_to_str(attr,intr)});
}
}
@ -143,7 +147,7 @@ fn crate_matches(crate_data: @~[u8], metas: ~[@ast::meta_item],
let linkage_metas = attr::find_linkage_metas(attrs);
if hash.is_not_empty() {
let chash = decoder::get_crate_hash(crate_data);
if *chash != hash { return false; }
if chash != hash { return false; }
}
metadata_matches(linkage_metas, metas)
}
@ -154,15 +158,8 @@ fn metadata_matches(extern_metas: ~[@ast::meta_item],
debug!{"matching %u metadata requirements against %u items",
vec::len(local_metas), vec::len(extern_metas)};
debug!{"crate metadata:"};
for extern_metas.each |have| {
debug!{" %s", pprust::meta_item_to_str(*have)};
}
for local_metas.each |needed| {
debug!{"looking for %s", pprust::meta_item_to_str(*needed)};
if !attr::contains(extern_metas, needed) {
debug!{"missing %s", pprust::meta_item_to_str(*needed)};
return false;
}
}
@ -206,9 +203,10 @@ fn meta_section_name(os: os) -> ~str {
}
// A diagnostic function for dumping crate metadata to an output stream
fn list_file_metadata(os: os, path: ~str, out: io::Writer) {
fn list_file_metadata(intr: ident_interner, os: os, path: ~str,
out: io::Writer) {
match get_metadata_section(os, path) {
option::some(bytes) => decoder::list_crate_metadata(bytes, out),
option::some(bytes) => decoder::list_crate_metadata(intr, bytes, out),
option::none => {
out.write_str(~"could not find metadata in " + path + ~".\n");
}

6
src/rustc/metadata/tydecode.rs
View file

@ -46,7 +46,7 @@ fn parse_ident_(st: @pstate, is_last: fn@(char) -> bool) ->
while !is_last(peek(st)) {
rslt += str::from_byte(next_byte(st));
}
return @rslt;
return st.tcx.sess.ident_of(rslt);
}
@ -133,7 +133,7 @@ fn parse_bound_region(st: @pstate) -> ty::bound_region {
assert next(st) == '|';
ty::br_anon(id)
}
'[' => ty::br_named(@parse_str(st, ']')),
'[' => ty::br_named(st.tcx.sess.ident_of(parse_str(st, ']'))),
'c' => {
let id = parse_int(st);
assert next(st) == '|';
@ -249,7 +249,7 @@ fn parse_ty(st: @pstate, conv: conv_did) -> ty::t {
assert (next(st) == '[');
let mut fields: ~[ty::field] = ~[];
while peek(st) != ']' {
let name = @parse_str(st, '=');
let name = st.tcx.sess.ident_of(parse_str(st, '='));
vec::push(fields, {ident: name, mt: parse_mt(st, conv)});
}
st.pos = st.pos + 1u;

12
src/rustc/metadata/tyencode.rs
View file

@ -126,14 +126,14 @@ fn enc_region(w: io::Writer, cx: @ctxt, r: ty::region) {
match r {
ty::re_bound(br) => {
w.write_char('b');
enc_bound_region(w, br);
enc_bound_region(w, cx, br);
}
ty::re_free(id, br) => {
w.write_char('f');
w.write_char('[');
w.write_int(id);
w.write_char('|');
enc_bound_region(w, br);
enc_bound_region(w, cx, br);
w.write_char(']');
}
ty::re_scope(nid) => {
@ -151,7 +151,7 @@ fn enc_region(w: io::Writer, cx: @ctxt, r: ty::region) {
}
}
fn enc_bound_region(w: io::Writer, br: ty::bound_region) {
fn enc_bound_region(w: io::Writer, cx: @ctxt, br: ty::bound_region) {
match br {
ty::br_self => w.write_char('s'),
ty::br_anon(idx) => {
@ -161,14 +161,14 @@ fn enc_bound_region(w: io::Writer, br: ty::bound_region) {
}
ty::br_named(s) => {
w.write_char('[');
w.write_str(*s);
w.write_str(cx.tcx.sess.str_of(s));
w.write_char(']')
}
ty::br_cap_avoid(id, br) => {
w.write_char('c');
w.write_int(id);
w.write_char('|');
enc_bound_region(w, *br);
enc_bound_region(w, cx, *br);
}
}
}
@ -265,7 +265,7 @@ fn enc_sty(w: io::Writer, cx: @ctxt, st: ty::sty) {
ty::ty_rec(fields) => {
w.write_str(&"R[");
for fields.each |field| {
w.write_str(*field.ident);
w.write_str(cx.tcx.sess.str_of(field.ident));
w.write_char('=');
enc_mt(w, cx, field.mt);
}

27
src/rustc/middle/astencode.rs
View file

@ -83,7 +83,8 @@ fn encode_inlined_item(ecx: @e::encode_ctxt,
ii: ast::inlined_item,
maps: maps) {
debug!{"> Encoding inlined item: %s::%s (%u)",
ast_map::path_to_str(path), *ii.ident(),
ast_map::path_to_str(path, ecx.tcx.sess.parse_sess.interner),
ecx.tcx.sess.str_of(ii.ident()),
ebml_w.writer.tell()};
let id_range = ast_util::compute_id_range_for_inlined_item(ii);
@ -94,7 +95,8 @@ fn encode_inlined_item(ecx: @e::encode_ctxt,
}
debug!{"< Encoded inlined fn: %s::%s (%u)",
ast_map::path_to_str(path), *ii.ident(),
ast_map::path_to_str(path, ecx.tcx.sess.parse_sess.interner),
ecx.tcx.sess.str_of(ii.ident()),
ebml_w.writer.tell()};
}
@ -107,7 +109,8 @@ fn decode_inlined_item(cdata: cstore::crate_metadata,
match par_doc.opt_child(c::tag_ast) {
none => none,
some(ast_doc) => {
debug!{"> Decoding inlined fn: %s::?", ast_map::path_to_str(path)};
debug!{"> Decoding inlined fn: %s::?",
ast_map::path_to_str(path, tcx.sess.parse_sess.interner)};
let ast_dsr = ebml::ebml_deserializer(ast_doc);
let from_id_range = ast_util::deserialize_id_range(ast_dsr);
let to_id_range = reserve_id_range(dcx.tcx.sess, from_id_range);
@ -118,14 +121,15 @@ fn decode_inlined_item(cdata: cstore::crate_metadata,
let ii = renumber_ast(xcx, raw_ii);
ast_map::map_decoded_item(tcx.sess.diagnostic(),
dcx.tcx.items, path, ii);
debug!{"Fn named: %s", *ii.ident()};
debug!{"Fn named: %s", tcx.sess.str_of(ii.ident())};
decode_side_tables(xcx, ast_doc);
debug!{"< Decoded inlined fn: %s::%s",
ast_map::path_to_str(path), *ii.ident()};
ast_map::path_to_str(path, tcx.sess.parse_sess.interner),
tcx.sess.str_of(ii.ident())};
match ii {
ast::ii_item(i) => {
debug!{">>> DECODED ITEM >>>\n%s\n<<< DECODED ITEM <<<",
syntax::print::pprust::item_to_str(i)};
syntax::print::pprust::item_to_str(i, tcx.sess.intr())};
}
_ => { }
}
@ -915,28 +919,26 @@ trait fake_ext_ctxt {
}
#[cfg(test)]
type fake_session = ();
type fake_session = parse::parse_sess;
#[cfg(test)]
impl fake_session: fake_ext_ctxt {
fn cfg() -> ast::crate_cfg { ~[] }
fn parse_sess() -> parse::parse_sess { parse::new_parse_sess(none) }
fn parse_sess() -> parse::parse_sess { self }
}
#[cfg(test)]
fn mk_ctxt() -> fake_ext_ctxt {
() as fake_ext_ctxt
parse::new_parse_sess(none) as fake_ext_ctxt
}
#[cfg(test)]
fn roundtrip(in_item: @ast::item) {
debug!{"in_item = %s", pprust::item_to_str(in_item)};
let mbuf = io::mem_buffer();
let ebml_w = ebml::writer(io::mem_buffer_writer(mbuf));
encode_item_ast(ebml_w, in_item);
let ebml_doc = ebml::doc(@io::mem_buffer_buf(mbuf));
let out_item = decode_item_ast(ebml_doc);
debug!{"out_item = %s", pprust::item_to_str(out_item)};
let exp_str =
io::with_str_writer(|w| ast::serialize_item(w, *in_item) );
@ -993,7 +995,8 @@ fn test_simplification() {
});
match (item_out, item_exp) {
(ast::ii_item(item_out), ast::ii_item(item_exp)) => {
assert pprust::item_to_str(item_out) == pprust::item_to_str(item_exp);
assert pprust::item_to_str(item_out, ext_cx.parse_sess().interner)
== pprust::item_to_str(item_exp, ext_cx.parse_sess().interner);
}
_ => fail
}

2
src/rustc/middle/borrowck/check_loans.rs
View file

@ -159,7 +159,7 @@ impl check_loan_ctxt {
debug!{"check_pure_callee_or_arg(pc=%?, expr=%?, \
callee_id=%d, ty=%s)",
pc,
opt_expr.map(|e| pprust::expr_to_str(e) ),
opt_expr.map(|e| pprust::expr_to_str(e, tcx.sess.intr()) ),
callee_id,
ty_to_str(self.tcx(), ty::node_id_to_type(tcx, callee_id))};

3
src/rustc/middle/borrowck/gather_loans.rs
View file

@ -90,7 +90,8 @@ fn req_loans_in_expr(ex: @ast::expr,
let tcx = bccx.tcx;
let old_root_ub = self.root_ub;
debug!{"req_loans_in_expr(ex=%s)", pprust::expr_to_str(ex)};
debug!{"req_loans_in_expr(ex=%s)",
pprust::expr_to_str(ex, tcx.sess.intr())};
// If this expression is borrowed, have to ensure it remains valid:
for tcx.borrowings.find(ex.id).each |borrow| {

6
src/rustc/middle/capture.rs
View file

@ -44,7 +44,7 @@ fn check_capture_clause(tcx: ty::ctxt,
tcx.sess.span_warn(
cap_item.span,
fmt!{"captured variable `%s` not used in closure",
*cap_item.name});
tcx.sess.str_of(cap_item.name)});
}
let cap_def_id = ast_util::def_id_of_def(cap_def).node;
@ -52,7 +52,7 @@ fn check_capture_clause(tcx: ty::ctxt,
tcx.sess.span_err(
cap_item.span,
fmt!{"variable `%s` captured more than once",
*cap_item.name});
tcx.sess.str_of(cap_item.name)});
}
}
}
@ -68,7 +68,7 @@ fn compute_capture_vars(tcx: ty::ctxt,
for (*cap_clause).each |cap_item| {
debug!{"Doing capture var: %s (%?)",
*cap_item.name, cap_item.id};
tcx.sess.str_of(cap_item.name), cap_item.id};
let cap_def = tcx.def_map.get(cap_item.id);
let cap_def_id = ast_util::def_id_of_def(cap_def).node;

8
src/rustc/middle/check_alt.rs
View file

@ -91,15 +91,15 @@ fn check_exhaustive(tcx: ty::ctxt, sp: span, pats: ~[@pat]) {
match ty::get(ty).struct {
ty::ty_bool => {
match check ctor {
val(const_int(1i64)) => some(@~"true"),
val(const_int(0i64)) => some(@~"false")
val(const_int(1i64)) => some(~"true"),
val(const_int(0i64)) => some(~"false")
}
}
ty::ty_enum(id, _) => {
let vid = match check ctor { variant(id) => id };
match check vec::find(*ty::enum_variants(tcx, id),
|v| v.id == vid) {
some(v) => some(v.name)
some(v) => some(tcx.sess.str_of(v.name))
}
}
_ => none
@ -107,7 +107,7 @@ fn check_exhaustive(tcx: ty::ctxt, sp: span, pats: ~[@pat]) {
}
};
let msg = ~"non-exhaustive patterns" + match ext {
some(s) => ~": " + *s + ~" not covered",
some(s) => ~": " + s + ~" not covered",
none => ~""
};
tcx.sess.span_err(sp, msg);

2
src/rustc/middle/freevars.rs
View file

@ -50,7 +50,7 @@ fn collect_freevars(def_map: resolve3::DefMap, blk: ast::blk)
ast::expr_path(path) => {
let mut i = 0;
match def_map.find(expr.id) {
none => fail (~"Not found: " + path_to_str(path)),
none => fail ~"path not found",
some(df) => {
let mut def = df;
while i < depth {

2
src/rustc/middle/kind.rs
View file

@ -214,7 +214,7 @@ fn check_block(b: blk, cx: ctx, v: visit::vt<ctx>) {
}
fn check_expr(e: @expr, cx: ctx, v: visit::vt<ctx>) {
debug!{"kind::check_expr(%s)", expr_to_str(e)};
debug!{"kind::check_expr(%s)", expr_to_str(e, cx.tcx.sess.intr())};
// Handle any kind bounds on type parameters
do option::iter(cx.tcx.node_type_substs.find(e.id)) |ts| {

12
src/rustc/middle/lang_items.rs
View file

@ -102,18 +102,12 @@ struct LanguageItemCollector {
meta_name_value(key, literal) => {
match literal.node {
lit_str(value) => {
self.match_and_collect_item(item_def_id,
*key,
*value);
self.match_and_collect_item(item_def_id, key, *value);
}
_ => {
// Skip.
_ => {} // Skip.
}
}
}
meta_word(*) | meta_list(*) => {
// Skip.
}
meta_word(*) | meta_list(*) => {} // Skip.
}
}

24
src/rustc/middle/lint.rs
View file

@ -246,13 +246,13 @@ impl ctxt {
for triples.each |pair| {
let (meta, level, lintname) = pair;
match self.dict.find(*lintname) {
match self.dict.find(lintname) {
none => {
self.span_lint(
new_ctxt.get_level(unrecognized_lint),
meta.span,
fmt!{"unknown `%s` attribute: `%s`",
level_to_str(level), *lintname});
level_to_str(level), lintname});
}
some(lint) => {
@ -263,7 +263,7 @@ impl ctxt {
meta.span,
fmt!{"%s(%s) overruled by outer forbid(%s)",
level_to_str(level),
*lintname, *lintname});
lintname, lintname});
}
// we do multiple unneeded copies of the
@ -433,9 +433,10 @@ fn check_item_path_statement(cx: ty::ctxt, it: @ast::item) {
}
fn check_item_non_camel_case_types(cx: ty::ctxt, it: @ast::item) {
fn is_camel_case(ident: ast::ident) -> bool {
fn is_camel_case(cx: ty::ctxt, ident: ast::ident) -> bool {
let ident = cx.sess.str_of(ident);
assert ident.is_not_empty();
let ident = ident_without_trailing_underscores(*ident);
let ident = ident_without_trailing_underscores(ident);
let ident = ident_without_leading_underscores(ident);
char::is_uppercase(str::char_at(ident, 0)) &&
!ident.contains_char('_')
@ -443,11 +444,8 @@ fn check_item_non_camel_case_types(cx: ty::ctxt, it: @ast::item) {
fn ident_without_trailing_underscores(ident: ~str) -> ~str {
match str::rfind(ident, |c| c != '_') {
some(idx) => ident.slice(0, idx + 1),
none => {
// all underscores
ident
}
some(idx) => (ident).slice(0, idx + 1),
none => { ident } // all underscores
}
}
@ -464,7 +462,7 @@ fn check_item_non_camel_case_types(cx: ty::ctxt, it: @ast::item) {
fn check_case(cx: ty::ctxt, ident: ast::ident,
expr_id: ast::node_id, item_id: ast::node_id,
span: span) {
if !is_camel_case(ident) {
if !is_camel_case(cx, ident) {
cx.sess.span_lint(
non_camel_case_types, expr_id, item_id, span,
~"type, variant, or trait must be camel case");
@ -488,7 +486,7 @@ fn check_item_non_camel_case_types(cx: ty::ctxt, it: @ast::item) {
}
fn check_pat(tcx: ty::ctxt, pat: @ast::pat) {
debug!{"lint check_pat pat=%s", pat_to_str(pat)};
debug!{"lint check_pat pat=%s", pat_to_str(pat, tcx.sess.intr())};
do pat_bindings(tcx.def_map, pat) |binding_mode, id, span, path| {
match binding_mode {
@ -501,7 +499,7 @@ fn check_pat(tcx: ty::ctxt, pat: @ast::pat) {
deprecated_pattern, id, id,
span,
fmt!{"binding `%s` should use ref or copy mode",
*path_to_ident(path)});
tcx.sess.str_of(path_to_ident(path))});
}
}
}

40
src/rustc/middle/liveness.rs
View file

@ -101,7 +101,7 @@
*/
import dvec::{DVec, dvec};
import std::map::{hashmap, int_hash, str_hash, box_str_hash};
import std::map::{hashmap, int_hash, str_hash, uint_hash};
import syntax::{visit, ast_util};
import syntax::print::pprust::{expr_to_str};
import visit::vt;
@ -233,7 +233,7 @@ struct ir_maps {
self.live_node_map = int_hash();
self.variable_map = int_hash();
self.capture_map = int_hash();
self.field_map = box_str_hash();
self.field_map = uint_hash();
self.var_kinds = ~[];
self.lnks = ~[];
}
@ -286,12 +286,12 @@ struct ir_maps {
}
}
fn variable_name(var: variable) -> ident {
match self.var_kinds[*var] {
vk_local(_, name) | vk_arg(_, name, _) => name,
vk_field(name) => @(~"self." + *name),
vk_self => @~"self",
vk_implicit_return => @~"<implicit-ret>"
fn variable_name(var: variable) -> ~str {
match copy self.var_kinds[*var] {
vk_local(_, nm) | vk_arg(_, nm, _) => self.tcx.sess.str_of(nm),
vk_field(nm) => ~"self." + self.tcx.sess.str_of(nm),
vk_self => ~"self",
vk_implicit_return => ~"<implicit-ret>"
}
}
@ -1492,7 +1492,8 @@ impl @liveness {
none => { /* ok */ }
some(lnk_exit) => {
self.tcx.sess.span_err(
sp, fmt!{"field `self.%s` is never initialized", *nm});
sp, fmt!{"field `self.%s` is never initialized",
self.tcx.sess.str_of(nm)});
}
some(lnk) => {
self.report_illegal_read(
@ -1548,7 +1549,7 @@ impl @liveness {
fn check_move_from_expr(expr: @expr, vt: vt<@liveness>) {
debug!{"check_move_from_expr(node %d: %s)",
expr.id, expr_to_str(expr)};
expr.id, expr_to_str(expr, self.tcx.sess.intr())};
if self.ir.method_map.contains_key(expr.id) {
// actually an rvalue, since this calls a method
@ -1664,13 +1665,14 @@ impl @liveness {
self.tcx.sess.span_err(
move_span,
fmt!{"illegal move from argument `%s`, which is not \
copy or move mode", *name});
copy or move mode", self.tcx.sess.str_of(name)});
return;
}
vk_field(name) => {
self.tcx.sess.span_err(
move_span,
fmt!{"illegal move from field `%s`", *name});
fmt!{"illegal move from field `%s`",
self.tcx.sess.str_of(name)});
return;
}
vk_self => {
@ -1711,12 +1713,12 @@ impl @liveness {
lnk_freevar(span) => {
self.tcx.sess.span_err(
span,
fmt!{"capture of %s: `%s`", msg, *name});
fmt!{"capture of %s: `%s`", msg, name});
}
lnk_expr(span) => {
self.tcx.sess.span_err(
span,
fmt!{"use of %s: `%s`", msg, *name});
fmt!{"use of %s: `%s`", msg, name});
}
lnk_exit |
lnk_vdef(_) => {
@ -1727,9 +1729,9 @@ impl @liveness {
}
}
fn should_warn(var: variable) -> option<ident> {
fn should_warn(var: variable) -> option<~str> {
let name = (*self.ir).variable_name(var);
if (*name)[0] == ('_' as u8) {none} else {some(name)}
if name[0] == ('_' as u8) {none} else {some(name)}
}
fn warn_about_unused_args(sp: span, decl: fn_decl, entry_ln: live_node) {
@ -1780,10 +1782,10 @@ impl @liveness {
if is_assigned {
self.tcx.sess.span_warn(
sp, fmt!{"variable `%s` is assigned to, \
but never used", *name});
but never used", name});
} else {
self.tcx.sess.span_warn(
sp, fmt!{"unused variable: `%s`", *name});
sp, fmt!{"unused variable: `%s`", name});
}
}
return true;
@ -1796,7 +1798,7 @@ impl @liveness {
for self.should_warn(var).each |name| {
self.tcx.sess.span_warn(
sp,
fmt!{"value assigned to `%s` is never read", *name});
fmt!{"value assigned to `%s` is never read", name});
}
}
}

16
src/rustc/middle/mem_categorization.rs
View file

@ -263,7 +263,7 @@ impl &mem_categorization_ctxt {
fn cat_expr(expr: @ast::expr) -> cmt {
debug!{"cat_expr: id=%d expr=%s",
expr.id, pprust::expr_to_str(expr)};
expr.id, pprust::expr_to_str(expr, self.tcx.sess.intr())};
let tcx = self.tcx;
let expr_ty = tcx.ty(expr);
@ -468,7 +468,8 @@ impl &mem_categorization_ctxt {
self.tcx.sess.span_bug(
node.span(),
fmt!{"Cannot find field `%s` in type `%s`",
*f_name, ty_to_str(self.tcx, base_cmt.ty)});
self.tcx.sess.str_of(f_name),
ty_to_str(self.tcx, base_cmt.ty)});
}
};
let m = self.inherited_mutability(base_cmt.mutbl, f_mutbl);
@ -650,12 +651,13 @@ impl &mem_categorization_ctxt {
// in the alt, the id of `local(x)->@` is the `@y` pattern,
// and the id of `local(x)->@->@` is the id of the `y` pattern.
debug!{"cat_pattern: id=%d pat=%s cmt=%s",
pat.id, pprust::pat_to_str(pat),
self.cmt_to_repr(cmt)};
let _i = indenter();
let _i = indenter();
let tcx = self.tcx;
debug!{"cat_pattern: id=%d pat=%s cmt=%s",
pat.id, pprust::pat_to_str(pat, tcx.sess.intr()),
self.cmt_to_repr(cmt)};
match pat.node {
ast::pat_wild => {
// _
@ -767,7 +769,7 @@ impl &mem_categorization_ctxt {
fn comp_to_repr(comp: comp_kind) -> ~str {
match comp {
comp_field(fld, _) => *fld,
comp_field(fld, _) => self.tcx.sess.str_of(fld),
comp_index(*) => ~"[]",
comp_tuple => ~"()",
comp_variant(_) => ~"<enum>"

2
src/rustc/middle/pat_util.rs
View file

@ -14,7 +14,7 @@ type pat_id_map = std::map::hashmap<ident, node_id>;
// This is used because same-named variables in alternative patterns need to
// use the node_id of their namesake in the first pattern.
fn pat_id_map(dm: resolve3::DefMap, pat: @pat) -> pat_id_map {
let map = std::map::box_str_hash();
let map = std::map::uint_hash();
do pat_bindings(dm, pat) |_bm, p_id, _s, n| {
map.insert(path_to_ident(n), p_id);
};

29
src/rustc/middle/region.rs
View file

@ -254,11 +254,13 @@ fn resolve_expr(expr: @ast::expr, cx: ctxt, visitor: visit::vt<ctxt>) {
let mut new_cx = cx;
match expr.node {
ast::expr_call(*) => {
debug!{"node %d: %s", expr.id, pprust::expr_to_str(expr)};
debug!{"node %d: %s", expr.id, pprust::expr_to_str(expr,
cx.sess.intr())};
new_cx.parent = some(expr.id);
}
ast::expr_match(subexpr, _, _) => {
debug!{"node %d: %s", expr.id, pprust::expr_to_str(expr)};
debug!{"node %d: %s", expr.id, pprust::expr_to_str(expr,
cx.sess.intr())};
new_cx.parent = some(expr.id);
}
ast::expr_fn(_, _, _, cap_clause) |
@ -390,8 +392,9 @@ impl determine_rp_ctxt {
fn add_rp(id: ast::node_id) {
assert id != 0;
if self.region_paramd_items.insert(id, ()) {
debug!{"add region-parameterized item: %d (%s)",
id, ast_map::node_id_to_str(self.ast_map, id)};
debug!{"add region-parameterized item: %d (%s)", id,
ast_map::node_id_to_str(self.ast_map, id,
self.sess.parse_sess.interner)};
self.worklist.push(id);
} else {
debug!{"item %d already region-parameterized", id};
@ -401,8 +404,10 @@ impl determine_rp_ctxt {
fn add_dep(from: ast::node_id, to: ast::node_id) {
debug!{"add dependency from %d -> %d (%s -> %s)",
from, to,
ast_map::node_id_to_str(self.ast_map, from),
ast_map::node_id_to_str(self.ast_map, to)};
ast_map::node_id_to_str(self.ast_map, from,
self.sess.parse_sess.interner),
ast_map::node_id_to_str(self.ast_map, to,
self.sess.parse_sess.interner)};
let vec = match self.dep_map.find(from) {
some(vec) => {vec}
none => {
@ -449,8 +454,9 @@ impl determine_rp_ctxt {
fn region_is_relevant(r: @ast::region) -> bool {
match r.node {
ast::re_anon => self.anon_implies_rp,
ast::re_named(@~"self") => true,
ast::re_named(_) => false
ast::re_named(id) => {
id == syntax::parse::token::special_idents::self_
}
}
}
@ -511,7 +517,8 @@ fn determine_rp_in_ty(ty: @ast::ty,
match ty.node {
ast::ty_rptr(r, _) |
ast::ty_path(@{rp: some(r), _}, _) => {
debug!{"referenced type with regions %s", pprust::ty_to_str(ty)};
debug!{"referenced type with regions %s",
pprust::ty_to_str(ty, cx.sess.intr())};
if cx.region_is_relevant(r) {
cx.add_rp(cx.item_id);
}
@ -520,7 +527,7 @@ fn determine_rp_in_ty(ty: @ast::ty,
ast::ty_fn(ast::proto_bare, _, _) |
ast::ty_fn(ast::proto_block, _, _) if cx.anon_implies_rp => {
debug!("referenced bare fn type with regions %s",
pprust::ty_to_str(ty));
pprust::ty_to_str(ty, cx.sess.intr()));
cx.add_rp(cx.item_id);
}
@ -541,7 +548,7 @@ fn determine_rp_in_ty(ty: @ast::ty,
let cstore = cx.sess.cstore;
if csearch::get_region_param(cstore, did) {
debug!{"reference to external, rp'd type %s",
pprust::ty_to_str(ty)};
pprust::ty_to_str(ty, cx.sess.intr())};
cx.add_rp(cx.item_id);
}
}

410
src/rustc/middle/resolve3.rs
View file

File diff suppressed because it is too large Load diff

12
src/rustc/middle/trans/alt.rs
View file

@ -95,7 +95,7 @@ type bind_map = ~[{
fn assoc(key: ast::ident, list: bind_map) -> option<binding> {
for vec::each(list) |elt| {
if str::eq(elt.ident, key) {
if elt.ident == key {
return some(elt.binding);
}
}
@ -232,7 +232,7 @@ fn enter_rec_or_struct(bcx: block, dm: DefMap, m: match_, col: uint,
for vec::each(fields) |fname| {
let mut pat = dummy;
for vec::each(fpats) |fpat| {
if str::eq(fpat.ident, fname) { pat = fpat.pat; break; }
if fpat.ident == fname { pat = fpat.pat; break; }
}
vec::push(pats, pat);
}
@ -334,7 +334,7 @@ fn collect_record_fields(m: match_, col: uint) -> ~[ast::ident] {
match br.pats[col].node {
ast::pat_rec(fs, _) => {
for vec::each(fs) |f| {
if !vec::any(fields, |x| str::eq(f.ident, x)) {
if !vec::any(fields, |x| f.ident == x) {
vec::push(fields, f.ident);
}
}
@ -351,7 +351,7 @@ fn collect_struct_fields(m: match_, col: uint) -> ~[ast::ident] {
match br.pats[col].node {
ast::pat_struct(_, fs, _) => {
for vec::each(fs) |f| {
if !vec::any(fields, |x| str::eq(f.ident, x)) {
if !vec::any(fields, |x| f.ident == x) {
vec::push(fields, f.ident);
}
}
@ -550,7 +550,7 @@ fn compile_submatch(bcx: block, m: match_, vals: ~[ValueRef],
}
// Index the class fields.
let field_map = std::map::box_str_hash();
let field_map = std::map::uint_hash();
for class_fields.eachi |i, class_field| {
field_map.insert(class_field.ident, i);
}
@ -951,7 +951,7 @@ fn bind_irrefutable_pat(bcx: block, pat: @ast::pat, val: ValueRef,
}
// Index the class fields.
let field_map = std::map::box_str_hash();
let field_map = std::map::uint_hash();
for class_fields.eachi |i, class_field| {
field_map.insert(class_field.ident, i);
}

98
src/rustc/middle/trans/base.rs
View file

@ -49,6 +49,7 @@ import type_of::*;
import common::*;
import common::result;
import syntax::ast_map::{path, path_mod, path_name};
import syntax::parse::token::special_idents;
import std::smallintmap;
import option::{is_none, is_some};
@ -500,8 +501,8 @@ fn declare_tydesc(ccx: @crate_ctxt, t: ty::t) -> @tydesc_info {
let llalign = llalign_of(ccx, llty);
//XXX this triggers duplicate LLVM symbols
let name = if false /*ccx.sess.opts.debuginfo*/ {
mangle_internal_name_by_type_only(ccx, t, @~"tydesc")
} else { mangle_internal_name_by_seq(ccx, @~"tydesc") };
mangle_internal_name_by_type_only(ccx, t, ~"tydesc")
} else { mangle_internal_name_by_seq(ccx, ~"tydesc") };
note_unique_llvm_symbol(ccx, name);
log(debug, fmt!{"+++ declare_tydesc %s %s", ty_to_str(ccx.tcx, t), name});
let gvar = str::as_c_str(name, |buf| {
@ -529,9 +530,9 @@ fn declare_generic_glue(ccx: @crate_ctxt, t: ty::t, llfnty: TypeRef,
let mut fn_nm;
//XXX this triggers duplicate LLVM symbols
if false /*ccx.sess.opts.debuginfo*/ {
fn_nm = mangle_internal_name_by_type_only(ccx, t, @(~"glue_" + name));
fn_nm = mangle_internal_name_by_type_only(ccx, t, (~"glue_" + name));
} else {
fn_nm = mangle_internal_name_by_seq(ccx, @(~"glue_" + name));
fn_nm = mangle_internal_name_by_seq(ccx, (~"glue_" + name));
}
note_unique_llvm_symbol(ccx, fn_nm);
let llfn = decl_cdecl_fn(ccx.llmod, fn_nm, llfnty);
@ -698,8 +699,9 @@ fn incr_refcnt_of_boxed(cx: block, box_ptr: ValueRef) {
fn make_visit_glue(bcx: block, v: ValueRef, t: ty::t) {
let _icx = bcx.insn_ctxt("make_visit_glue");
let mut bcx = bcx;
assert bcx.ccx().tcx.intrinsic_defs.contains_key(@~"ty_visitor");
let (trait_id, ty) = bcx.ccx().tcx.intrinsic_defs.get(@~"ty_visitor");
let ty_visitor_name = special_idents::ty_visitor;
assert bcx.ccx().tcx.intrinsic_defs.contains_key(ty_visitor_name);
let (trait_id, ty) = bcx.ccx().tcx.intrinsic_defs.get(ty_visitor_name);
let v = PointerCast(bcx, v, T_ptr(type_of::type_of(bcx.ccx(), ty)));
bcx = reflect::emit_calls_to_trait_visit_ty(bcx, t, v, trait_id);
build_return(bcx);
@ -1720,7 +1722,7 @@ fn trans_eager_binop(cx: block, span: span, op: ast::binop, lhs: ValueRef,
fn trans_assign_op(bcx: block, ex: @ast::expr, op: ast::binop,
dst: @ast::expr, src: @ast::expr) -> block {
debug!{"%s", expr_to_str(ex)};
debug!{"%s", expr_to_str(ex, bcx.tcx().sess.parse_sess.interner)};
let _icx = bcx.insn_ctxt("trans_assign_op");
let t = expr_ty(bcx, src);
let lhs_res = trans_lval(bcx, dst);
@ -1731,7 +1733,8 @@ fn trans_assign_op(bcx: block, ex: @ast::expr, op: ast::binop,
some(origin) => {
let bcx = lhs_res.bcx;
debug!{"user-defined method callee_id: %s",
ast_map::node_id_to_str(bcx.tcx().items, ex.callee_id)};
ast_map::node_id_to_str(bcx.tcx().items, ex.callee_id,
bcx.sess().parse_sess.interner)};
let fty = node_id_type(bcx, ex.callee_id);
let dty = expr_ty(bcx, dst);
@ -2164,7 +2167,8 @@ fn monomorphic_fn(ccx: @crate_ctxt, fn_id: ast::def_id,
must_cast: true};
}
ast_map::node_ctor(nm, _, ct, _, pt) => (pt, nm, ct.span),
ast_map::node_dtor(_, dtor, _, pt) => (pt, @~"drop", dtor.span),
ast_map::node_dtor(_, dtor, _, pt) =>
(pt, special_idents::dtor, dtor.span),
ast_map::node_trait_method(*) => {
ccx.tcx.sess.bug(~"Can't monomorphize a trait method")
}
@ -2198,7 +2202,8 @@ fn monomorphic_fn(ccx: @crate_ctxt, fn_id: ast::def_id,
}
ccx.monomorphizing.insert(fn_id, depth + 1u);
let pt = vec::append(*pt, ~[path_name(@ccx.names(*name))]);
let pt = vec::append(*pt,
~[path_name(ccx.names(ccx.sess.str_of(name)))]);
let s = mangle_exported_name(ccx, pt, mono_ty);
let mk_lldecl = || {
@ -2897,9 +2902,9 @@ fn trans_arg_expr(cx: block, arg: ty::arg, lldestty: TypeRef, e: @ast::expr,
&temp_cleanups: ~[ValueRef], ret_flag: option<ValueRef>,
derefs: uint)
-> result {
debug!{"+++ trans_arg_expr on %s", expr_to_str(e)};
let _icx = cx.insn_ctxt("trans_arg_expr");
let ccx = cx.ccx();
debug!{"+++ trans_arg_expr on %s", expr_to_str(e, ccx.sess.intr())};
let e_ty = expr_ty(cx, e);
let is_bot = ty::type_is_bot(e_ty);
@ -3436,9 +3441,8 @@ fn trans_rec(bcx: block, fields: ~[ast::field],
let mut temp_cleanups = ~[];
for fields.each |fld| {
let ix = option::get(vec::position(ty_fields, |ft| {
str::eq(fld.node.ident, ft.ident)
}));
let ix = option::get(vec::position(ty_fields,
|ft| ft.ident == fld.node.ident));
let dst = GEPi(bcx, addr, ~[0u, ix]);
bcx = trans_expr_save_in(bcx, fld.node.expr, dst);
add_clean_temp_mem(bcx, dst, ty_fields[ix].mt.ty);
@ -3450,7 +3454,7 @@ fn trans_rec(bcx: block, fields: ~[ast::field],
bcx = cx;
// Copy over inherited fields
for ty_fields.eachi |i, tf| {
if !vec::any(fields, |f| str::eq(f.node.ident, tf.ident)) {
if !vec::any(fields, |f| f.node.ident == tf.ident) {
let dst = GEPi(bcx, addr, ~[0u, i]);
let base = GEPi(bcx, base_val, ~[0u, i]);
let val = load_if_immediate(bcx, base, tf.mt.ty);
@ -3533,7 +3537,7 @@ fn trans_struct(block_context: block, span: span, fields: ~[ast::field],
for fields.each |field| {
let mut found = none;
for class_fields.eachi |i, class_field| {
if str::eq(class_field.ident, field.node.ident) {
if class_field.ident == field.node.ident {
found = some((i, class_field.id));
break;
}
@ -3572,7 +3576,7 @@ fn trans_struct(block_context: block, span: span, fields: ~[ast::field],
// Copy over inherited fields.
for class_fields.eachi |i, class_field| {
let exists = do vec::any(fields) |provided_field| {
str::eq(provided_field.node.ident, class_field.ident)
provided_field.node.ident == class_field.ident
};
if exists {
again;
@ -3809,7 +3813,7 @@ fn trans_expr(bcx: block, e: @ast::expr, dest: dest) -> block {
match check ty::get(expr_ty(bcx, e)).struct {
ty::ty_fn({proto, _}) => {
debug!{"translating fn_block %s with type %s",
expr_to_str(e),
expr_to_str(e, tcx.sess.intr()),
ppaux::ty_to_str(tcx, expr_ty(bcx, e))};
return closure::trans_expr_fn(bcx, proto, decl, body,
e.id, cap_clause, none, dest);
@ -3941,8 +3945,8 @@ fn lval_to_dps(bcx: block, e: @ast::expr, dest: dest) -> block {
let ty = expr_ty(bcx, e);
let lv = trans_lval(bcx, e);
let last_use = (lv.kind == lv_owned && last_use_map.contains_key(e.id));
debug!{"is last use (%s) = %b, %d", expr_to_str(e), last_use,
lv.kind as int};
debug!{"is last use (%s) = %b, %d", expr_to_str(e, bcx.ccx().sess.intr()),
last_use, lv.kind as int};
lval_result_to_dps(lv, ty, last_use, dest)
}
@ -4016,17 +4020,17 @@ fn trans_log(log_ex: @ast::expr, lvl: @ast::expr,
}
let modpath = vec::append(
~[path_mod(ccx.link_meta.name)],
~[path_mod(ccx.sess.ident_of(ccx.link_meta.name))],
vec::filter(bcx.fcx.path, |e|
match e { path_mod(_) => true, _ => false }
));
let modname = path_str(modpath);
let modname = path_str(ccx.sess, modpath);
let global = if ccx.module_data.contains_key(modname) {
ccx.module_data.get(modname)
} else {
let s = link::mangle_internal_name_by_path_and_seq(
ccx, modpath, @~"loglevel");
ccx, modpath, ~"loglevel");
let global = str::as_c_str(s, |buf| {
llvm::LLVMAddGlobal(ccx.llmod, T_i32(), buf)
});
@ -4061,7 +4065,8 @@ fn trans_log(log_ex: @ast::expr, lvl: @ast::expr,
fn trans_check_expr(bcx: block, chk_expr: @ast::expr,
pred_expr: @ast::expr, s: ~str) -> block {
let _icx = bcx.insn_ctxt("trans_check_expr");
let expr_str = s + ~" " + expr_to_str(pred_expr) + ~" failed";
let expr_str = s + ~" " + expr_to_str(pred_expr, bcx.ccx().sess.intr())
+ ~" failed";
let {bcx, val} = {
do with_scope_result(bcx, chk_expr.info(), ~"check") |bcx| {
trans_temp_expr(bcx, pred_expr)
@ -4292,10 +4297,10 @@ fn init_local(bcx: block, local: @ast::local) -> block {
fn trans_stmt(cx: block, s: ast::stmt) -> block {
let _icx = cx.insn_ctxt("trans_stmt");
debug!{"trans_stmt(%s)", stmt_to_str(s)};
debug!{"trans_stmt(%s)", stmt_to_str(s, cx.tcx().sess.intr())};
if !cx.sess().no_asm_comments() {
add_span_comment(cx, s.span, stmt_to_str(s));
add_span_comment(cx, s.span, stmt_to_str(s, cx.ccx().sess.intr()));
}
let mut bcx = cx;
@ -4331,8 +4336,8 @@ fn new_block(cx: fn_ctxt, parent: option<block>, +kind: block_kind,
let s = if cx.ccx.sess.opts.save_temps || cx.ccx.sess.opts.debuginfo {
cx.ccx.names(name)
} else { ~"" };
let llbb: BasicBlockRef = str::as_c_str(s, |buf| {
} else { special_idents::invalid };
let llbb: BasicBlockRef = str::as_c_str(cx.ccx.sess.str_of(s), |buf| {
llvm::LLVMAppendBasicBlock(cx.llfn, buf)
});
let bcx = mk_block(llbb, parent, kind, is_lpad, opt_node_info, cx);
@ -4543,7 +4548,7 @@ fn alloc_local(cx: block, local: @ast::local) -> block {
let val = alloc_ty(cx, t);
if cx.sess().opts.debuginfo {
do option::iter(simple_name) |name| {
str::as_c_str(*name, |buf| {
str::as_c_str(cx.ccx().sess.str_of(name), |buf| {
llvm::LLVMSetValueName(val, buf)
});
}
@ -4808,7 +4813,7 @@ fn trans_fn(ccx: @crate_ctxt,
|_bcx| { });
if do_time {
let end = time::get_time();
log_fn_time(ccx, path_str(path), start, end);
log_fn_time(ccx, path_str(ccx.sess, path), start, end);
}
}
@ -4824,7 +4829,7 @@ fn trans_enum_variant(ccx: @crate_ctxt,
let fn_args = vec::map(args, |varg|
{mode: ast::expl(ast::by_copy),
ty: varg.ty,
ident: @~"arg",
ident: special_idents::arg,
id: varg.id});
let fcx = new_fn_ctxt_w_id(ccx, ~[], llfndecl, variant.node.id,
param_substs, none);
@ -5129,7 +5134,8 @@ fn register_fn_fuller(ccx: @crate_ctxt, sp: span, path: path,
ccx.item_symbols.insert(node_id, ps);
debug!{"register_fn_fuller created fn %s for item %d with path %s",
val_str(ccx.tn, llfn), node_id, ast_map::path_to_str(path)};
val_str(ccx.tn, llfn), node_id,
ast_map::path_to_str(path, ccx.sess.parse_sess.interner)};
let is_main = is_main_name(path) && !ccx.sess.building_library;
if is_main { create_main_wrapper(ccx, sp, llfn, node_type); }
@ -5252,7 +5258,7 @@ fn get_dtor_symbol(ccx: @crate_ctxt, path: path, id: ast::node_id,
none if is_none(substs) => {
let s = mangle_exported_name(
ccx,
vec::append(path, ~[path_name(@ccx.names(~"dtor"))]),
vec::append(path, ~[path_name(ccx.names(~"dtor"))]),
t);
ccx.item_symbols.insert(id, s);
s
@ -5266,7 +5272,7 @@ fn get_dtor_symbol(ccx: @crate_ctxt, path: path, id: ast::node_id,
mangle_exported_name(
ccx,
vec::append(path,
~[path_name(@ccx.names(~"dtor"))]),
~[path_name(ccx.names(~"dtor"))]),
mono_ty)
}
none => {
@ -5397,7 +5403,7 @@ fn get_item_val(ccx: @crate_ctxt, id: ast::node_id) -> ValueRef {
fn register_method(ccx: @crate_ctxt, id: ast::node_id, pth: @ast_map::path,
m: @ast::method) -> ValueRef {
let mty = ty::node_id_to_type(ccx.tcx, id);
let pth = vec::append(*pth, ~[path_name(@ccx.names(~"meth")),
let pth = vec::append(*pth, ~[path_name(ccx.names(~"meth")),
path_name(m.ident)]);
let llfn = register_fn_full(ccx, m.span, pth, id, mty);
set_inline_hint_if_appr(m.attrs, llfn);
@ -5415,7 +5421,7 @@ fn trans_constant(ccx: @crate_ctxt, it: @ast::item) {
let path = item_path(ccx, it);
for vec::each(enum_definition.variants) |variant| {
let p = vec::append(path, ~[path_name(variant.node.name),
path_name(@~"discrim")]);
path_name(special_idents::descrim)]);
let s = mangle_exported_name(ccx, p, ty::mk_int(ccx.tcx));
let disr_val = vi[i].disr_val;
note_unique_llvm_symbol(ccx, s);
@ -5535,7 +5541,7 @@ fn gather_local_rtcalls(ccx: @crate_ctxt, crate: @ast::crate) {
do vec::iter(attr_metas) |attr_meta| {
match attr::get_meta_item_list(attr_meta) {
some(list) => {
let name = *attr::get_meta_item_name(vec::head(list));
let name = attr::get_meta_item_name(vec::head(list));
push_rtcall(ccx, name, {crate: ast::local_crate,
node: item.id});
}
@ -5551,7 +5557,7 @@ fn gather_local_rtcalls(ccx: @crate_ctxt, crate: @ast::crate) {
fn gather_external_rtcalls(ccx: @crate_ctxt) {
do cstore::iter_crate_data(ccx.sess.cstore) |_cnum, cmeta| {
do decoder::each_path(cmeta) |path| {
do decoder::each_path(ccx.sess.intr(), cmeta) |path| {
let pathname = path.path_string;
match path.def_like {
decoder::dl_def(d) => {
@ -5624,7 +5630,7 @@ fn decl_crate_map(sess: session::session, mapmeta: link_meta,
let cstore = sess.cstore;
while cstore::have_crate_data(cstore, n_subcrates) { n_subcrates += 1; }
let mapname = if sess.building_library {
*mapmeta.name + ~"_" + *mapmeta.vers + ~"_" + mapmeta.extras_hash
mapmeta.name + ~"_" + mapmeta.vers + ~"_" + mapmeta.extras_hash
} else { ~"toplevel" };
let sym_name = ~"_rust_crate_map_" + mapname;
let arrtype = T_array(int_type, n_subcrates as uint);
@ -5643,8 +5649,8 @@ fn fill_crate_map(ccx: @crate_ctxt, map: ValueRef) {
while cstore::have_crate_data(cstore, i) {
let cdata = cstore::get_crate_data(cstore, i);
let nm = ~"_rust_crate_map_" + cdata.name +
~"_" + *cstore::get_crate_vers(cstore, i) +
~"_" + *cstore::get_crate_hash(cstore, i);
~"_" + cstore::get_crate_vers(cstore, i) +
~"_" + cstore::get_crate_hash(cstore, i);
let cr = str::as_c_str(nm, |buf| {
llvm::LLVMAddGlobal(ccx.llmod, ccx.int_type, buf)
});
@ -5683,8 +5689,8 @@ fn crate_ctxt_to_encode_parms(cx: @crate_ctxt)
if !def.reexp { again; }
let path = match check cx.tcx.items.get(exp_id) {
ast_map::node_export(_, path) => {
ast_map::path_to_str(*path)
ast_map::path_to_str(*path,
cx.sess.parse_sess.interner)
}
};
vec::push(reexports, (path, def.id));
@ -5746,7 +5752,7 @@ fn trans_crate(sess: session::session,
// crashes if the module identifer is same as other symbols
// such as a function name in the module.
// 1. http://llvm.org/bugs/show_bug.cgi?id=11479
let llmod_id = *link_meta.name + ~".rc";
let llmod_id = link_meta.name + ~".rc";
let llmod = str::as_c_str(llmod_id, |buf| {
llvm::LLVMModuleCreateWithNameInContext
@ -5776,7 +5782,7 @@ fn trans_crate(sess: session::session,
lib::llvm::associate_type(tn, ~"tydesc", tydesc_type);
let crate_map = decl_crate_map(sess, link_meta, llmod);
let dbg_cx = if sess.opts.debuginfo {
option::some(debuginfo::mk_ctxt(llmod_id))
option::some(debuginfo::mk_ctxt(llmod_id, sess.parse_sess.interner))
} else {
option::none
};
@ -5808,7 +5814,7 @@ fn trans_crate(sess: session::session,
const_globals: int_hash::<ValueRef>(),
module_data: str_hash::<ValueRef>(),
lltypes: ty::new_ty_hash(),
names: new_namegen(),
names: new_namegen(sess.parse_sess.interner),
symbol_hasher: symbol_hasher,
type_hashcodes: ty::new_ty_hash(),
type_short_names: ty::new_ty_hash(),

7
src/rustc/middle/trans/closure.rs
View file

@ -263,7 +263,9 @@ fn build_closure(bcx0: block,
let lv = trans_local_var(bcx, cap_var.def);
let nid = ast_util::def_id_of_def(cap_var.def).node;
debug!{"Node id is %s",
syntax::ast_map::node_id_to_str(bcx.ccx().tcx.items, nid)};
syntax::ast_map::node_id_to_str
(bcx.ccx().tcx.items, nid,
bcx.ccx().sess.parse_sess.interner)};
let mut ty = node_id_type(bcx, nid);
match cap_var.mode {
capture::cap_ref => {
@ -359,7 +361,8 @@ fn trans_expr_fn(bcx: block,
let ccx = bcx.ccx();
let fty = node_id_type(bcx, id);
let llfnty = type_of_fn_from_ty(ccx, fty);
let sub_path = vec::append_one(bcx.fcx.path, path_name(@~"anon"));
let sub_path = vec::append_one(bcx.fcx.path,
path_name(special_idents::anon));
let s = mangle_internal_name_by_path(ccx, sub_path);
let llfn = decl_internal_cdecl_fn(ccx.llmod, s, llfnty);

21
src/rustc/middle/trans/common.rs
View file

@ -20,11 +20,14 @@ import metadata::{csearch};
import metadata::common::link_meta;
import syntax::ast_map::path;
import util::ppaux::ty_to_str;
import syntax::parse::token::ident_interner;
import syntax::ast::ident;
type namegen = fn@(~str) -> ~str;
fn new_namegen() -> namegen {
let i = @mut 0;
return fn@(prefix: ~str) -> ~str { *i += 1; prefix + int::str(*i) };
type namegen = fn@(~str) -> ident;
fn new_namegen(intr: ident_interner) -> namegen {
return fn@(prefix: ~str) -> ident {
return intr.gensym(@fmt!("%s_%u", prefix, intr.gensym(@prefix)))
};
}
type tydesc_info =
@ -873,7 +876,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(cx.names(~"str"),
str::as_c_str(fmt!{"str%u", cx.names(~"str")},
|buf| llvm::LLVMAddGlobal(cx.llmod, val_ty(sc), buf));
llvm::LLVMSetInitializer(g, sc);
llvm::LLVMSetGlobalConstant(g, True);
@ -927,7 +930,7 @@ fn C_bytes(bytes: ~[u8]) -> ValueRef unsafe {
fn C_shape(ccx: @crate_ctxt, bytes: ~[u8]) -> ValueRef {
let llshape = C_bytes(bytes);
let llglobal = str::as_c_str(ccx.names(~"shape"), |buf| {
let llglobal = str::as_c_str(fmt!{"shape%u", ccx.names(~"shape")}, |buf| {
llvm::LLVMAddGlobal(ccx.llmod, val_ty(llshape), buf)
});
llvm::LLVMSetInitializer(llglobal, llshape);
@ -983,13 +986,13 @@ fn align_to(cx: block, off: ValueRef, align: ValueRef) -> ValueRef {
return build::And(cx, bumped, build::Not(cx, mask));
}
fn path_str(p: path) -> ~str {
fn path_str(sess: session::session, p: path) -> ~str {
let mut r = ~"", first = true;
for vec::each(p) |e| {
match e { ast_map::path_name(s) | ast_map::path_mod(s) => {
if first { first = false; }
else { r += ~"::"; }
r += *s;
r += sess.str_of(s);
} }
}
r
@ -1023,7 +1026,7 @@ fn field_idx_strict(cx: ty::ctxt, sp: span, ident: ast::ident,
match ty::field_idx(ident, fields) {
none => cx.sess.span_bug(
sp, fmt!{"base expr doesn't appear to \
have a field named %s", *ident}),
have a field named %s", cx.sess.str_of(ident)}),
some(i) => i
}
}

25
src/rustc/middle/trans/debuginfo.rs
View file

@ -7,6 +7,7 @@ import trans::base;
import trans::build::B;
import middle::ty;
import syntax::{ast, codemap, ast_util, ast_map};
import syntax::parse::token::ident_interner;
import codemap::span;
import ast::ty;
import pat_util::*;
@ -89,9 +90,9 @@ type debug_ctxt = {
crate_file: ~str
};
fn mk_ctxt(crate: ~str) -> debug_ctxt {
fn mk_ctxt(crate: ~str, intr: ident_interner) -> debug_ctxt {
{llmetadata: map::int_hash(),
names: new_namegen(),
names: new_namegen(intr),
crate_file: crate}
}
@ -392,14 +393,15 @@ fn create_record(cx: @crate_ctxt, t: ty::t, fields: ~[ast::ty_field],
let fname = filename_from_span(cx, span);
let file_node = create_file(cx, fname);
let scx = create_structure(file_node,
option::get(cx.dbg_cx).names(~"rec"),
cx.sess.str_of(
option::get(cx.dbg_cx).names(~"rec")),
line_from_span(cx.sess.codemap,
span) as int);
for fields.each |field| {
let field_t = ty::get_field(t, field.node.ident).mt.ty;
let ty_md = create_ty(cx, field_t, field.node.mt.ty);
let (size, align) = size_and_align_of(cx, field_t);
add_member(scx, *field.node.ident,
add_member(scx, cx.sess.str_of(field.node.ident),
line_from_span(cx.sess.codemap, field.span) as int,
size as int, align as int, ty_md.node);
}
@ -635,7 +637,7 @@ fn create_local_var(bcx: block, local: @ast::local)
none => create_function(bcx.fcx).node,
some(_) => create_block(bcx).node
};
let mdnode = create_var(tg, context, *name, filemd.node,
let mdnode = create_var(tg, context, cx.sess.str_of(name), filemd.node,
loc.line as int, tymd.node);
let mdval = @{node: mdnode, data: {id: local.node.id}};
update_cache(cache, AutoVariableTag, local_var_metadata(mdval));
@ -677,8 +679,8 @@ fn create_arg(bcx: block, arg: ast::arg, sp: span)
let tymd = create_ty(cx, ty, arg.ty);
let filemd = create_file(cx, loc.file.name);
let context = create_function(bcx.fcx);
let mdnode = create_var(tg, context.node, *arg.ident, filemd.node,
loc.line as int, tymd.node);
let mdnode = create_var(tg, context.node, cx.sess.str_of(arg.ident),
filemd.node, loc.line as int, tymd.node);
let mdval = @{node: mdnode, data: {id: arg.id}};
update_cache(cache, tg, argument_metadata(mdval));
@ -736,10 +738,10 @@ fn create_function(fcx: fn_ctxt) -> @metadata<subprogram_md> {
ast_map::node_expr(expr) => {
match expr.node {
ast::expr_fn(_, decl, _, _) => {
(@dbg_cx.names(~"fn"), decl.output, expr.id)
(dbg_cx.names(~"fn"), decl.output, expr.id)
}
ast::expr_fn_block(decl, _, _) => {
(@dbg_cx.names(~"fn"), decl.output, expr.id)
(dbg_cx.names(~"fn"), decl.output, expr.id)
}
_ => fcx.ccx.sess.span_bug(expr.span,
~"create_function: \
@ -778,8 +780,9 @@ fn create_function(fcx: fn_ctxt) -> @metadata<subprogram_md> {
let fn_metadata = ~[lltag(SubprogramTag),
llunused(),
file_node,
llstr(*ident),
llstr(*ident), //XXX fully-qualified C++ name
llstr(cx.sess.str_of(ident)),
//XXX fully-qualified C++ name:
llstr(cx.sess.str_of(ident)),
llstr(~""), //XXX MIPS name?????
file_node,
lli32(loc.line as int),

21
src/rustc/middle/trans/foreign.rs
View file

@ -412,10 +412,10 @@ fn decl_x86_64_fn(tys: x86_64_tys,
return llfn;
}
fn link_name(i: @ast::foreign_item) -> ~str {
fn link_name(ccx: @crate_ctxt, i: @ast::foreign_item) -> ~str {
match attr::first_attr_value_str_by_name(i.attrs, ~"link_name") {
none => return *i.ident,
option::some(ln) => return *ln
none => ccx.sess.str_of(i.ident),
option::some(ln) => ln
}
}
@ -669,7 +669,7 @@ fn trans_foreign_mod(ccx: @crate_ctxt,
}
}
let lname = link_name(foreign_item);
let lname = link_name(ccx, foreign_item);
let llbasefn = base_fn(ccx, lname, tys, cc);
// Name the shim function
let shim_name = lname + ~"__c_stack_shim";
@ -700,7 +700,7 @@ fn trans_foreign_mod(ccx: @crate_ctxt,
cc: lib::llvm::CallConv) {
let fcx = new_fn_ctxt(ccx, ~[], decl, none);
let bcx = top_scope_block(fcx, none), lltop = bcx.llbb;
let llbasefn = base_fn(ccx, link_name(item), tys, cc);
let llbasefn = base_fn(ccx, link_name(ccx, item), tys, cc);
let ty = ty::lookup_item_type(ccx.tcx,
ast_util::local_def(item.id)).ty;
let args = vec::from_fn(ty::ty_fn_args(ty).len(), |i| {
@ -799,7 +799,7 @@ fn trans_intrinsic(ccx: @crate_ctxt, decl: ValueRef, item: @ast::foreign_item,
let fcx = new_fn_ctxt_w_id(ccx, path, decl, item.id,
some(substs), some(item.span));
let mut bcx = top_scope_block(fcx, none), lltop = bcx.llbb;
match *item.ident {
match ccx.sess.str_of(item.ident) {
// NB: Transitionary, de-mode-ing. Remove the first string of each
// pattern when the old intrinsics are gone.
~"atomic_xchng" | ~"atomic_xchg" => {
@ -1001,7 +1001,9 @@ fn trans_foreign_fn(ccx: @crate_ctxt, path: ast_map::path, decl: ast::fn_decl,
let _icx = ccx.insn_ctxt("foreign::foreign::build_rust_fn");
let t = ty::node_id_to_type(ccx.tcx, id);
let ps = link::mangle_internal_name_by_path(
ccx, vec::append_one(path, ast_map::path_name(@~"__rust_abi")));
ccx, vec::append_one(path, ast_map::path_name(
syntax::parse::token::special_idents::clownshoe_abi
)));
let llty = type_of_fn_from_ty(ccx, t);
let llfndecl = decl_internal_cdecl_fn(ccx.llmod, ps, llty);
trans_fn(ccx, path, decl, body, llfndecl, no_self, none, id);
@ -1038,8 +1040,9 @@ fn trans_foreign_fn(ccx: @crate_ctxt, path: ast_map::path, decl: ast::fn_decl,
}
let shim_name = link::mangle_internal_name_by_path(
ccx, vec::append_one(path,
ast_map::path_name(@~"__rust_stack_shim")));
ccx, vec::append_one(path, ast_map::path_name(
syntax::parse::token::special_idents::clownshoe_stack_shim
)));
return build_shim_fn_(ccx, shim_name, llrustfn, tys,
lib::llvm::CCallConv,
build_args, build_ret);

4
src/rustc/middle/trans/impl.rs
View file

@ -163,7 +163,7 @@ fn trans_static_method_callee(bcx: block, method_id: ast::def_id,
}
};
debug!("trans_static_method_callee: method_id=%?, callee_id=%?, \
name=%s", method_id, callee_id, *mname);
name=%s", method_id, callee_id, ccx.sess.str_of(mname));
let vtbls = resolve_vtables_in_fn_ctxt(
bcx.fcx, ccx.maps.vtable_map.get(callee_id));
@ -361,7 +361,7 @@ fn get_vtable(ccx: @crate_ctxt, origin: typeck::vtable_origin)
fn make_vtable(ccx: @crate_ctxt, ptrs: ~[ValueRef]) -> ValueRef {
let _icx = ccx.insn_ctxt("impl::make_vtable");
let tbl = C_struct(ptrs);
let vt_gvar = str::as_c_str(ccx.names(~"vtable"), |buf| {
let vt_gvar = str::as_c_str(ccx.sess.str_of(ccx.names(~"vtable")), |buf| {
llvm::LLVMAddGlobal(ccx.llmod, val_ty(tbl), buf)
});
llvm::LLVMSetInitializer(vt_gvar, tbl);

3
src/rustc/middle/trans/reachable.rs
View file

@ -175,7 +175,8 @@ fn traverse_inline_body(cx: ctx, body: blk) {
traverse_def_id(cx, def_id_of_def(d));
}
none => cx.tcx.sess.span_bug(e.span, fmt!{"Unbound node \
id %? while traversing %s", e.id, expr_to_str(e)})
id %? while traversing %s", e.id,
expr_to_str(e, cx.tcx.sess.intr())})
}
}
expr_field(_, _, _) => {

18
src/rustc/middle/trans/reflect.rs
View file

@ -55,7 +55,8 @@ impl reflector {
fn visit(ty_name: ~str, args: ~[ValueRef]) {
let tcx = self.bcx.tcx();
let mth_idx = option::get(ty::method_idx(@(~"visit_" + ty_name),
let mth_idx = option::get(ty::method_idx(
tcx.sess.ident_of(~"visit_" + ty_name),
*self.visitor_methods));
let mth_ty = ty::mk_fn(tcx, self.visitor_methods[mth_idx].fty);
let v = self.visitor_val;
@ -157,7 +158,8 @@ impl reflector {
for fields.eachi |i, field| {
self.visit(~"rec_field",
~[self.c_uint(i),
self.c_slice(*field.ident)]
self.c_slice(
bcx.ccx().sess.str_of(field.ident))]
+ self.c_mt(field.mt));
}
}
@ -233,7 +235,8 @@ impl reflector {
for fields.eachi |i, field| {
self.visit(~"class_field",
~[self.c_uint(i),
self.c_slice(*field.ident)]
self.c_slice(
bcx.ccx().sess.str_of(field.ident))]
+ self.c_mt(field.mt));
}
}
@ -256,7 +259,8 @@ impl reflector {
~[self.c_uint(i),
self.c_int(v.disr_val),
self.c_uint(vec::len(v.args)),
self.c_slice(*v.name)]) {
self.c_slice(
bcx.ccx().sess.str_of(v.name))]) {
for v.args.eachi |j, a| {
self.visit(~"enum_variant_field",
~[self.c_uint(j),
@ -291,10 +295,10 @@ impl reflector {
fn emit_calls_to_trait_visit_ty(bcx: block, t: ty::t,
visitor_val: ValueRef,
visitor_trait_id: def_id) -> block {
import syntax::parse::token::special_idents::tydesc;
let final = sub_block(bcx, ~"final");
assert bcx.ccx().tcx.intrinsic_defs.contains_key(@~"tydesc");
let (_, tydesc_ty) = bcx.ccx().tcx.intrinsic_defs.get(@~"tydesc");
assert bcx.ccx().tcx.intrinsic_defs.contains_key(tydesc);
let (_, tydesc_ty) = bcx.ccx().tcx.intrinsic_defs.get(tydesc);
let tydesc_ty = type_of::type_of(bcx.ccx(), tydesc_ty);
let r = reflector({
visitor_val: visitor_val,

6
src/rustc/middle/trans/shape.rs
View file

@ -391,7 +391,7 @@ fn gen_enum_shapes(ccx: @crate_ctxt) -> ValueRef {
let variant_shape = shape_of_variant(ccx, v);
add_substr(data, variant_shape);
let zname = str::bytes(*v.name) + ~[0u8];
let zname = str::bytes(ccx.sess.str_of(v.name)) + ~[0u8];
add_substr(data, zname);
}
enum_variants += ~[variants];
@ -732,8 +732,8 @@ fn simplify_type(tcx: ty::ctxt, typ: ty::t) -> ty::t {
ty::ty_class(did, ref substs) => {
let simpl_fields = (if is_some(ty::ty_dtor(tcx, did)) {
// remember the drop flag
~[{ident: @~"drop", mt: {ty:
ty::mk_u8(tcx),
~[{ident: syntax::parse::token::special_idents::dtor,
mt: {ty: ty::mk_u8(tcx),
mutbl: ast::m_mutbl}}] }
else { ~[] }) +
do ty::lookup_class_fields(tcx, did).map |f| {

2
src/rustc/middle/trans/type_use.rs
View file

@ -81,7 +81,7 @@ fn type_uses_for(ccx: @crate_ctxt, fn_id: def_id, n_tps: uint)
ast_map::node_foreign_item(i@@{node: foreign_item_fn(_, _), _},
abi, _) => {
if abi == foreign_abi_rust_intrinsic {
let flags = match *i.ident {
let flags = match cx.ccx.sess.str_of(i.ident) {
~"size_of" | ~"pref_align_of" | ~"min_align_of" |
~"init" | ~"reinterpret_cast" |
~"move_val" | ~"move_val_init" => {

35
src/rustc/middle/ty.rs
View file

@ -616,7 +616,7 @@ fn mk_ctxt(s: session::session,
node_types: @smallintmap::mk(),
node_type_substs: map::int_hash(),
items: amap,
intrinsic_defs: map::box_str_hash(),
intrinsic_defs: map::uint_hash(),
freevars: freevars,
tcache: ast_util::new_def_hash(),
rcache: mk_rcache(),
@ -2200,7 +2200,7 @@ pure fn hash_bound_region(br: &bound_region) -> uint {
match *br { // no idea if this is any good
ty::br_self => 0u,
ty::br_anon(idx) => 1u | (idx << 2),
ty::br_named(str) => 2u | (str::hash(str) << 2),
ty::br_named(ident) => 2u | (ident << 2),
ty::br_cap_avoid(id, br) =>
3u | (id as uint << 2) | hash_bound_region(br)
}
@ -2310,10 +2310,13 @@ pure fn hash_type_structure(st: &sty) -> uint {
}
fn node_id_to_type(cx: ctxt, id: ast::node_id) -> t {
//io::println(fmt!("%?/%?", id, cx.node_types.size()));
match smallintmap::find(*cx.node_types, id as uint) {
some(t) => t,
none => cx.sess.bug(fmt!{"node_id_to_type: unbound node ID %s",
ast_map::node_id_to_str(cx.items, id)})
none => cx.sess.bug(
fmt!{"node_id_to_type: unbound node ID %s",
ast_map::node_id_to_str(cx.items, id,
cx.sess.parse_sess.interner)})
}
}
@ -2482,7 +2485,7 @@ fn field_idx(id: ast::ident, fields: ~[field]) -> option<uint> {
}
fn get_field(rec_ty: t, id: ast::ident) -> field {
match check vec::find(get_fields(rec_ty), |f| str::eq(f.ident, id)) {
match check vec::find(get_fields(rec_ty), |f| f.ident == id) {
some(f) => f
}
}
@ -2703,9 +2706,9 @@ fn type_err_to_str(cx: ctxt, err: &type_err) -> ~str {
~"record elements differ in mutability"
}
terr_record_fields(values) => {
fmt!("expected a record with field `%s` \
but found one with field `%s`",
*values.expected, *values.found)
fmt!("expected a record with field `%s` but found one with field \
`%s`",
cx.sess.str_of(values.expected), cx.sess.str_of(values.found))
}
terr_arg_count => ~"incorrect number of function parameters",
terr_mode_mismatch(values) => {
@ -2734,7 +2737,8 @@ fn type_err_to_str(cx: ctxt, err: &type_err) -> ~str {
vstore_to_str(cx, values.found))
}
terr_in_field(err, fname) => {
fmt!{"in field `%s`, %s", *fname, type_err_to_str(cx, err)}
fmt!("in field `%s`, %s", cx.sess.str_of(fname),
type_err_to_str(cx, err))
}
terr_sorts(values) => {
fmt!{"expected %s but found %s",
@ -2844,7 +2848,7 @@ fn substd_enum_variants(cx: ctxt,
}
fn item_path_str(cx: ctxt, id: ast::def_id) -> ~str {
ast_map::path_to_str(item_path(cx, id))
ast_map::path_to_str(item_path(cx, id), cx.sess.parse_sess.interner)
}
/* If class_id names a class with a dtor, return some(the dtor's id).
@ -2909,7 +2913,8 @@ fn item_path(cx: ctxt, id: ast::def_id) -> ast_map::path {
vec::append_one(*path, ast_map::path_name(nm))
}
ast_map::node_dtor(_, _, _, path) => {
vec::append_one(*path, ast_map::path_name(@~"dtor"))
vec::append_one(*path, ast_map::path_name(
syntax::parse::token::special_idents::literally_dtor))
}
ast_map::node_stmt(*) | ast_map::node_expr(*) |
@ -3062,8 +3067,10 @@ fn lookup_class_fields(cx: ctxt, did: ast::def_id) -> ~[field_ty] {
}
}
_ => {
cx.sess.bug(fmt!{"class ID not bound to an item: %s",
ast_map::node_id_to_str(cx.items, did.node)});
cx.sess.bug(
fmt!{"class ID not bound to an item: %s",
ast_map::node_id_to_str(cx.items, did.node,
cx.sess.parse_sess.interner)});
}
}
}
@ -3129,7 +3136,7 @@ fn lookup_class_method_by_name(cx:ctxt, did: ast::def_id, name: ident,
}
}
cx.sess.span_fatal(sp, fmt!{"Class doesn't have a method \
named %s", *name});
named %s", cx.sess.str_of(name)});
}
else {
csearch::get_class_method(cx.sess.cstore, did, name)

5
src/rustc/middle/typeck/astconv.rs
View file

@ -309,8 +309,9 @@ fn ast_ty_to_ty<AC: ast_conv, RS: region_scope copy owned>(
}
ast::ty_path(path, id) => {
let a_def = match tcx.def_map.find(id) {
none => tcx.sess.span_fatal(ast_ty.span, fmt!{"unbound path %s",
path_to_str(path)}),
none => tcx.sess.span_fatal(
ast_ty.span, fmt!{"unbound path %s",
path_to_str(path, tcx.sess.intr())}),
some(d) => d
};
match a_def {

110
src/rustc/middle/typeck/check.rs
View file

@ -75,7 +75,7 @@ import rscope::{in_binding_rscope, region_scope, type_rscope};
import syntax::ast::ty_i;
import typeck::infer::{resolve_type, force_tvar};
import std::map::str_hash;
import std::map::{str_hash, uint_hash};
type self_info = {
self_ty: ty::t,
@ -335,7 +335,8 @@ fn check_fn(ccx: @crate_ctxt,
do vec::iter2(arg_tys, decl.inputs) |arg_ty, input| {
assign(input.ty.span, input.id, some(arg_ty));
debug!{"Argument %s is assigned to %s",
*input.ident, fcx.locals.get(input.id).to_str()};
tcx.sess.str_of(input.ident),
fcx.locals.get(input.id).to_str()};
}
// Add explicitly-declared locals.
@ -347,7 +348,7 @@ fn check_fn(ccx: @crate_ctxt,
};
assign(local.span, local.node.id, o_ty);
debug!{"Local variable %s is assigned to %s",
pat_to_str(local.node.pat),
pat_to_str(local.node.pat, tcx.sess.intr()),
fcx.locals.get(local.node.id).to_str()};
visit::visit_local(local, e, v);
};
@ -359,7 +360,7 @@ fn check_fn(ccx: @crate_ctxt,
if !pat_util::pat_is_variant(fcx.ccx.tcx.def_map, p) => {
assign(p.span, p.id, none);
debug!{"Pattern binding %s is assigned to %s",
*path.idents[0],
tcx.sess.str_of(path.idents[0]),
fcx.locals.get(p.id).to_str()};
}
_ => {}
@ -405,15 +406,15 @@ fn check_method(ccx: @crate_ctxt, method: @ast::method,
fn check_no_duplicate_fields(tcx: ty::ctxt, fields:
~[(ast::ident, span)]) {
let field_names = hashmap::<@~str, span>(|x| str::hash(*x),
|x,y| str::eq(*x, *y));
let field_names = uint_hash();
for fields.each |p| {
let (id, sp) = p;
match field_names.find(id) {
some(orig_sp) => {
tcx.sess.span_err(sp, fmt!{"Duplicate field \
name %s in record type declaration",
*id});
tcx.sess.str_of(id)});
tcx.sess.span_note(orig_sp, ~"First declaration of \
this field occurred here");
break;
@ -479,7 +480,7 @@ fn check_item(ccx: @crate_ctxt, it: @ast::item) {
ast::item_impl(tps, _, ty, ms) => {
let rp = ccx.tcx.region_paramd_items.contains_key(it.id);
debug!{"item_impl %s with id %d rp %b",
*it.ident, it.id, rp};
ccx.tcx.sess.str_of(it.ident), it.id, rp};
let self_ty = ccx.to_ty(rscope::type_rscope(rp), ty);
for ms.each |m| {
check_method(ccx, m, self_ty, local_def(it.id));
@ -555,9 +556,11 @@ impl @fn_ctxt: region_scope {
do empty_rscope.named_region(span, id).chain_err |_e| {
match self.in_scope_regions.find(ty::br_named(id)) {
some(r) => result::ok(r),
none if *id == ~"blk" => result::ok(self.block_region()),
none if id == syntax::parse::token::special_idents::blk
=> result::ok(self.block_region()),
none => {
result::err(fmt!{"named region `%s` not in scope here", *id})
result::err(fmt!{"named region `%s` not in scope here",
self.ccx.tcx.sess.str_of(id)})
}
}
}
@ -601,8 +604,10 @@ impl @fn_ctxt {
match self.node_types.find(ex.id) {
some(t) => t,
none => {
self.tcx().sess.bug(fmt!{"no type for expr %d (%s) in fcx %s",
ex.id, expr_to_str(ex), self.tag()});
self.tcx().sess.bug(
fmt!{"no type for expr %d (%s) in fcx %s",
ex.id, expr_to_str(ex, self.ccx.tcx.sess.intr()),
self.tag()});
}
}
}
@ -612,7 +617,9 @@ impl @fn_ctxt {
none => {
self.tcx().sess.bug(
fmt!{"no type for node %d: %s in fcx %s",
id, ast_map::node_id_to_str(self.tcx().items, id),
id, ast_map::node_id_to_str(
self.tcx().items, id,
self.tcx().sess.parse_sess.interner),
self.tag()});
}
}
@ -623,7 +630,9 @@ impl @fn_ctxt {
none => {
self.tcx().sess.bug(
fmt!{"no type substs for node %d: %s in fcx %s",
id, ast_map::node_id_to_str(self.tcx().items, id),
id, ast_map::node_id_to_str(
self.tcx().items, id,
self.tcx().sess.parse_sess.interner),
self.tag()});
}
}
@ -842,8 +851,10 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
expected: option<ty::t>,
unifier: fn()) -> bool {
debug!{">> typechecking expr %d (%s)",
expr.id, syntax::print::pprust::expr_to_str(expr)};
debug!{
">> typechecking expr %d (%s)",
expr.id, syntax::print::pprust::expr_to_str(expr,
fcx.ccx.tcx.sess.intr())};
// A generic function to factor out common logic from call and
// overloaded operations
@ -1028,10 +1039,10 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
fn lookup_op_method(fcx: @fn_ctxt, op_ex: @ast::expr,
self_ex: @ast::expr, self_t: ty::t,
opname: ~str, args: ~[@ast::expr])
opname: ast::ident, args: ~[@ast::expr])
-> option<(ty::t, bool)> {
let lkup = method::lookup(fcx, op_ex, self_ex, op_ex.id,
op_ex.callee_id, @opname, self_t, ~[], false);
op_ex.callee_id, opname, self_t, ~[], false);
match lkup.method() {
some(origin) => {
let {fty: method_ty, bot: bot} = {
@ -1100,9 +1111,8 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
let tcx = fcx.ccx.tcx;
match ast_util::binop_to_method_name(op) {
some(name) => {
match lookup_op_method(fcx, ex,
lhs_expr, lhs_resolved_t,
name, ~[rhs]) {
match lookup_op_method(fcx, ex, lhs_expr, lhs_resolved_t,
fcx.tcx().sess.ident_of(name), ~[rhs]) {
some(pair) => return pair,
_ => ()
}
@ -1134,7 +1144,8 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
fn check_user_unop(fcx: @fn_ctxt, op_str: ~str, mname: ~str,
ex: @ast::expr,
rhs_expr: @ast::expr, rhs_t: ty::t) -> ty::t {
match lookup_op_method(fcx, ex, rhs_expr, rhs_t, mname, ~[]) {
match lookup_op_method(fcx, ex, rhs_expr, rhs_t,
fcx.tcx().sess.ident_of(mname), ~[]) {
some((ret_ty, _)) => ret_ty,
_ => {
fcx.ccx.tcx.sess.span_err(
@ -1221,7 +1232,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
let fty = ty::mk_fn(tcx, fn_ty);
debug!{"check_expr_fn_with_unifier %s fty=%s",
expr_to_str(expr), fcx.infcx.ty_to_str(fty)};
expr_to_str(expr, tcx.sess.intr()), fcx.infcx.ty_to_str(fty)};
fcx.write_ty(expr.id, fty);
@ -1315,7 +1326,8 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
let msg = fmt!{"attempted access of field `%s` on type `%s`, \
but no public field or method with that name \
was found",
*field, fcx.infcx.ty_to_str(t_err)};
tcx.sess.str_of(field),
fcx.infcx.ty_to_str(t_err)};
tcx.sess.span_err(expr.span, msg);
// NB: Adding a bogus type to allow typechecking to continue
fcx.write_ty(expr.id, fcx.infcx.next_ty_var());
@ -1788,7 +1800,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
for fields_t.each |f| {
let mut found = false;
for base_fields.each |bf| {
if str::eq(f.node.ident, bf.ident) {
if f.node.ident == bf.ident {
demand::suptype(fcx, f.span, bf.mt.ty, f.node.mt.ty);
found = true;
}
@ -1796,7 +1808,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
if !found {
tcx.sess.span_fatal(f.span,
~"unknown field in record update: " +
*f.node.ident);
tcx.sess.str_of(f.node.ident));
}
}
}
@ -1873,27 +1885,27 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
// Look up the class fields and build up a map.
let class_fields = ty::lookup_class_fields(tcx, class_id);
let class_field_map = str_hash();
let class_field_map = uint_hash();
let mut fields_found = 0;
for class_fields.each |field| {
// XXX: Check visibility here.
class_field_map.insert(*field.ident, (field.id, false));
class_field_map.insert(field.ident, (field.id, false));
}
// Typecheck each field.
for fields.each |field| {
match class_field_map.find(*field.node.ident) {
match class_field_map.find(field.node.ident) {
none => {
tcx.sess.span_err(field.span,
fmt!{"structure has no field named \
field named `%s`",
*field.node.ident});
tcx.sess.span_err(
field.span,
fmt!{"structure has no field named field named `%s`",
tcx.sess.str_of(field.node.ident)});
}
some((_, true)) => {
tcx.sess.span_err(field.span,
fmt!{"field `%s` specified more than \
once",
*field.node.ident});
tcx.sess.span_err(
field.span,
fmt!{"field `%s` specified more than once",
tcx.sess.str_of(field.node.ident)});
}
some((field_id, false)) => {
let expected_field_type =
@ -1914,11 +1926,11 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
if fields_found < class_fields.len() {
let mut missing_fields = ~[];
for class_fields.each |class_field| {
let name = *class_field.ident;
let name = class_field.ident;
let (_, seen) = class_field_map.get(name);
if !seen {
vec::push(missing_fields,
~"`" + name + ~"`");
~"`" + tcx.sess.str_of(name) + ~"`");
}
}
@ -1960,7 +1972,8 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
none => {
let resolved = structurally_resolved_type(fcx, expr.span,
raw_base_t);
match lookup_op_method(fcx, expr, base, resolved, ~"index",
match lookup_op_method(fcx, expr, base, resolved,
tcx.sess.ident_of(~"index"),
~[idx]) {
some((ret_ty, _)) => fcx.write_ty(id, ret_ty),
_ => {
@ -1976,7 +1989,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
if bot { fcx.write_bot(expr.id); }
debug!{"type of expr %s is %s, expected is %s",
syntax::print::pprust::expr_to_str(expr),
syntax::print::pprust::expr_to_str(expr, tcx.sess.intr()),
ty_to_str(tcx, fcx.expr_ty(expr)),
match expected {
some(t) => ty_to_str(tcx, t),
@ -2456,7 +2469,8 @@ fn check_bounds_are_used(ccx: @crate_ctxt,
for tps_used.eachi |i, b| {
if !b {
ccx.tcx.sess.span_err(
span, fmt!{"type parameter `%s` is unused", *tps[i].ident});
span, fmt!{"type parameter `%s` is unused",
ccx.tcx.sess.str_of(tps[i].ident)});
}
}
}
@ -2469,7 +2483,7 @@ fn check_intrinsic_type(ccx: @crate_ctxt, it: @ast::foreign_item) {
{mode: ast::expl(m), ty: ty}
}
let tcx = ccx.tcx;
let (n_tps, inputs, output) = match *it.ident {
let (n_tps, inputs, output) = match ccx.tcx.sess.str_of(it.ident) {
~"size_of" |
~"pref_align_of" | ~"min_align_of" => (1u, ~[], ty::mk_uint(ccx.tcx)),
~"init" => (1u, ~[], param(ccx, 0u)),
@ -2511,10 +2525,12 @@ fn check_intrinsic_type(ccx: @crate_ctxt, it: @ast::foreign_item) {
(1u, ~[], ty::mk_nil_ptr(tcx))
}
~"visit_tydesc" => {
assert ccx.tcx.intrinsic_defs.contains_key(@~"tydesc");
assert ccx.tcx.intrinsic_defs.contains_key(@~"ty_visitor");
let (_, tydesc_ty) = ccx.tcx.intrinsic_defs.get(@~"tydesc");
let (_, visitor_trait) = ccx.tcx.intrinsic_defs.get(@~"ty_visitor");
let tydesc_name = syntax::parse::token::special_idents::tydesc;
let ty_visitor_name = tcx.sess.ident_of(~"ty_visitor");
assert tcx.intrinsic_defs.contains_key(tydesc_name);
assert ccx.tcx.intrinsic_defs.contains_key(ty_visitor_name);
let (_, tydesc_ty) = tcx.intrinsic_defs.get(tydesc_name);
let (_, visitor_trait) = tcx.intrinsic_defs.get(ty_visitor_name);
let td_ptr = ty::mk_ptr(ccx.tcx, {ty: tydesc_ty,
mutbl: ast::m_imm});
(0u, ~[arg(ast::by_val, td_ptr),

19
src/rustc/middle/typeck/check/alt.rs
View file

@ -215,11 +215,9 @@ fn check_pat(pcx: pat_ctxt, pat: @ast::pat, expected: ty::t) {
fields",
ex_f_count, f_count});
}
fn matches(name: ast::ident, f: ty::field) -> bool {
str::eq(name, f.ident)
}
for fields.each |f| {
match vec::find(ex_fields, |a| matches(f.ident, a)) {
match vec::find(ex_fields, |a| f.ident == a.ident) {
some(field) => {
check_pat(pcx, f.pat, field.mt.ty);
}
@ -227,7 +225,7 @@ fn check_pat(pcx: pat_ctxt, pat: @ast::pat, expected: ty::t) {
tcx.sess.span_fatal(pat.span,
fmt!{"mismatched types: did not \
expect a record with a field `%s`",
*f.ident});
tcx.sess.str_of(f.ident)});
}
}
}
@ -259,7 +257,7 @@ fn check_pat(pcx: pat_ctxt, pat: @ast::pat, expected: ty::t) {
// OK.
}
ast::def_class(*) => {
let name = syntax::print::pprust::path_to_str(path);
let name = pprust::path_to_str(path, tcx.sess.intr());
tcx.sess.span_err(pat.span,
fmt!("mismatched types: expected `%s` but \
found `%s`",
@ -278,7 +276,7 @@ fn check_pat(pcx: pat_ctxt, pat: @ast::pat, expected: ty::t) {
}
// Index the class fields.
let field_map = std::map::box_str_hash();
let field_map = std::map::uint_hash();
for class_fields.eachi |i, class_field| {
field_map.insert(class_field.ident, i);
}
@ -297,10 +295,11 @@ fn check_pat(pcx: pat_ctxt, pat: @ast::pat, expected: ty::t) {
found_fields.insert(index, ());
}
none => {
let name = syntax::print::pprust::path_to_str(path);
let name = pprust::path_to_str(path, tcx.sess.intr());
tcx.sess.span_err(pat.span,
fmt!("struct `%s` does not have a field
named `%s`", name, *field.ident));
named `%s`", name,
tcx.sess.str_of(field.ident)));
}
}
}
@ -313,7 +312,7 @@ fn check_pat(pcx: pat_ctxt, pat: @ast::pat, expected: ty::t) {
}
tcx.sess.span_err(pat.span,
fmt!("pattern does not mention field `%s`",
*field.ident));
tcx.sess.str_of(field.ident)));
}
}

13
src/rustc/middle/typeck/check/method.rs
View file

@ -107,7 +107,8 @@ struct lookup {
// Entrypoint:
fn method() -> option<method_map_entry> {
debug!{"method lookup(m_name=%s, self_ty=%s, %?)",
*self.m_name, self.fcx.infcx.ty_to_str(self.self_ty),
self.fcx.tcx().sess.str_of(self.m_name),
self.fcx.infcx.ty_to_str(self.self_ty),
ty::get(self.self_ty).struct};
// Determine if there are any inherent methods we can call.
@ -533,7 +534,9 @@ struct lookup {
debug!{"(adding inherent and extension candidates) \
adding candidates from impl: %s",
node_id_to_str(self.tcx().items,
implementation.did.node)};
implementation.did.node,
self.fcx.tcx().sess.parse_sess
.interner)};
self.add_candidates_from_impl(implementation, mode);
}
}
@ -572,9 +575,11 @@ struct lookup {
fn def_id_to_str(def_id: ast::def_id) -> ~str {
if def_id.crate == ast::local_crate {
node_id_to_str(self.tcx().items, def_id.node)
node_id_to_str(self.tcx().items, def_id.node,
self.fcx.tcx().sess.parse_sess.interner)
} else {
ast_map::path_to_str(csearch::get_item_path(self.tcx(), def_id))
ast_map::path_to_str(csearch::get_item_path(self.tcx(), def_id),
self.fcx.tcx().sess.parse_sess.interner)
}
}

3
src/rustc/middle/typeck/check/regionck.rs
View file

@ -156,7 +156,8 @@ fn visit_block(b: ast::blk, &&rcx: @rcx, v: rvt) {
}
fn visit_expr(e: @ast::expr, &&rcx: @rcx, v: rvt) {
debug!{"visit_expr(e=%s)", pprust::expr_to_str(e)};
debug!{"visit_expr(e=%s)",
pprust::expr_to_str(e, rcx.fcx.tcx().sess.intr())};
match e.node {
ast::expr_path(*) => {

2
src/rustc/middle/typeck/check/vtable.rs
View file

@ -287,7 +287,7 @@ fn connect_trait_tps(fcx: @fn_ctxt, expr: @ast::expr, impl_tys: ~[ty::t],
fn early_resolve_expr(ex: @ast::expr, &&fcx: @fn_ctxt, is_early: bool) {
debug!("vtable: early_resolve_expr() ex with id %?: %s",
ex.id, expr_to_str(ex));
ex.id, expr_to_str(ex, fcx.tcx().sess.intr()));
let cx = fcx.ccx;
match ex.node {
ast::expr_path(*) => {

4
src/rustc/middle/typeck/check/writeback.rs
View file

@ -117,7 +117,7 @@ fn visit_pat(p: @ast::pat, wbcx: wb_ctxt, v: wb_vt) {
if !wbcx.success { return; }
resolve_type_vars_for_node(wbcx, p.span, p.id);
debug!{"Type for pattern binding %s (id %d) resolved to %s",
pat_to_str(p), p.id,
pat_to_str(p, wbcx.fcx.ccx.tcx.sess.intr()), p.id,
wbcx.fcx.infcx.ty_to_str(
ty::node_id_to_type(wbcx.fcx.ccx.tcx,
p.id))};
@ -130,7 +130,7 @@ fn visit_local(l: @ast::local, wbcx: wb_ctxt, v: wb_vt) {
match resolve_type(wbcx.fcx.infcx, var_ty, resolve_all | force_all) {
result::ok(lty) => {
debug!{"Type for local %s (id %d) resolved to %s",
pat_to_str(l.node.pat), l.node.id,
pat_to_str(l.node.pat, wbcx.fcx.ccx.tcx.sess.intr()),l.node.id,
wbcx.fcx.infcx.ty_to_str(lty)};
write_ty_to_tcx(wbcx.fcx.ccx.tcx, l.node.id, lty);
}

41
src/rustc/middle/typeck/coherence.rs
View file

@ -164,6 +164,7 @@ struct CoherenceChecker {
// Create a mapping containing a MethodInfo for every provided
// method in every trait.
fn build_provided_methods_map(crate: @crate) {
let sess = self.crate_context.tcx.sess;
let pmm = self.crate_context.provided_methods_map;
@ -173,7 +174,8 @@ struct CoherenceChecker {
item_trait(_, _, trait_methods) => {
for trait_methods.each |trait_method| {
debug!{"(building provided methods map) checking \
trait `%s` with id %d", *item.ident, item.id};
trait `%s` with id %d",
sess.str_of(item.ident), item.id};
match trait_method {
required(_) => { /* fall through */}
@ -193,7 +195,7 @@ struct CoherenceChecker {
methods map) adding \
method `%s` to entry for \
existing trait",
*mi.ident};
sess.str_of(mi.ident)};
let mut method_infos = mis;
push(method_infos, mi);
pmm.insert(item.id, method_infos);
@ -204,7 +206,7 @@ struct CoherenceChecker {
debug!{"(building provided \
methods map) creating new \
entry for method `%s`",
*mi.ident};
sess.str_of(mi.ident)};
pmm.insert(item.id, ~[mi]);
}
}
@ -227,7 +229,8 @@ struct CoherenceChecker {
// inherent methods and extension methods.
visit_crate(*crate, (), mk_simple_visitor(@{
visit_item: |item| {
debug!{"(checking coherence) item '%s'", *item.ident};
debug!{"(checking coherence) item '%s'",
self.crate_context.tcx.sess.str_of(item.ident)};
match item.node {
item_impl(_, associated_traits, _, _) => {
@ -269,7 +272,7 @@ struct CoherenceChecker {
if associated_traits.len() == 0 {
debug!{"(checking implementation) no associated traits for item \
'%s'",
*item.ident};
self.crate_context.tcx.sess.str_of(item.ident)};
match get_base_type_def_id(self.inference_context,
item.span,
@ -292,9 +295,10 @@ struct CoherenceChecker {
self.trait_ref_to_trait_def_id(associated_trait);
debug!{"(checking implementation) adding impl for trait \
'%s', item '%s'",
ast_map::node_id_to_str(self.crate_context.tcx.items,
trait_did.node),
*item.ident};
ast_map::node_id_to_str(
self.crate_context.tcx.items, trait_did.node,
self.crate_context.tcx.sess.parse_sess.interner),
self.crate_context.tcx.sess.str_of(item.ident)};
let implementation = self.create_impl_from_item(item);
self.add_trait_method(trait_did, implementation);
@ -567,7 +571,8 @@ struct CoherenceChecker {
fn create_impl_from_item(item: @item) -> @Impl {
fn add_provided_methods(inherent_methods: ~[@MethodInfo],
all_provided_methods: ~[@MethodInfo])
all_provided_methods: ~[@MethodInfo],
sess: driver::session::session)
-> ~[@MethodInfo] {
let mut methods = inherent_methods;
@ -583,8 +588,9 @@ struct CoherenceChecker {
}
if !method_inherent_to_impl {
debug!{"(creating impl) adding provided method `%s` to \
impl", *provided_method.ident};
debug!{
"(creating impl) adding provided method `%s` to impl",
sess.str_of(provided_method.ident)};
push(methods, provided_method);
}
}
@ -625,8 +631,9 @@ struct CoherenceChecker {
// trait.
// XXX: could probably be doing this with filter.
methods = add_provided_methods(methods,
all_provided);
methods = add_provided_methods(
methods, all_provided,
self.crate_context.tcx.sess);
}
}
}
@ -717,11 +724,11 @@ struct CoherenceChecker {
self_type.ty) {
none => {
let session = self.crate_context.tcx.sess;
session.bug(fmt!{"no base type for external impl \
session.bug(fmt!{
"no base type for external impl \
with no trait: %s (type %s)!",
*implementation.ident,
ty_to_str(self.crate_context.tcx,
self_type.ty)});
session.str_of(implementation.ident),
ty_to_str(self.crate_context.tcx,self_type.ty)});
}
some(_) => {
// Nothing to do.

23
src/rustc/middle/typeck/collect.rs
View file

@ -30,7 +30,9 @@ fn collect_item_types(ccx: @crate_ctxt, crate: @ast::crate) {
// There ought to be a better approach. Attributes?
for crate.node.module.items.each |crate_item| {
if *crate_item.ident == ~"intrinsic" {
if crate_item.ident
== syntax::parse::token::special_idents::intrinsic {
match crate_item.node {
ast::item_mod(m) => {
for m.items.each |intrinsic_item| {
@ -246,7 +248,7 @@ fn compare_impl_method(tcx: ty::ctxt, sp: span,
tcx.sess.span_err(
sp, fmt!{"method `%s`'s purity does \
not match the trait method's \
purity", *impl_m.ident});
purity", tcx.sess.str_of(impl_m.ident)});
}
// is this check right?
@ -254,11 +256,11 @@ fn compare_impl_method(tcx: ty::ctxt, sp: span,
tcx.sess.span_err(
sp, fmt!{"method `%s`'s self type does \
not match the trait method's \
self type", *impl_m.ident});
self type", tcx.sess.str_of(impl_m.ident)});
}
if impl_m.tps != trait_m.tps {
tcx.sess.span_err(sp, ~"method `" + *trait_m.ident +
tcx.sess.span_err(sp, ~"method `" + tcx.sess.str_of(trait_m.ident) +
~"` has an incompatible set of type parameters");
return;
}
@ -266,7 +268,7 @@ fn compare_impl_method(tcx: ty::ctxt, sp: span,
if vec::len(impl_m.fty.inputs) != vec::len(trait_m.fty.inputs) {
tcx.sess.span_err(sp,fmt!{"method `%s` has %u parameters \
but the trait has %u",
*trait_m.ident,
tcx.sess.str_of(trait_m.ident),
vec::len(impl_m.fty.inputs),
vec::len(trait_m.fty.inputs)});
return;
@ -299,7 +301,8 @@ fn compare_impl_method(tcx: ty::ctxt, sp: span,
};
require_same_types(
tcx, none, false, sp, impl_fty, trait_fty,
|| ~"method `" + *trait_m.ident + ~"` has an incompatible type");
|| ~"method `" + tcx.sess.str_of(trait_m.ident)
+ ~"` has an incompatible type");
return;
// Replaces bound references to the self region with `with_r`.
@ -351,7 +354,8 @@ fn check_methods_against_trait(ccx: @crate_ctxt,
none => {
tcx.sess.span_err(
a_trait_ty.path.span,
fmt!{"missing method `%s`", *trait_m.ident});
fmt!{"missing method `%s`",
tcx.sess.str_of(trait_m.ident)});
}
}
}
@ -402,7 +406,8 @@ fn convert_methods(ccx: @crate_ctxt,
fn convert(ccx: @crate_ctxt, it: @ast::item) {
let tcx = ccx.tcx;
let rp = tcx.region_paramd_items.contains_key(it.id);
debug!{"convert: item %s with id %d rp %b", *it.ident, it.id, rp};
debug!{"convert: item %s with id %d rp %b", tcx.sess.str_of(it.ident),
it.id, rp};
match it.node {
// These don't define types.
ast::item_foreign_mod(_) | ast::item_mod(_) => {}
@ -607,7 +612,7 @@ fn ty_of_item(ccx: @crate_ctxt, it: @ast::item)
rp: false, // functions do not have a self
ty: ty::mk_fn(ccx.tcx, tofd)};
debug!{"type of %s (id %d) is %s",
*it.ident, it.id, ty_to_str(tcx, tpt.ty)};
tcx.sess.str_of(it.ident), it.id, ty_to_str(tcx, tpt.ty)};
ccx.tcx.tcache.insert(local_def(it.id), tpt);
return tpt;
}

5
src/rustc/middle/typeck/rscope.rs
View file

@ -1,4 +1,5 @@
import result::result;
import syntax::parse::token::special_idents;
trait region_scope {
fn anon_region(span: span) -> result<ty::region, ~str>;
@ -11,7 +12,7 @@ impl empty_rscope: region_scope {
result::ok(ty::re_static)
}
fn named_region(_span: span, id: ast::ident) -> result<ty::region, ~str> {
if *id == ~"static" { result::ok(ty::re_static) }
if id == special_idents::static { result::ok(ty::re_static) }
else { result::err(~"only the static region is allowed here") }
}
}
@ -28,7 +29,7 @@ impl type_rscope: region_scope {
}
fn named_region(span: span, id: ast::ident) -> result<ty::region, ~str> {
do empty_rscope.named_region(span, id).chain_err |_e| {
if *id == ~"self" {
if id == special_idents::self_ {
self.anon_region(span)
} else {
result::err(~"named regions other than `self` are not \

4
src/rustc/util/common.rs
View file

@ -84,7 +84,9 @@ fn local_rhs_span(l: @ast::local, def: span) -> span {
fn is_main_name(path: syntax::ast_map::path) -> bool {
// FIXME (#34): path should be a constrained type, so we know
// the call to last doesn't fail.
vec::last(path) == syntax::ast_map::path_name(@~"main")
vec::last(path) == syntax::ast_map::path_name(
syntax::parse::token::special_idents::main
)
}
//

15
src/rustc/util/ppaux.rs
View file

@ -106,7 +106,7 @@ fn explain_region_and_span(cx: ctxt, region: ty::region)
fn bound_region_to_str(cx: ctxt, br: bound_region) -> ~str {
match br {
br_named(str) => fmt!{"&%s", *str},
br_named(id) => fmt!("&%s", cx.sess.str_of(id)),
br_self if cx.sess.ppregions() => ~"&<self>",
br_self => ~"&self",
@ -161,7 +161,8 @@ fn re_scope_id_to_str(cx: ctxt, node_id: ast::node_id) -> ~str {
}
_ => { cx.sess.bug(
fmt!{"re_scope refers to %s",
ast_map::node_id_to_str(cx.items, node_id)}) }
ast_map::node_id_to_str(cx.items, node_id,
cx.sess.parse_sess.interner)}) }
}
}
@ -257,7 +258,7 @@ fn ty_to_str(cx: ctxt, typ: t) -> ~str {
s += proto_ty_to_str(cx, proto);
match ident {
some(i) => { s += ~" "; s += *i; }
some(i) => { s += ~" "; s += cx.sess.str_of(i); }
_ => { }
}
s += ~"(";
@ -280,13 +281,13 @@ fn ty_to_str(cx: ctxt, typ: t) -> ~str {
m.fty.output, m.fty.ret_style) + ~";";
}
fn field_to_str(cx: ctxt, f: field) -> ~str {
return *f.ident + ~": " + mt_to_str(cx, f.mt);
return cx.sess.str_of(f.ident) + ~": " + mt_to_str(cx, f.mt);
}
// if there is an id, print that instead of the structural type:
for ty::type_def_id(typ).each |def_id| {
// note that this typedef cannot have type parameters
return ast_map::path_to_str(ty::item_path(cx, def_id));
return ast_map::path_to_str(ty::item_path(cx, def_id),cx.sess.intr());
}
// pretty print the structural type representation:
@ -336,12 +337,12 @@ fn ty_to_str(cx: ctxt, typ: t) -> ~str {
ty_self => ~"self",
ty_enum(did, substs) | ty_class(did, substs) => {
let path = ty::item_path(cx, did);
let base = ast_map::path_to_str(path);
let base = ast_map::path_to_str(path, cx.sess.intr());
parameterized(cx, base, substs.self_r, substs.tps)
}
ty_trait(did, substs, vs) => {
let path = ty::item_path(cx, did);
let base = ast_map::path_to_str(path);
let base = ast_map::path_to_str(path, cx.sess.intr());
let result = parameterized(cx, base, substs.self_r, substs.tps);
vstore_ty_to_str(cx, result, vs)
}

5
src/rustdoc/attr_parser.rs
View file

@ -63,8 +63,7 @@ fn parse_crate(attrs: ~[ast::attribute]) -> crate_attrs {
let link_metas = attr::find_linkage_metas(attrs);
{
name: attr::last_meta_item_value_str_by_name(
link_metas, ~"name").map(|x| *x )
name: attr::last_meta_item_value_str_by_name(link_metas, ~"name")
}
}
@ -95,7 +94,7 @@ fn should_not_extract_crate_name_if_no_name_value_in_link_attribute() {
fn parse_desc(attrs: ~[ast::attribute]) -> option<~str> {
match doc_meta(attrs) {
some(meta) => {
attr::get_meta_item_value_str(meta).map(|x| *x )
attr::get_meta_item_value_str(meta)
}
none => none
}

9
src/rustdoc/attr_pass.rs
View file

@ -7,6 +7,7 @@
)];
import doc::item_utils;
import extract::to_str;
import syntax::ast;
import syntax::ast_map;
import std::map::hashmap;
@ -150,7 +151,7 @@ fn fold_enum(
}, _) => {
let ast_variant = option::get(
vec::find(enum_definition.variants, |v| {
*v.node.name == variant.name
to_str(v.node.name) == variant.name
}));
attr_parser::parse_desc(ast_variant.node.attrs)
@ -208,10 +209,10 @@ fn merge_method_attrs(
vec::map(methods, |method| {
match method {
ast::required(ty_m) => {
(*ty_m.ident, attr_parser::parse_desc(ty_m.attrs))
(to_str(ty_m.ident), attr_parser::parse_desc(ty_m.attrs))
}
ast::provided(m) => {
(*m.ident, attr_parser::parse_desc(m.attrs))
(to_str(m.ident), attr_parser::parse_desc(m.attrs))
}
}
})
@ -220,7 +221,7 @@ fn merge_method_attrs(
node: ast::item_impl(_, _, _, methods), _
}, _) => {
vec::map(methods, |method| {
(*method.ident, attr_parser::parse_desc(method.attrs))
(to_str(method.ident), attr_parser::parse_desc(method.attrs))
})
}
_ => fail ~"unexpected item"

35
src/rustdoc/extract.rs
View file

@ -3,7 +3,21 @@
import syntax::ast;
import doc::item_utils;
export from_srv, extract;
export from_srv, extract, to_str, interner;
// Hack; rather than thread an interner through everywhere, rely on
// thread-local data
fn to_str(id: ast::ident) -> ~str {
let intr = unsafe{ task::local_data_get(
syntax::parse::token::interner_key) };
return *(*intr.get()).get(id);
}
fn interner() -> syntax::parse::token::ident_interner {
return *(unsafe{ task::local_data_get(
syntax::parse::token::interner_key) }).get();
}
fn from_srv(
srv: astsrv::srv,
@ -34,14 +48,14 @@ fn top_moddoc_from_crate(
crate: @ast::crate,
default_name: ~str
) -> doc::moddoc {
moddoc_from_mod(mk_itemdoc(ast::crate_node_id, @default_name),
moddoc_from_mod(mk_itemdoc(ast::crate_node_id, default_name),
crate.node.module)
}
fn mk_itemdoc(id: ast::node_id, name: ast::ident) -> doc::itemdoc {
fn mk_itemdoc(id: ast::node_id, name: ~str) -> doc::itemdoc {
{
id: id,
name: *name,
name: name,
path: ~[],
brief: none,
desc: none,
@ -57,7 +71,7 @@ fn moddoc_from_mod(
doc::moddoc_({
item: itemdoc,
items: do vec::filter_map(module_.items) |item| {
let itemdoc = mk_itemdoc(item.id, item.ident);
let itemdoc = mk_itemdoc(item.id, to_str(item.ident));
match item.node {
ast::item_mod(m) => {
some(doc::modtag(
@ -113,7 +127,7 @@ fn nmoddoc_from_mod(
{
item: itemdoc,
fns: do vec::map(module_.items) |item| {
let itemdoc = mk_itemdoc(item.id, item.ident);
let itemdoc = mk_itemdoc(item.id, to_str(item.ident));
match item.node {
ast::foreign_item_fn(_, _) => {
fndoc_from_fn(itemdoc)
@ -162,8 +176,9 @@ fn variantdocs_from_variants(
}
fn variantdoc_from_variant(variant: ast::variant) -> doc::variantdoc {
{
name: *variant.node.name,
name: to_str(variant.node.name),
desc: none,
sig: none
}
@ -192,7 +207,7 @@ fn traitdoc_from_trait(
match method {
ast::required(ty_m) => {
{
name: *ty_m.ident,
name: to_str(ty_m.ident),
brief: none,
desc: none,
sections: ~[],
@ -202,7 +217,7 @@ fn traitdoc_from_trait(
}
ast::provided(m) => {
{
name: *m.ident,
name: to_str(m.ident),
brief: none,
desc: none,
sections: ~[],
@ -237,7 +252,7 @@ fn impldoc_from_impl(
self_ty: none,
methods: do vec::map(methods) |method| {
{
name: *method.ident,
name: to_str(method.ident),
brief: none,
desc: none,
sections: ~[],

35
src/rustdoc/tystr_pass.rs
View file

@ -5,6 +5,7 @@ import syntax::ast;
import syntax::print::pprust;
import syntax::ast_map;
import std::map::hashmap;
import extract::to_str;
export mk_pass;
@ -55,7 +56,7 @@ fn get_fn_sig(srv: astsrv::srv, fn_id: doc::ast_id) -> option<~str> {
ident: ident,
node: ast::foreign_item_fn(decl, tys), _
}, _, _) => {
some(pprust::fun_to_str(decl, ident, tys))
some(pprust::fun_to_str(decl, ident, tys, extract::interner()))
}
}
}
@ -85,7 +86,7 @@ fn fold_const(
ast_map::node_item(@{
node: ast::item_const(ty, _), _
}, _) => {
pprust::ty_to_str(ty)
pprust::ty_to_str(ty, extract::interner())
}
}
})
@ -115,10 +116,10 @@ fn fold_enum(
}, _) => {
let ast_variant = option::get(
do vec::find(enum_definition.variants) |v| {
*v.node.name == variant.name
to_str(v.node.name) == variant.name
});
pprust::variant_to_str(ast_variant)
pprust::variant_to_str(ast_variant, extract::interner())
}
}
};
@ -173,8 +174,8 @@ fn get_method_sig(
}, _) => {
match check vec::find(methods, |method| {
match method {
ast::required(ty_m) => *ty_m.ident == method_name,
ast::provided(m) => *m.ident == method_name,
ast::required(ty_m) => to_str(ty_m.ident) == method_name,
ast::provided(m) => to_str(m.ident) == method_name,
}
}) {
some(method) => {
@ -183,14 +184,16 @@ fn get_method_sig(
some(pprust::fun_to_str(
ty_m.decl,
ty_m.ident,
ty_m.tps
ty_m.tps,
extract::interner()
))
}
ast::provided(m) => {
some(pprust::fun_to_str(
m.decl,
m.ident,
m.tps
m.tps,
extract::interner()
))
}
}
@ -201,13 +204,14 @@ fn get_method_sig(
node: ast::item_impl(_, _, _, methods), _
}, _) => {
match check vec::find(methods, |method| {
*method.ident == method_name
to_str(method.ident) == method_name
}) {
some(method) => {
some(pprust::fun_to_str(
method.decl,
method.ident,
method.tps
method.tps,
extract::interner()
))
}
}
@ -236,9 +240,10 @@ fn fold_impl(
node: ast::item_impl(_, trait_types, self_ty, _), _
}, _) => {
let trait_types = vec::map(trait_types, |p| {
pprust::path_to_str(p.path)
pprust::path_to_str(p.path, extract::interner())
});
(trait_types, some(pprust::ty_to_str(self_ty)))
(trait_types, some(pprust::ty_to_str(self_ty,
extract::interner())))
}
_ => fail ~"expected impl"
}
@ -293,9 +298,9 @@ fn fold_type(
}, _) => {
some(fmt!{
"type %s%s = %s",
*ident,
pprust::typarams_to_str(params),
pprust::ty_to_str(ty)
to_str(ident),
pprust::typarams_to_str(params, extract::interner()),
pprust::ty_to_str(ty, extract::interner())
})
}
_ => fail ~"expected type"

41
src/test/run-pass-fulldeps/qquote.rs
View file

@ -16,15 +16,15 @@ trait fake_ext_ctxt {
fn parse_sess() -> parse::parse_sess;
}
type fake_session = ();
type fake_session = parse::parse_sess;
impl fake_session: fake_ext_ctxt {
fn cfg() -> ast::crate_cfg { ~[] }
fn parse_sess() -> parse::parse_sess { parse::new_parse_sess(none) }
fn parse_sess() -> parse::parse_sess { self }
}
fn mk_ctxt() -> fake_ext_ctxt {
() as fake_ext_ctxt
parse::new_parse_sess(none) as fake_ext_ctxt
}
@ -32,60 +32,61 @@ fn main() {
let ext_cx = mk_ctxt();
let abc = #ast{23};
check_pp(abc, pprust::print_expr, ~"23");
check_pp(ext_cx, abc, pprust::print_expr, ~"23");
let expr3 = #ast{2 - $(abc) + 7};
check_pp(expr3, pprust::print_expr, ~"2 - 23 + 7");
check_pp(ext_cx, expr3, pprust::print_expr, ~"2 - 23 + 7");
let expr4 = #ast{2 - $(#ast{3}) + 9};
check_pp(expr4, pprust::print_expr, ~"2 - 3 + 9");
check_pp(ext_cx, expr4, pprust::print_expr, ~"2 - 3 + 9");
let ty = #ast[ty]{int};
check_pp(ty, pprust::print_type, ~"int");
check_pp(ext_cx, ty, pprust::print_type, ~"int");
let ty2 = #ast[ty]{option<$(ty)>};
check_pp(ty2, pprust::print_type, ~"option<int>");
check_pp(ext_cx, ty2, pprust::print_type, ~"option<int>");
let item = #ast[item]{const x : int = 10;};
check_pp(item, pprust::print_item, ~"const x: int = 10;");
check_pp(ext_cx, item, pprust::print_item, ~"const x: int = 10;");
let item2: @ast::item = #ast[item]{const x : int = $(abc);};
check_pp(item2, pprust::print_item, ~"const x: int = 23;");
check_pp(ext_cx, item2, pprust::print_item, ~"const x: int = 23;");
let stmt = #ast[stmt]{let x = 20;};
check_pp(*stmt, pprust::print_stmt, ~"let x = 20;");
check_pp(ext_cx, *stmt, pprust::print_stmt, ~"let x = 20;");
let stmt2 = #ast[stmt]{let x : $(ty) = $(abc);};
check_pp(*stmt2, pprust::print_stmt, ~"let x: int = 23;");
check_pp(ext_cx, *stmt2, pprust::print_stmt, ~"let x: int = 23;");
let pat = #ast[pat]{some(_)};
check_pp(pat, pprust::print_pat, ~"some(_)");
check_pp(ext_cx, pat, pprust::print_pat, ~"some(_)");
// issue #1785
let x = #ast{1};
let test1 = #ast{1+$(x)};
check_pp(test1, pprust::print_expr, ~"1 + 1");
check_pp(ext_cx, test1, pprust::print_expr, ~"1 + 1");
let test2 = #ast{$(x)+1};
check_pp(test2, pprust::print_expr, ~"1 + 1");
check_pp(ext_cx, test2, pprust::print_expr, ~"1 + 1");
let y = #ast{2};
let test3 = #ast{$(x) + $(y)};
check_pp(test3, pprust::print_expr, ~"1 + 2");
check_pp(ext_cx, test3, pprust::print_expr, ~"1 + 2");
let crate = #ast[crate] { fn a() { } };
check_pp(crate, pprust::print_crate_, ~"fn a() { }\n");
check_pp(ext_cx, crate, pprust::print_crate_, ~"fn a() { }\n");
// issue #1926
let s = #ast[expr]{__s};
let e = #ast[expr]{__e};
let call = #ast[expr]{$(s).foo(|__e| $(e) )};
check_pp(call, pprust::print_expr, ~"__s.foo(|__e| __e)")
check_pp(ext_cx, call, pprust::print_expr, ~"__s.foo(|__e| __e)")
}
fn check_pp<T>(expr: T, f: fn(pprust::ps, T), expect: ~str) {
fn check_pp<T>(cx: fake_ext_ctxt,
expr: T, f: fn(pprust::ps, T), expect: ~str) {
let buf = mem_buffer();
let pp = pprust::rust_printer(buf as io::Writer);
let pp = pprust::rust_printer(buf as io::Writer,cx.parse_sess().interner);
f(pp, expr);
pp::eof(pp.s);
let str = mem_buffer_str(buf);