dnrops
/
rust
mirror of https://github.com/rust-lang/rust.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Change 'iface' to 'trait' internally; parse `trait` as `iface` synonym

This commit is contained in:
Lindsey Kuper 2012-07-03 16:30:42 -07:00
parent d93f3c5d83
commit 33334f3c43
49 changed files with 453 additions and 451 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/libsyntax/ast.rs
View File

@ -62,7 +62,7 @@ enum ty_param_bound {
bound_copy, bound_copy,
bound_send, bound_send,
bound_const, bound_const,
bound_iface(@ty), bound_trait(@ty),
} }
#[auto_serialize] #[auto_serialize]
@ -657,11 +657,11 @@ enum attr_style { attr_outer, attr_inner, }
type attribute_ = {style: attr_style, value: meta_item, is_sugared_doc: bool}; type attribute_ = {style: attr_style, value: meta_item, is_sugared_doc: bool};
/* /*
iface_refs appear in both impls and in classes that implement ifaces. trait_refs appear in both impls and in classes that implement traits.
resolve maps each iface_ref's id to its defining iface. resolve maps each trait_ref's id to its defining trait.
*/ */
#[auto_serialize] #[auto_serialize]
type iface_ref = {path: @path, id: node_id}; type trait_ref = {path: @path, id: node_id};
#[auto_serialize] #[auto_serialize]
enum visibility { public, private } enum visibility { public, private }
@ -686,7 +686,7 @@ enum item_ {
item_ty(@ty, ~[ty_param], region_param), item_ty(@ty, ~[ty_param], region_param),
item_enum(~[variant], ~[ty_param], region_param), item_enum(~[variant], ~[ty_param], region_param),
item_class(~[ty_param], /* ty params for class */ item_class(~[ty_param], /* ty params for class */
~[@iface_ref], /* ifaces this class implements */ ~[@trait_ref], /* traits this class implements */
~[@class_member], /* methods, etc. */ ~[@class_member], /* methods, etc. */
/* (not including ctor or dtor) */ /* (not including ctor or dtor) */
class_ctor, class_ctor,
@ -694,8 +694,8 @@ enum item_ {
option<class_dtor>, option<class_dtor>,
region_param region_param
), ),
item_iface(~[ty_param], region_param, ~[ty_method]), item_trait(~[ty_param], region_param, ~[ty_method]),
item_impl(~[ty_param], region_param, option<@iface_ref> /* iface */, item_impl(~[ty_param], region_param, option<@trait_ref> /* trait */,
@ty /* self */, ~[@method]), @ty /* self */, ~[@method]),
} }

6
src/libsyntax/ast_map.rs
View File

@ -214,11 +214,11 @@ fn map_item(i: @item, cx: ctx, v: vt) {
extend(cx, i.ident))); extend(cx, i.ident)));
} }
} }
item_class(tps, ifces, items, ctor, dtor, _) { item_class(tps, traits, items, ctor, dtor, _) {
let (_, ms) = ast_util::split_class_items(items); let (_, ms) = ast_util::split_class_items(items);
// Map iface refs to their parent classes. This is // Map trait refs to their parent classes. This is
// so we can find the self_ty // so we can find the self_ty
do vec::iter(ifces) |p| { cx.map.insert(p.id, do vec::iter(traits) |p| { cx.map.insert(p.id,
node_item(i, item_path)); }; node_item(i, item_path)); };
let d_id = ast_util::local_def(i.id); let d_id = ast_util::local_def(i.id);
let p = extend(cx, i.ident); let p = extend(cx, i.ident);

4
src/libsyntax/ext/auto_serialize.rs
View File

@ -530,7 +530,7 @@ fn mk_ser_fn(cx: ext_ctxt, span: span, name: ast::ident,
} }
let ser_bnds = @~[ let ser_bnds = @~[
ast::bound_iface(cx.ty_path(span, ast::bound_trait(cx.ty_path(span,
~[@"std", @"serialization", ~[@"std", @"serialization",
@"serializer"], @"serializer"],
~[]))]; ~[]))];
@ -736,7 +736,7 @@ fn mk_deser_fn(cx: ext_ctxt, span: span,
} }
let deser_bnds = @~[ let deser_bnds = @~[
ast::bound_iface(cx.ty_path( ast::bound_trait(cx.ty_path(
span, span,
~[@"std", @"serialization", @"deserializer"], ~[@"std", @"serialization", @"deserializer"],
~[]))]; ~[]))];

14
src/libsyntax/fold.rs
View File

@ -142,7 +142,7 @@ fn fold_fn_decl(decl: ast::fn_decl, fld: ast_fold) -> ast::fn_decl {
fn fold_ty_param_bound(tpb: ty_param_bound, fld: ast_fold) -> ty_param_bound { fn fold_ty_param_bound(tpb: ty_param_bound, fld: ast_fold) -> ty_param_bound {
alt tpb { alt tpb {
bound_copy | bound_send | bound_const { tpb } bound_copy | bound_send | bound_const { tpb }
bound_iface(ty) { bound_iface(fld.fold_ty(ty)) } bound_trait(ty) { bound_trait(fld.fold_ty(ty)) }
} }
} }
@ -252,7 +252,7 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
fold_ty_params(typms, fld), fold_ty_params(typms, fld),
r) r)
} }
item_class(typms, ifaces, items, ctor, m_dtor, rp) { item_class(typms, traits, items, ctor, m_dtor, rp) {
let ctor_body = fld.fold_block(ctor.node.body); let ctor_body = fld.fold_block(ctor.node.body);
let ctor_decl = fold_fn_decl(ctor.node.dec, fld); let ctor_decl = fold_fn_decl(ctor.node.dec, fld);
let ctor_id = fld.new_id(ctor.node.id); let ctor_id = fld.new_id(ctor.node.id);
@ -264,7 +264,7 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
with dtor}}; with dtor}};
item_class( item_class(
/* FIXME (#2543) */ copy typms, /* FIXME (#2543) */ copy typms,
vec::map(ifaces, |p| fold_iface_ref(p, fld)), vec::map(traits, |p| fold_trait_ref(p, fld)),
vec::map(items, fld.fold_class_item), vec::map(items, fld.fold_class_item),
{node: {body: ctor_body, {node: {body: ctor_body,
dec: ctor_decl, dec: ctor_decl,
@ -274,19 +274,19 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
item_impl(tps, rp, ifce, ty, methods) { item_impl(tps, rp, ifce, ty, methods) {
item_impl(fold_ty_params(tps, fld), item_impl(fold_ty_params(tps, fld),
rp, rp,
ifce.map(|p| fold_iface_ref(p, fld)), ifce.map(|p| fold_trait_ref(p, fld)),
fld.fold_ty(ty), fld.fold_ty(ty),
vec::map(methods, fld.fold_method)) vec::map(methods, fld.fold_method))
} }
item_iface(tps, rp, methods) { item_trait(tps, rp, methods) {
item_iface(fold_ty_params(tps, fld), item_trait(fold_ty_params(tps, fld),
rp, rp,
/* FIXME (#2543) */ copy methods) /* FIXME (#2543) */ copy methods)
} }
}; };
} }
fn fold_iface_ref(&&p: @iface_ref, fld: ast_fold) -> @iface_ref { fn fold_trait_ref(&&p: @trait_ref, fld: ast_fold) -> @trait_ref {
@{path: fld.fold_path(p.path), id: fld.new_id(p.id)} @{path: fld.fold_path(p.path), id: fld.new_id(p.id)}
} }

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

@ -1892,7 +1892,7 @@ class parser {
else if self.eat_keyword("const") { else if self.eat_keyword("const") {
push(bounds, bound_const) push(bounds, bound_const)
} }
else { push(bounds, bound_iface(self.parse_ty(false))); } else { push(bounds, bound_trait(self.parse_ty(false))); }
} }
} }
ret {ident: ident, id: self.get_id(), bounds: @bounds}; ret {ident: ident, id: self.get_id(), bounds: @bounds};
@ -2008,12 +2008,12 @@ class parser {
self_id: self.get_id(), vis: pr} self_id: self.get_id(), vis: pr}
} }
fn parse_item_iface() -> item_info { fn parse_item_trait() -> item_info {
let ident = self.parse_ident(); let ident = self.parse_ident();
let rp = self.parse_region_param(); let rp = self.parse_region_param();
let tps = self.parse_ty_params(); let tps = self.parse_ty_params();
let meths = self.parse_ty_methods(); let meths = self.parse_ty_methods();
(ident, item_iface(tps, rp, meths), none) (ident, item_trait(tps, rp, meths), none)
} }
// Parses three variants (with the region/type params always optional): // Parses three variants (with the region/type params always optional):
@ -2082,15 +2082,15 @@ class parser {
} }
} }
fn parse_iface_ref() -> @iface_ref { fn parse_trait_ref() -> @trait_ref {
@{path: self.parse_path_with_tps(false), @{path: self.parse_path_with_tps(false),
id: self.get_id()} id: self.get_id()}
} }
fn parse_iface_ref_list() -> ~[@iface_ref] { fn parse_trait_ref_list() -> ~[@trait_ref] {
self.parse_seq_to_before_end( self.parse_seq_to_before_end(
token::LBRACE, seq_sep_trailing_disallowed(token::COMMA), token::LBRACE, seq_sep_trailing_disallowed(token::COMMA),
|p| p.parse_iface_ref()) |p| p.parse_trait_ref())
} }
fn parse_item_class() -> item_info { fn parse_item_class() -> item_info {
@ -2098,8 +2098,8 @@ class parser {
let rp = self.parse_region_param(); let rp = self.parse_region_param();
let ty_params = self.parse_ty_params(); let ty_params = self.parse_ty_params();
let class_path = self.ident_to_path_tys(class_name, rp, ty_params); let class_path = self.ident_to_path_tys(class_name, rp, ty_params);
let ifaces : ~[@iface_ref] = if self.eat(token::COLON) let traits : ~[@trait_ref] = if self.eat(token::COLON)
{ self.parse_iface_ref_list() } { self.parse_trait_ref_list() }
else { ~[] }; else { ~[] };
self.expect(token::LBRACE); self.expect(token::LBRACE);
let mut ms: ~[@class_member] = ~[]; let mut ms: ~[@class_member] = ~[];
@ -2127,7 +2127,7 @@ class parser {
alt the_ctor { alt the_ctor {
some((ct_d, ct_b, ct_s)) { some((ct_d, ct_b, ct_s)) {
(class_name, (class_name,
item_class(ty_params, ifaces, ms, { item_class(ty_params, traits, ms, {
node: {id: ctor_id, node: {id: ctor_id,
self_id: self.get_id(), self_id: self.get_id(),
dec: ct_d, dec: ct_d,
@ -2462,7 +2462,9 @@ class parser {
} else if self.eat_keyword("enum") { } else if self.eat_keyword("enum") {
self.parse_item_enum(vis) self.parse_item_enum(vis)
} else if self.eat_keyword("iface") { } else if self.eat_keyword("iface") {
self.parse_item_iface() self.parse_item_trait()
} else if self.eat_keyword("trait") {
self.parse_item_trait()
} else if self.eat_keyword("impl") { } else if self.eat_keyword("impl") {
self.parse_item_impl() self.parse_item_impl()
} else if self.eat_keyword("class") { } else if self.eat_keyword("class") {

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

@ -494,14 +494,14 @@ fn print_item(s: ps, &&item: @ast::item) {
bclose(s, item.span); bclose(s, item.span);
} }
} }
ast::item_class(tps, ifaces, items, ctor, m_dtor, rp) { ast::item_class(tps, traits, items, ctor, m_dtor, rp) {
head(s, "class"); head(s, "class");
word_nbsp(s, *item.ident); word_nbsp(s, *item.ident);
print_region_param(s, rp); print_region_param(s, rp);
print_type_params(s, tps); print_type_params(s, tps);
if vec::len(ifaces) != 0u { if vec::len(traits) != 0u {
word_space(s, ":"); word_space(s, ":");
commasep(s, inconsistent, ifaces, |s, p| commasep(s, inconsistent, traits, |s, p|
print_path(s, p.path, false)); print_path(s, p.path, false));
} }
bopen(s); bopen(s);
@ -579,7 +579,7 @@ fn print_item(s: ps, &&item: @ast::item) {
} }
bclose(s, item.span); bclose(s, item.span);
} }
ast::item_iface(tps, rp, methods) { ast::item_trait(tps, rp, methods) {
head(s, "iface"); head(s, "iface");
word(s.s, *item.ident); word(s.s, *item.ident);
print_region_param(s, rp); print_region_param(s, rp);
@ -1350,7 +1350,7 @@ fn print_bounds(s: ps, bounds: @~[ast::ty_param_bound]) {
ast::bound_copy { word(s.s, "copy"); } ast::bound_copy { word(s.s, "copy"); }
ast::bound_send { word(s.s, "send"); } ast::bound_send { word(s.s, "send"); }
ast::bound_const { word(s.s, "const"); } ast::bound_const { word(s.s, "const"); }
ast::bound_iface(t) { print_type(s, t); } ast::bound_trait(t) { print_type(s, t); }
} }
} }
} }

8
src/libsyntax/visit.rs
View File

@ -143,19 +143,19 @@ fn visit_item<E>(i: @item, e: E, v: vt<E>) {
visit_method_helper(m, e, v) visit_method_helper(m, e, v)
} }
} }
item_class(tps, ifaces, members, ctor, m_dtor, _) { item_class(tps, traits, members, ctor, m_dtor, _) {
v.visit_ty_params(tps, e, v); v.visit_ty_params(tps, e, v);
for members.each |m| { for members.each |m| {
v.visit_class_item(m, e, v); v.visit_class_item(m, e, v);
} }
for ifaces.each |p| { visit_path(p.path, e, v); } for traits.each |p| { visit_path(p.path, e, v); }
visit_class_ctor_helper(ctor, i.ident, tps, visit_class_ctor_helper(ctor, i.ident, tps,
ast_util::local_def(i.id), e, v); ast_util::local_def(i.id), e, v);
do option::iter(m_dtor) |dtor| { do option::iter(m_dtor) |dtor| {
visit_class_dtor_helper(dtor, tps, visit_class_dtor_helper(dtor, tps,
ast_util::local_def(i.id), e, v)}; ast_util::local_def(i.id), e, v)};
} }
item_iface(tps, _rp, methods) { item_trait(tps, _rp, methods) {
v.visit_ty_params(tps, e, v); v.visit_ty_params(tps, e, v);
for methods.each |m| { for methods.each |m| {
for m.decl.inputs.each |a| { v.visit_ty(a.ty, e, v); } for m.decl.inputs.each |a| { v.visit_ty(a.ty, e, v); }
@ -260,7 +260,7 @@ fn visit_ty_params<E>(tps: ~[ty_param], e: E, v: vt<E>) {
for tps.each |tp| { for tps.each |tp| {
for vec::each(*tp.bounds) |bound| { for vec::each(*tp.bounds) |bound| {
alt bound { alt bound {
bound_iface(t) { v.visit_ty(t, e, v); } bound_trait(t) { v.visit_ty(t, e, v); }
bound_copy | bound_send | bound_const { } bound_copy | bound_send | bound_const { }
} }
} }

2
src/rustc/front/intrinsic.rs
View File

@ -106,7 +106,7 @@ mod intrinsic {
fn visit_leave_fn(purity: uint, proto: uint, fn visit_leave_fn(purity: uint, proto: uint,
n_inputs: uint, retstyle: uint) -> bool; n_inputs: uint, retstyle: uint) -> bool;
fn visit_iface() -> bool; fn visit_trait() -> bool;
fn visit_enter_res() -> bool; fn visit_enter_res() -> bool;
fn visit_leave_res() -> bool; fn visit_leave_res() -> bool;
fn visit_var() -> bool; fn visit_var() -> bool;

10
src/rustc/metadata/astencode.rs
View File

@ -380,8 +380,8 @@ impl of tr for method_origin {
typeck::method_param(did, m, p, b) { typeck::method_param(did, m, p, b) {
typeck::method_param(did.tr(xcx), m, p, b) typeck::method_param(did.tr(xcx), m, p, b)
} }
typeck::method_iface(did, m) { typeck::method_trait(did, m) {
typeck::method_iface(did.tr(xcx), m) typeck::method_trait(did.tr(xcx), m)
} }
} }
} }
@ -441,8 +441,8 @@ fn encode_vtable_origin(ecx: @e::encode_ctxt,
} }
} }
} }
typeck::vtable_iface(def_id, tys) { typeck::vtable_trait(def_id, tys) {
ebml_w.emit_enum_variant("vtable_iface", 1u, 3u) {|| ebml_w.emit_enum_variant("vtable_trait", 1u, 3u) {||
ebml_w.emit_enum_variant_arg(0u) {|| ebml_w.emit_enum_variant_arg(0u) {||
ebml_w.emit_def_id(def_id) ebml_w.emit_def_id(def_id)
} }
@ -490,7 +490,7 @@ impl helpers for ebml::ebml_deserializer {
) )
} }
2u { 2u {
typeck::vtable_iface( typeck::vtable_trait(
self.read_enum_variant_arg(0u) {|| self.read_enum_variant_arg(0u) {||
self.read_def_id(xcx) self.read_def_id(xcx)
}, },

12
src/rustc/metadata/common.rs
View File

@ -70,8 +70,8 @@ const tag_crate_dep_vers: uint = 0x2cu;
const tag_mod_impl: uint = 0x30u; const tag_mod_impl: uint = 0x30u;
const tag_item_iface_method: uint = 0x31u; const tag_item_trait_method: uint = 0x31u;
const tag_impl_iface: uint = 0x32u; const tag_impl_trait: uint = 0x32u;
// discriminator value for variants // discriminator value for variants
const tag_disr_val: uint = 0x34u; const tag_disr_val: uint = 0x34u;
@ -85,13 +85,13 @@ const tag_item_field: uint = 0x44u;
const tag_class_mut: uint = 0x45u; const tag_class_mut: uint = 0x45u;
const tag_region_param: uint = 0x46u; const tag_region_param: uint = 0x46u;
const tag_mod_impl_iface: uint = 0x47u; const tag_mod_impl_trait: uint = 0x47u;
/* /*
iface items contain tag_item_iface_method elements, trait items contain tag_item_trait_method elements,
impl items contain tag_item_impl_method elements, and classes impl items contain tag_item_impl_method elements, and classes
have both. That's because some code treats classes like ifaces, have both. That's because some code treats classes like traits,
and other code treats them like impls. Because classes can contain and other code treats them like impls. Because classes can contain
both, tag_item_iface_method and tag_item_impl_method have to be two both, tag_item_trait_method and tag_item_impl_method have to be two
different tags. different tags.
*/ */
const tag_item_impl_method: uint = 0x48u; const tag_item_impl_method: uint = 0x48u;

20
src/rustc/metadata/csearch.rs
View File

@ -21,10 +21,10 @@ export lookup_defs;
export lookup_method_purity; export lookup_method_purity;
export get_enum_variants; export get_enum_variants;
export get_impls_for_mod; export get_impls_for_mod;
export get_iface_methods; export get_trait_methods;
export each_path; export each_path;
export get_type; export get_type;
export get_impl_iface; export get_impl_trait;
export get_impl_method; export get_impl_method;
export get_item_path; export get_item_path;
export maybe_get_item_ast, found_ast, found, found_parent, not_found; export maybe_get_item_ast, found_ast, found, found_parent, not_found;
@ -133,10 +133,10 @@ fn get_impls_for_mod(cstore: cstore::cstore, def: ast::def_id,
} }
} }
fn get_iface_methods(tcx: ty::ctxt, def: ast::def_id) -> @~[ty::method] { fn get_trait_methods(tcx: ty::ctxt, def: ast::def_id) -> @~[ty::method] {
let cstore = tcx.cstore; let cstore = tcx.cstore;
let cdata = cstore::get_crate_data(cstore, def.crate); let cdata = cstore::get_crate_data(cstore, def.crate);
decoder::get_iface_methods(cdata, def.node, tcx) decoder::get_trait_methods(cdata, def.node, tcx)
} }
fn get_class_fields(tcx: ty::ctxt, def: ast::def_id) -> ~[ty::field_ty] { fn get_class_fields(tcx: ty::ctxt, def: ast::def_id) -> ~[ty::field_ty] {
@ -171,12 +171,12 @@ fn get_field_type(tcx: ty::ctxt, class_id: ast::def_id,
ret {bounds: @~[], rp: ast::rp_none, ty: ty}; ret {bounds: @~[], rp: ast::rp_none, ty: ty};
} }
// Given a def_id for an impl or class, return the iface it implements, // Given a def_id for an impl or class, return the trait it implements,
// or none if it's not for an impl or for a class that implements ifaces // or none if it's not for an impl or for a class that implements traits
fn get_impl_iface(tcx: ty::ctxt, def: ast::def_id) -> option<ty::t> { fn get_impl_trait(tcx: ty::ctxt, def: ast::def_id) -> option<ty::t> {
let cstore = tcx.cstore; let cstore = tcx.cstore;
let cdata = cstore::get_crate_data(cstore, def.crate); let cdata = cstore::get_crate_data(cstore, def.crate);
decoder::get_impl_iface(cdata, def.node, tcx) decoder::get_impl_trait(cdata, def.node, tcx)
} }
fn get_impl_method(cstore: cstore::cstore, fn get_impl_method(cstore: cstore::cstore,
@ -186,8 +186,8 @@ fn get_impl_method(cstore: cstore::cstore,
decoder::get_impl_method(cdata, def.node, mname) decoder::get_impl_method(cdata, def.node, mname)
} }
/* Because classes use the iface format rather than the impl format /* Because classes use the trait format rather than the impl format
for their methods (so that get_iface_methods can be reused to get for their methods (so that get_trait_methods can be reused to get
class methods), classes require a slightly different version of class methods), classes require a slightly different version of
get_impl_method. Sigh. */ get_impl_method. Sigh. */
fn get_class_method(cstore: cstore::cstore, fn get_class_method(cstore: cstore::cstore,

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

@ -22,7 +22,7 @@ export get_symbol;
export get_enum_variants; export get_enum_variants;
export get_type; export get_type;
export get_type_param_count; export get_type_param_count;
export get_impl_iface; export get_impl_trait;
export get_class_method; export get_class_method;
export get_impl_method; export get_impl_method;
export lookup_def; export lookup_def;
@ -35,7 +35,7 @@ export get_crate_deps;
export get_crate_hash; export get_crate_hash;
export get_crate_vers; export get_crate_vers;
export get_impls_for_mod; export get_impls_for_mod;
export get_iface_methods; export get_trait_methods;
export get_crate_module_paths; export get_crate_module_paths;
export def_like; export def_like;
export dl_def; export dl_def;
@ -164,10 +164,10 @@ fn item_type(item_id: ast::def_id, item: ebml::doc,
} else { t } } else { t }
} }
fn item_impl_iface(item: ebml::doc, tcx: ty::ctxt, cdata: cmd) fn item_impl_trait(item: ebml::doc, tcx: ty::ctxt, cdata: cmd)
-> option<ty::t> { -> option<ty::t> {
let mut result = none; let mut result = none;
do ebml::tagged_docs(item, tag_impl_iface) |ity| { do ebml::tagged_docs(item, tag_impl_trait) |ity| {
result = some(doc_type(ity, tcx, cdata)); result = some(doc_type(ity, tcx, cdata));
}; };
result result
@ -328,9 +328,9 @@ fn get_type_param_count(data: @~[u8], id: ast::node_id) -> uint {
item_ty_param_count(lookup_item(id, data)) item_ty_param_count(lookup_item(id, data))
} }
fn get_impl_iface(cdata: cmd, id: ast::node_id, tcx: ty::ctxt) fn get_impl_trait(cdata: cmd, id: ast::node_id, tcx: ty::ctxt)
-> option<ty::t> { -> option<ty::t> {
item_impl_iface(lookup_item(id, cdata.data), tcx, cdata) item_impl_trait(lookup_item(id, cdata.data), tcx, cdata)
} }
fn get_impl_method(cdata: cmd, id: ast::node_id, fn get_impl_method(cdata: cmd, id: ast::node_id,
@ -354,7 +354,7 @@ fn get_class_method(cdata: cmd, id: ast::node_id,
some(it) { it } some(it) { it }
none { fail (#fmt("get_class_method: class id not found \ none { fail (#fmt("get_class_method: class id not found \
when looking up method %s", *name)) }}; when looking up method %s", *name)) }};
do ebml::tagged_docs(cls_items, tag_item_iface_method) |mid| { do ebml::tagged_docs(cls_items, tag_item_trait_method) |mid| {
let m_did = class_member_id(mid, cdata); let m_did = class_member_id(mid, cdata);
if item_name(mid) == name { if item_name(mid) == name {
found = some(m_did); found = some(m_did);
@ -601,20 +601,20 @@ fn get_impls_for_mod(cdata: cmd,
@result @result
} }
/* Works for both classes and ifaces */ /* Works for both classes and traits */
fn get_iface_methods(cdata: cmd, id: ast::node_id, tcx: ty::ctxt) fn get_trait_methods(cdata: cmd, id: ast::node_id, tcx: ty::ctxt)
-> @~[ty::method] { -> @~[ty::method] {
let data = cdata.data; let data = cdata.data;
let item = lookup_item(id, data); let item = lookup_item(id, data);
let mut result = ~[]; let mut result = ~[];
do ebml::tagged_docs(item, tag_item_iface_method) |mth| { do ebml::tagged_docs(item, tag_item_trait_method) |mth| {
let bounds = item_ty_param_bounds(mth, tcx, cdata); let bounds = item_ty_param_bounds(mth, tcx, cdata);
let name = item_name(mth); let name = item_name(mth);
let ty = doc_type(mth, tcx, cdata); let ty = doc_type(mth, tcx, cdata);
let fty = alt ty::get(ty).struct { ty::ty_fn(f) { f } let fty = alt ty::get(ty).struct { ty::ty_fn(f) { f }
_ { _ {
tcx.diag.handler().bug( tcx.diag.handler().bug(
"get_iface_methods: id has non-function type"); "get_trait_methods: id has non-function type");
} }; } };
vec::push(result, {ident: name, tps: bounds, fty: fty, vec::push(result, {ident: name, tps: bounds, fty: fty,
purity: alt check item_family(mth) { purity: alt check item_family(mth) {
@ -703,7 +703,7 @@ fn item_family_to_str(fam: char) -> str {
'n' { ret "foreign mod"; } 'n' { ret "foreign mod"; }
'v' { ret "enum"; } 'v' { ret "enum"; }
'i' { ret "impl"; } 'i' { ret "impl"; }
'I' { ret "iface"; } 'I' { ret "trait"; }
'C' { ret "class"; } 'C' { ret "class"; }
'g' { ret "public field"; } 'g' { ret "public field"; }
'j' { ret "private field"; } 'j' { ret "private field"; }

28
src/rustc/metadata/encoder.rs
View File

@ -211,7 +211,7 @@ fn encode_module_item_paths(ebml_w: ebml::writer, ecx: @encode_ctxt,
} }
encode_enum_variant_paths(ebml_w, variants, path, index); encode_enum_variant_paths(ebml_w, variants, path, index);
} }
item_iface(*) { item_trait(*) {
do ebml_w.wr_tag(tag_paths_data_item) { do ebml_w.wr_tag(tag_paths_data_item) {
encode_name_and_def_id(ebml_w, it.ident, it.id); encode_name_and_def_id(ebml_w, it.ident, it.id);
} }
@ -221,8 +221,8 @@ fn encode_module_item_paths(ebml_w: ebml::writer, ecx: @encode_ctxt,
} }
} }
fn encode_iface_ref(ebml_w: ebml::writer, ecx: @encode_ctxt, t: @iface_ref) { fn encode_trait_ref(ebml_w: ebml::writer, ecx: @encode_ctxt, t: @trait_ref) {
ebml_w.start_tag(tag_impl_iface); ebml_w.start_tag(tag_impl_trait);
encode_type(ecx, ebml_w, node_id_to_type(ecx.tcx, t.id)); encode_type(ecx, ebml_w, node_id_to_type(ecx.tcx, t.id));
ebml_w.end_tag(); ebml_w.end_tag();
} }
@ -396,7 +396,7 @@ fn encode_info_for_mod(ecx: @encode_ctxt, ebml_w: ebml::writer, md: _mod,
ebml_w.start_tag(tag_mod_impl); ebml_w.start_tag(tag_mod_impl);
alt ecx.tcx.items.find(did.node) { alt ecx.tcx.items.find(did.node) {
some(ast_map::node_item(it@@{node: cl@item_class(*),_},_)) { some(ast_map::node_item(it@@{node: cl@item_class(*),_},_)) {
/* If did stands for an iface /* If did stands for a trait
ref, we need to map it to its parent class */ ref, we need to map it to its parent class */
ebml_w.wr_str(def_to_str(local_def(it.id))); ebml_w.wr_str(def_to_str(local_def(it.id)));
} }
@ -622,7 +622,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
encode_enum_variant_info(ecx, ebml_w, item.id, variants, encode_enum_variant_info(ecx, ebml_w, item.id, variants,
path, index, tps); path, index, tps);
} }
item_class(tps, ifaces, items, ctor, m_dtor, rp) { item_class(tps, traits, items, ctor, m_dtor, rp) {
/* First, encode the fields and methods /* First, encode the fields and methods
These come first because we need to write them to make These come first because we need to write them to make
the index, and the index needs to be in the item for the the index, and the index needs to be in the item for the
@ -650,8 +650,8 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
encode_name(ebml_w, item.ident); encode_name(ebml_w, item.ident);
encode_path(ebml_w, path, ast_map::path_name(item.ident)); encode_path(ebml_w, path, ast_map::path_name(item.ident));
encode_region_param(ebml_w, rp); encode_region_param(ebml_w, rp);
for ifaces.each |t| { for traits.each |t| {
encode_iface_ref(ebml_w, ecx, t); encode_trait_ref(ebml_w, ecx, t);
} }
/* Encode the dtor */ /* Encode the dtor */
/* Encode id for dtor */ /* Encode id for dtor */
@ -662,7 +662,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
}; };
/* Encode def_ids for each field and method /* Encode def_ids for each field and method
for methods, write all the stuff get_iface_method for methods, write all the stuff get_trait_method
needs to know*/ needs to know*/
let (fs,ms) = ast_util::split_class_items(items); let (fs,ms) = ast_util::split_class_items(items);
for fs.each |f| { for fs.each |f| {
@ -677,8 +677,8 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
private { /* do nothing */ } private { /* do nothing */ }
public { public {
/* Write the info that's needed when viewing this class /* Write the info that's needed when viewing this class
as an iface */ as a trait */
ebml_w.start_tag(tag_item_iface_method); ebml_w.start_tag(tag_item_trait_method);
encode_family(ebml_w, purity_fn_family(m.decl.purity)); encode_family(ebml_w, purity_fn_family(m.decl.purity));
encode_name(ebml_w, m.ident); encode_name(ebml_w, m.ident);
encode_type_param_bounds(ebml_w, ecx, m.tps); encode_type_param_bounds(ebml_w, ecx, m.tps);
@ -713,7 +713,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
ebml_w.end_tag(); ebml_w.end_tag();
} }
do option::iter(ifce) |t| { do option::iter(ifce) |t| {
encode_iface_ref(ebml_w, ecx, t) encode_trait_ref(ebml_w, ecx, t)
}; };
encode_path(ebml_w, path, ast_map::path_name(item.ident)); encode_path(ebml_w, path, ast_map::path_name(item.ident));
ebml_w.end_tag(); ebml_w.end_tag();
@ -727,7 +727,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
vec::append(tps, m.tps)); vec::append(tps, m.tps));
} }
} }
item_iface(tps, rp, ms) { item_trait(tps, rp, ms) {
add_to_index(); add_to_index();
ebml_w.start_tag(tag_items_data_item); ebml_w.start_tag(tag_items_data_item);
encode_def_id(ebml_w, local_def(item.id)); encode_def_id(ebml_w, local_def(item.id));
@ -737,8 +737,8 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
encode_type(ecx, ebml_w, node_id_to_type(tcx, item.id)); encode_type(ecx, ebml_w, node_id_to_type(tcx, item.id));
encode_name(ebml_w, item.ident); encode_name(ebml_w, item.ident);
let mut i = 0u; let mut i = 0u;
for vec::each(*ty::iface_methods(tcx, local_def(item.id))) |mty| { for vec::each(*ty::trait_methods(tcx, local_def(item.id))) |mty| {
ebml_w.start_tag(tag_item_iface_method); ebml_w.start_tag(tag_item_trait_method);
encode_name(ebml_w, mty.ident); encode_name(ebml_w, mty.ident);
encode_type_param_bounds(ebml_w, ecx, ms[i].tps); encode_type_param_bounds(ebml_w, ecx, ms[i].tps);
encode_type(ecx, ebml_w, ty::mk_fn(tcx, mty.fty)); encode_type(ecx, ebml_w, ty::mk_fn(tcx, mty.fty));

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

@ -290,7 +290,7 @@ fn parse_ty(st: @pstate, conv: conv_did) -> ty::t {
let def = parse_def(st, conv); let def = parse_def(st, conv);
let substs = parse_substs(st, conv); let substs = parse_substs(st, conv);
assert next(st) == ']'; assert next(st) == ']';
ret ty::mk_iface(st.tcx, def, substs); ret ty::mk_trait(st.tcx, def, substs);
} }
'p' { 'p' {
let did = parse_def(st, conv); let did = parse_def(st, conv);
@ -505,7 +505,7 @@ fn parse_bounds(st: @pstate, conv: conv_did) -> @~[ty::param_bound] {
'S' { ty::bound_send } 'S' { ty::bound_send }
'C' { ty::bound_copy } 'C' { ty::bound_copy }
'K' { ty::bound_const } 'K' { ty::bound_const }
'I' { ty::bound_iface(parse_ty(st, conv)) } 'I' { ty::bound_trait(parse_ty(st, conv)) }
'.' { break; } '.' { break; }
}); });
} }

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

@ -222,7 +222,7 @@ fn enc_sty(w: io::writer, cx: @ctxt, st: ty::sty) {
enc_substs(w, cx, substs); enc_substs(w, cx, substs);
w.write_char(']'); w.write_char(']');
} }
ty::ty_iface(def, substs) { ty::ty_trait(def, substs) {
w.write_str("x["/&); w.write_str("x["/&);
w.write_str(cx.ds(def)); w.write_str(cx.ds(def));
w.write_char('|'); w.write_char('|');
@ -401,7 +401,7 @@ fn enc_bounds(w: io::writer, cx: @ctxt, bs: @~[ty::param_bound]) {
ty::bound_send { w.write_char('S'); } ty::bound_send { w.write_char('S'); }
ty::bound_copy { w.write_char('C'); } ty::bound_copy { w.write_char('C'); }
ty::bound_const { w.write_char('K'); } ty::bound_const { w.write_char('K'); }
ty::bound_iface(tp) { ty::bound_trait(tp) {
w.write_char('I'); w.write_char('I');
enc_ty(w, cx, tp); enc_ty(w, cx, tp);
} }

12
src/rustc/middle/astencode.rs
View File

@ -395,10 +395,10 @@ impl of tr for method_origin {
typeck::method_static(did.tr(xcx)) typeck::method_static(did.tr(xcx))
} }
typeck::method_param(mp) { typeck::method_param(mp) {
typeck::method_param({iface_id:mp.iface_id.tr(xcx) with mp}) typeck::method_param({trait_id:mp.trait_id.tr(xcx) with mp})
} }
typeck::method_iface(did, m) { typeck::method_trait(did, m) {
typeck::method_iface(did.tr(xcx), m) typeck::method_trait(did.tr(xcx), m)
} }
} }
} }
@ -458,8 +458,8 @@ fn encode_vtable_origin(ecx: @e::encode_ctxt,
} }
} }
} }
typeck::vtable_iface(def_id, tys) { typeck::vtable_trait(def_id, tys) {
do ebml_w.emit_enum_variant("vtable_iface", 1u, 3u) { do ebml_w.emit_enum_variant("vtable_trait", 1u, 3u) {
do ebml_w.emit_enum_variant_arg(0u) { do ebml_w.emit_enum_variant_arg(0u) {
ebml_w.emit_def_id(def_id) ebml_w.emit_def_id(def_id)
} }
@ -507,7 +507,7 @@ impl helpers for ebml::ebml_deserializer {
) )
} }
2u { 2u {
typeck::vtable_iface( typeck::vtable_trait(
do self.read_enum_variant_arg(0u) { do self.read_enum_variant_arg(0u) {
self.read_def_id(xcx) self.read_def_id(xcx)
}, },

16
src/rustc/middle/kind.rs
View File

@ -265,16 +265,16 @@ fn check_expr(e: @expr, cx: ctx, v: visit::vt<ctx>) {
// and then the method bounds themselves... // and then the method bounds themselves...
ty::lookup_item_type(cx.tcx, did).bounds ty::lookup_item_type(cx.tcx, did).bounds
} }
typeck::method_param({iface_id:ifce_id, typeck::method_param({trait_id:trt_id,
method_num:n_mth, _}) | method_num:n_mth, _}) |
typeck::method_iface(ifce_id, n_mth) { typeck::method_trait(trt_id, n_mth) {
// ...iface methods bounds, in contrast, include only the // ...trait methods bounds, in contrast, include only the
// method bounds, so we must preprend the tps from the // method bounds, so we must preprend the tps from the
// iface itself. This ought to be harmonized. // trait itself. This ought to be harmonized.
let ifce_bounds = let trt_bounds =
ty::lookup_item_type(cx.tcx, ifce_id).bounds; ty::lookup_item_type(cx.tcx, trt_id).bounds;
let mth = ty::iface_methods(cx.tcx, ifce_id)[n_mth]; let mth = ty::trait_methods(cx.tcx, trt_id)[n_mth];
@(vec::append(*ifce_bounds, *mth.tps)) @(vec::append(*trt_bounds, *mth.tps))
} }
} }
} }

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

@ -406,7 +406,7 @@ fn maybe_insert(e: @env, id: node_id, def: option<def>) {
} }
} }
fn resolve_iface_ref(p: @iface_ref, sc: scopes, e: @env) { fn resolve_trait_ref(p: @trait_ref, sc: scopes, e: @env) {
maybe_insert(e, p.id, maybe_insert(e, p.id,
lookup_path_strict(*e, sc, p.path.span, p.path, ns_type)); lookup_path_strict(*e, sc, p.path.span, p.path, ns_type));
} }
@ -436,15 +436,15 @@ fn resolve_names(e: @env, c: @ast::crate) {
fn walk_item(e: @env, i: @ast::item, &&sc: scopes, v: vt<scopes>) { fn walk_item(e: @env, i: @ast::item, &&sc: scopes, v: vt<scopes>) {
visit_item_with_scope(e, i, sc, v); visit_item_with_scope(e, i, sc, v);
alt i.node { alt i.node {
/* At this point, the code knows what ifaces the iface refs /* At this point, the code knows what traits the trait refs
refer to, so it's possible to resolve them. refer to, so it's possible to resolve them.
*/ */
ast::item_impl(_, _, ifce, _, _) { ast::item_impl(_, _, ifce, _, _) {
ifce.iter(|p| resolve_iface_ref(p, sc, e)) ifce.iter(|p| resolve_trait_ref(p, sc, e))
} }
ast::item_class(_, ifaces, _, _, _, _) { ast::item_class(_, traits, _, _, _, _) {
for ifaces.each |p| { for traits.each |p| {
resolve_iface_ref(p, sc, e); resolve_trait_ref(p, sc, e);
} }
} }
_ {} _ {}
@ -485,7 +485,7 @@ fn resolve_names(e: @env, c: @ast::crate) {
e.current_tp = some(current); e.current_tp = some(current);
for vec::each(*tp.bounds) |bound| { for vec::each(*tp.bounds) |bound| {
alt bound { alt bound {
bound_iface(t) { v.visit_ty(t, sc, v); } bound_trait(t) { v.visit_ty(t, sc, v); }
_ {} _ {}
} }
} }
@ -564,7 +564,7 @@ fn visit_item_with_scope(e: @env, i: @ast::item,
m.decl, m.body, m.span, m.id, msc, v); m.decl, m.body, m.span, m.id, msc, v);
} }
} }
ast::item_iface(tps, _, methods) { ast::item_trait(tps, _, methods) {
v.visit_ty_params(tps, sc, v); v.visit_ty_params(tps, sc, v);
let isc = @cons(scope_method(i.id, tps), sc); let isc = @cons(scope_method(i.id, tps), sc);
for methods.each |m| { for methods.each |m| {
@ -574,14 +574,14 @@ fn visit_item_with_scope(e: @env, i: @ast::item,
v.visit_ty(m.decl.output, msc, v); v.visit_ty(m.decl.output, msc, v);
} }
} }
ast::item_class(tps, ifaces, members, ctor, m_dtor, _) { ast::item_class(tps, traits, members, ctor, m_dtor, _) {
v.visit_ty_params(tps, sc, v); v.visit_ty_params(tps, sc, v);
let class_scope = @cons(scope_item(i), sc); let class_scope = @cons(scope_item(i), sc);
/* visit the constructor... */ /* visit the constructor... */
let ctor_scope = @cons(scope_method(ctor.node.self_id, tps), let ctor_scope = @cons(scope_method(ctor.node.self_id, tps),
class_scope); class_scope);
/* visit the iface refs in the class scope */ /* visit the trait refs in the class scope */
for ifaces.each |p| { for traits.each |p| {
visit::visit_path(p.path, class_scope, v); visit::visit_path(p.path, class_scope, v);
} }
visit_fn_with_scope(e, visit::fk_ctor(i.ident, tps, ctor.node.self_id, visit_fn_with_scope(e, visit::fk_ctor(i.ident, tps, ctor.node.self_id,
@ -1048,7 +1048,7 @@ fn lookup_in_scope(e: env, &&sc: scopes, sp: span, name: ident, ns: namespace,
ast::item_enum(_, tps, _) | ast::item_ty(_, tps, _) { ast::item_enum(_, tps, _) | ast::item_ty(_, tps, _) {
if ns == ns_type { ret lookup_in_ty_params(e, name, tps); } if ns == ns_type { ret lookup_in_ty_params(e, name, tps); }
} }
ast::item_iface(tps, _, _) { ast::item_trait(tps, _, _) {
if ns == ns_type { if ns == ns_type {
if *name == "self" { if *name == "self" {
ret some(def_self(it.id)); ret some(def_self(it.id));
@ -1336,7 +1336,7 @@ fn found_def_item(i: @ast::item, ns: namespace) -> option<def> {
ret some(ast::def_foreign_mod(local_def(i.id))); ret some(ast::def_foreign_mod(local_def(i.id)));
} }
} }
ast::item_ty(*) | item_iface(*) | item_enum(*) { ast::item_ty(*) | item_trait(*) | item_enum(*) {
if ns == ns_type { ret some(ast::def_ty(local_def(i.id))); } if ns == ns_type { ret some(ast::def_ty(local_def(i.id))); }
} }
ast::item_class(_, _, _members, ct, _, _) { ast::item_class(_, _, _members, ct, _, _) {
@ -1641,7 +1641,7 @@ fn index_mod(md: ast::_mod) -> mod_index {
alt it.node { alt it.node {
ast::item_const(_, _) | ast::item_fn(_, _, _) | ast::item_mod(_) | ast::item_const(_, _) | ast::item_fn(_, _, _) | ast::item_mod(_) |
ast::item_foreign_mod(_) | ast::item_ty(_, _, _) | ast::item_foreign_mod(_) | ast::item_ty(_, _, _) |
ast::item_impl(*) | ast::item_iface(*) { ast::item_impl(*) | ast::item_trait(*) {
add_to_index(index, it.ident, mie_item(it)); add_to_index(index, it.ident, mie_item(it));
} }
ast::item_enum(variants, _, _) { ast::item_enum(variants, _, _) {
@ -1780,7 +1780,7 @@ fn check_item(e: @env, i: @ast::item, &&x: (), v: vt<()>) {
ensure_unique(*e, i.span, ty_params, |tp| tp.ident, ensure_unique(*e, i.span, ty_params, |tp| tp.ident,
"type parameter"); "type parameter");
} }
ast::item_iface(_, _, methods) { ast::item_trait(_, _, methods) {
ensure_unique(*e, i.span, methods, |m| m.ident, ensure_unique(*e, i.span, methods, |m| m.ident,
"method"); "method");
} }
@ -1862,7 +1862,7 @@ fn check_block(e: @env, b: ast::blk, &&x: (), v: vt<()>) {
ast::item_const(_, _) | ast::item_fn(*) { ast::item_const(_, _) | ast::item_fn(*) {
add_name(values, it.span, it.ident); add_name(values, it.span, it.ident);
} }
ast::item_ty(*) | ast::item_iface(*) { ast::item_ty(*) | ast::item_trait(*) {
add_name(types, it.span, it.ident); add_name(types, it.span, it.ident);
} }
_ { } _ { }
@ -2146,7 +2146,7 @@ type method_info = {did: def_id, n_tps: uint, ident: ast::ident};
* did: the def id of the class or impl item * did: the def id of the class or impl item
* ident: the name of the impl, unless it has no name (as in * ident: the name of the impl, unless it has no name (as in
"impl of X") in which case the ident "impl of X") in which case the ident
is the ident of the iface that's being implemented is the ident of the trait that's being implemented
* methods: the item's methods * methods: the item's methods
*/ */
type _impl = {did: def_id, ident: ast::ident, methods: ~[@method_info]}; type _impl = {did: def_id, ident: ast::ident, methods: ~[@method_info]};
@ -2258,7 +2258,7 @@ fn find_impls_in_item(e: env, i: @ast::item, &impls: ~[@_impl],
let n_tps = tps.len(); let n_tps = tps.len();
do vec::iter(ifces) |p| { do vec::iter(ifces) |p| {
// The def_id, in this case, identifies the combination of // The def_id, in this case, identifies the combination of
// class and iface // class and trait
vec::push(impls, @{did: local_def(p.id), vec::push(impls, @{did: local_def(p.id),
ident: i.ident, ident: i.ident,
methods: vec::map(mthds, |m| { methods: vec::map(mthds, |m| {

22
src/rustc/middle/resolve3.rs
View File

@ -2,7 +2,7 @@ import driver::session::session;
import metadata::csearch::{each_path, get_impls_for_mod, lookup_defs}; import metadata::csearch::{each_path, get_impls_for_mod, lookup_defs};
import metadata::cstore::find_use_stmt_cnum; import metadata::cstore::find_use_stmt_cnum;
import metadata::decoder::{def_like, dl_def, dl_field, dl_impl}; import metadata::decoder::{def_like, dl_def, dl_field, dl_impl};
import syntax::ast::{_mod, arm, blk, bound_const, bound_copy, bound_iface}; import syntax::ast::{_mod, arm, blk, bound_const, bound_copy, bound_trait};
import syntax::ast::{bound_send, capture_clause, class_ctor, class_dtor}; import syntax::ast::{bound_send, capture_clause, class_ctor, class_dtor};
import syntax::ast::{class_member, class_method, crate, crate_num, decl_item}; import syntax::ast::{class_member, class_method, crate, crate_num, decl_item};
import syntax::ast::{def, def_arg, def_binding, def_class, def_const, def_fn}; import syntax::ast::{def, def_arg, def_binding, def_class, def_const, def_fn};
@ -12,9 +12,9 @@ import syntax::ast::{def_upvar, def_use, def_variant, expr, expr_assign_op};
import syntax::ast::{expr_binary, expr_cast, expr_field, expr_fn}; import syntax::ast::{expr_binary, expr_cast, expr_field, expr_fn};
import syntax::ast::{expr_fn_block, expr_index, expr_new, expr_path}; import syntax::ast::{expr_fn_block, expr_index, expr_new, expr_path};
import syntax::ast::{expr_unary, fn_decl, foreign_item, foreign_item_fn}; import syntax::ast::{expr_unary, fn_decl, foreign_item, foreign_item_fn};
import syntax::ast::{ident, iface_ref, impure_fn, instance_var, item}; import syntax::ast::{ident, trait_ref, impure_fn, instance_var, item};
import syntax::ast::{item_class, item_const, item_enum, item_fn}; import syntax::ast::{item_class, item_const, item_enum, item_fn};
import syntax::ast::{item_foreign_mod, item_iface, item_impl, item_mod}; import syntax::ast::{item_foreign_mod, item_trait, item_impl, item_mod};
import syntax::ast::{item_ty, local, local_crate, method, node_id, pat}; import syntax::ast::{item_ty, local, local_crate, method, node_id, pat};
import syntax::ast::{pat_enum, pat_ident, path, prim_ty, stmt_decl, ty}; import syntax::ast::{pat_enum, pat_ident, path, prim_ty, stmt_decl, ty};
import syntax::ast::{ty_bool, ty_char, ty_constr, ty_f, ty_f32, ty_f64}; import syntax::ast::{ty_bool, ty_char, ty_constr, ty_f, ty_f32, ty_f64};
@ -867,7 +867,7 @@ class Resolver {
visit_item(item, new_parent, visitor); visit_item(item, new_parent, visitor);
} }
item_iface(*) { item_trait(*) {
(*name_bindings).define_type(def_ty(local_def(item.id))); (*name_bindings).define_type(def_ty(local_def(item.id)));
visit_item(item, new_parent, visitor); visit_item(item, new_parent, visitor);
} }
@ -1233,7 +1233,7 @@ class Resolver {
fn build_reduced_graph_for_impls_in_external_module(module: @Module) { fn build_reduced_graph_for_impls_in_external_module(module: @Module) {
// XXX: This is really unfortunate. decoder::each_path can produce // XXX: This is really unfortunate. decoder::each_path can produce
// false positives, since, in the crate metadata, an iface named 'bar' // false positives, since, in the crate metadata, a trait named 'bar'
// in module 'foo' defining a method named 'baz' will result in the // in module 'foo' defining a method named 'baz' will result in the
// creation of a (bogus) path entry named 'foo::bar::baz', and we will // creation of a (bogus) path entry named 'foo::bar::baz', and we will
// create a module node for "bar". We can identify these fake modules // create a module node for "bar". We can identify these fake modules
@ -2747,7 +2747,7 @@ class Resolver {
visitor); visitor);
} }
item_iface(type_parameters, _, methods) { item_trait(type_parameters, _, methods) {
// Create a new rib for the self type. // Create a new rib for the self type.
let self_type_rib = @Rib(NormalRibKind); let self_type_rib = @Rib(NormalRibKind);
(*self.type_ribs).push(self_type_rib); (*self.type_ribs).push(self_type_rib);
@ -3013,7 +3013,7 @@ class Resolver {
bound_copy | bound_send | bound_const { bound_copy | bound_send | bound_const {
// Nothing to do. // Nothing to do.
} }
bound_iface(interface_type) { bound_trait(interface_type) {
self.resolve_type(interface_type, visitor); self.resolve_type(interface_type, visitor);
} }
} }
@ -3023,14 +3023,14 @@ class Resolver {
fn resolve_class(id: node_id, fn resolve_class(id: node_id,
type_parameters: @~[ty_param], type_parameters: @~[ty_param],
interfaces: ~[@iface_ref], interfaces: ~[@trait_ref],
class_members: ~[@class_member], class_members: ~[@class_member],
constructor: class_ctor, constructor: class_ctor,
optional_destructor: option<class_dtor>, optional_destructor: option<class_dtor>,
visitor: ResolveVisitor) { visitor: ResolveVisitor) {
// Add a type into the def map. This is needed to prevent an ICE in // Add a type into the def map. This is needed to prevent an ICE in
// ty::impl_iface. // ty::impl_trait.
// If applicable, create a rib for the type parameters. // If applicable, create a rib for the type parameters.
let outer_type_parameter_count = (*type_parameters).len(); let outer_type_parameter_count = (*type_parameters).len();
@ -3055,7 +3055,7 @@ class Resolver {
// definition of the interface into the definition // definition of the interface into the definition
// map. // map.
#debug("(resolving class) found iface def: %?", def); #debug("(resolving class) found trait def: %?", def);
self.record_def(interface.id, def); self.record_def(interface.id, def);
@ -3122,7 +3122,7 @@ class Resolver {
fn resolve_implementation(id: node_id, fn resolve_implementation(id: node_id,
span: span, span: span,
type_parameters: ~[ty_param], type_parameters: ~[ty_param],
interface_reference: option<@iface_ref>, interface_reference: option<@trait_ref>,
self_type: @ty, self_type: @ty,
methods: ~[@method], methods: ~[@method],
visitor: ResolveVisitor) { visitor: ResolveVisitor) {

18
src/rustc/middle/trans/base.rs
View File

@ -652,7 +652,7 @@ fn make_take_glue(bcx: block, v: ValueRef, t: ty::t) {
ty::ty_fn(_) { ty::ty_fn(_) {
closure::make_fn_glue(bcx, v, t, take_ty) closure::make_fn_glue(bcx, v, t, take_ty)
} }
ty::ty_iface(_, _) { ty::ty_trait(_, _) {
let llbox = Load(bcx, GEPi(bcx, v, ~[0u, 1u])); let llbox = Load(bcx, GEPi(bcx, v, ~[0u, 1u]));
incr_refcnt_of_boxed(bcx, llbox); incr_refcnt_of_boxed(bcx, llbox);
bcx bcx
@ -682,10 +682,10 @@ fn incr_refcnt_of_boxed(cx: block, box_ptr: ValueRef) {
fn make_visit_glue(bcx: block, v: ValueRef, t: ty::t) { fn make_visit_glue(bcx: block, v: ValueRef, t: ty::t) {
let _icx = bcx.insn_ctxt("make_visit_glue"); let _icx = bcx.insn_ctxt("make_visit_glue");
let mut bcx = bcx; let mut bcx = bcx;
assert bcx.ccx().tcx.intrinsic_ifaces.contains_key(@"ty_visitor"); assert bcx.ccx().tcx.intrinsic_traits.contains_key(@"ty_visitor");
let (iid, ty) = bcx.ccx().tcx.intrinsic_ifaces.get(@"ty_visitor"); let (iid, ty) = bcx.ccx().tcx.intrinsic_traits.get(@"ty_visitor");
let v = PointerCast(bcx, v, T_ptr(type_of::type_of(bcx.ccx(), ty))); let v = PointerCast(bcx, v, T_ptr(type_of::type_of(bcx.ccx(), ty)));
bcx = reflect::emit_calls_to_iface_visit_ty(bcx, t, v, iid); bcx = reflect::emit_calls_to_trait_visit_ty(bcx, t, v, iid);
build_return(bcx); build_return(bcx);
} }
@ -808,7 +808,7 @@ fn make_drop_glue(bcx: block, v0: ValueRef, t: ty::t) {
ty::ty_fn(_) { ty::ty_fn(_) {
closure::make_fn_glue(bcx, v0, t, drop_ty) closure::make_fn_glue(bcx, v0, t, drop_ty)
} }
ty::ty_iface(_, _) { ty::ty_trait(_, _) {
let llbox = Load(bcx, GEPi(bcx, v0, ~[0u, 1u])); let llbox = Load(bcx, GEPi(bcx, v0, ~[0u, 1u]));
decr_refcnt_maybe_free(bcx, llbox, ty::mk_opaque_box(ccx.tcx)) decr_refcnt_maybe_free(bcx, llbox, ty::mk_opaque_box(ccx.tcx))
} }
@ -2063,7 +2063,7 @@ fn normalize_for_monomorphization(tcx: ty::ctxt, ty: ty::t) -> option<ty::t> {
output: ty::mk_nil(tcx), output: ty::mk_nil(tcx),
ret_style: ast::return_val, ret_style: ast::return_val,
constraints: ~[]})) } constraints: ~[]})) }
ty::ty_iface(_, _) { some(ty::mk_fn(tcx, {purity: ast::impure_fn, ty::ty_trait(_, _) { some(ty::mk_fn(tcx, {purity: ast::impure_fn,
proto: ast::proto_box, proto: ast::proto_box,
inputs: ~[], inputs: ~[],
output: ty::mk_nil(tcx), output: ty::mk_nil(tcx),
@ -2085,7 +2085,7 @@ fn make_mono_id(ccx: @crate_ctxt, item: ast::def_id, substs: ~[ty::t],
let mut v = ~[]; let mut v = ~[];
for vec::each(*bounds) |bound| { for vec::each(*bounds) |bound| {
alt bound { alt bound {
ty::bound_iface(_) { ty::bound_trait(_) {
vec::push(v, impl::vtable_id(ccx, vts[i])); vec::push(v, impl::vtable_id(ccx, vts[i]));
i += 1u; i += 1u;
} }
@ -2822,7 +2822,7 @@ fn trans_cast(cx: block, e: @ast::expr, id: ast::node_id,
let ccx = cx.ccx(); let ccx = cx.ccx();
let t_out = node_id_type(cx, id); let t_out = node_id_type(cx, id);
alt ty::get(t_out).struct { alt ty::get(t_out).struct {
ty::ty_iface(_, _) { ret impl::trans_cast(cx, e, id, dest); } ty::ty_trait(_, _) { ret impl::trans_cast(cx, e, id, dest); }
_ {} _ {}
} }
let e_res = trans_temp_expr(cx, e); let e_res = trans_temp_expr(cx, e);
@ -4964,7 +4964,7 @@ fn trans_item(ccx: @crate_ctxt, item: ast::item) {
}; };
foreign::trans_foreign_mod(ccx, foreign_mod, abi); foreign::trans_foreign_mod(ccx, foreign_mod, abi);
} }
ast::item_class(tps, _ifaces, items, ctor, m_dtor, _) { ast::item_class(tps, _traits, items, ctor, m_dtor, _) {
if tps.len() == 0u { if tps.len() == 0u {
let psubsts = {tys: ty::ty_params_to_tys(ccx.tcx, tps), let psubsts = {tys: ty::ty_params_to_tys(ccx.tcx, tps),
vtables: none, vtables: none,

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

@ -783,7 +783,7 @@ fn T_captured_tydescs(cx: @crate_ctxt, n: uint) -> TypeRef {
ret T_struct(vec::from_elem::<TypeRef>(n, T_ptr(cx.tydesc_type))); ret T_struct(vec::from_elem::<TypeRef>(n, T_ptr(cx.tydesc_type)));
} }
fn T_opaque_iface(cx: @crate_ctxt) -> TypeRef { fn T_opaque_trait(cx: @crate_ctxt) -> TypeRef {
T_struct(~[T_ptr(cx.tydesc_type), T_opaque_box_ptr(cx)]) T_struct(~[T_ptr(cx.tydesc_type), T_opaque_box_ptr(cx)])
} }

32
src/rustc/middle/trans/impl.rs
View File

@ -58,7 +58,7 @@ fn trans_method_callee(bcx: block, callee_id: ast::node_id,
{env: self_env(val, node_id_type(bcx, self.id), none) {env: self_env(val, node_id_type(bcx, self.id), none)
with lval_static_fn(bcx, did, callee_id)} with lval_static_fn(bcx, did, callee_id)}
} }
typeck::method_param({iface_id:iid, method_num:off, typeck::method_param({trait_id:iid, method_num:off,
param_num:p, bound_num:b}) { param_num:p, bound_num:b}) {
alt check bcx.fcx.param_substs { alt check bcx.fcx.param_substs {
some(substs) { some(substs) {
@ -67,10 +67,10 @@ fn trans_method_callee(bcx: block, callee_id: ast::node_id,
} }
} }
} }
typeck::method_iface(_, off) { typeck::method_trait(_, off) {
let {bcx, val} = trans_temp_expr(bcx, self); let {bcx, val} = trans_temp_expr(bcx, self);
let fty = node_id_type(bcx, callee_id); let fty = node_id_type(bcx, callee_id);
trans_iface_callee(bcx, val, fty, off) trans_trait_callee(bcx, val, fty, off)
} }
} }
} }
@ -112,14 +112,14 @@ fn method_ty_param_count(ccx: @crate_ctxt, m_id: ast::def_id,
fn trans_monomorphized_callee(bcx: block, callee_id: ast::node_id, fn trans_monomorphized_callee(bcx: block, callee_id: ast::node_id,
base: @ast::expr, derefs: uint, base: @ast::expr, derefs: uint,
iface_id: ast::def_id, n_method: uint, trait_id: ast::def_id, n_method: uint,
n_param: uint, n_bound: uint, n_param: uint, n_bound: uint,
substs: param_substs) -> lval_maybe_callee { substs: param_substs) -> lval_maybe_callee {
let _icx = bcx.insn_ctxt("impl::trans_monomorphized_callee"); let _icx = bcx.insn_ctxt("impl::trans_monomorphized_callee");
alt find_vtable_in_fn_ctxt(substs, n_param, n_bound) { alt find_vtable_in_fn_ctxt(substs, n_param, n_bound) {
typeck::vtable_static(impl_did, impl_substs, sub_origins) { typeck::vtable_static(impl_did, impl_substs, sub_origins) {
let ccx = bcx.ccx(); let ccx = bcx.ccx();
let mname = ty::iface_methods(ccx.tcx, iface_id)[n_method].ident; let mname = ty::trait_methods(ccx.tcx, trait_id)[n_method].ident;
let mth_id = method_with_name(bcx.ccx(), impl_did, mname); let mth_id = method_with_name(bcx.ccx(), impl_did, mname);
let n_m_tps = method_ty_param_count(ccx, mth_id, impl_did); let n_m_tps = method_ty_param_count(ccx, mth_id, impl_did);
let node_substs = node_id_type_params(bcx, callee_id); let node_substs = node_id_type_params(bcx, callee_id);
@ -135,10 +135,10 @@ fn trans_monomorphized_callee(bcx: block, callee_id: ast::node_id,
ccx, node_id_type(bcx, callee_id)))) ccx, node_id_type(bcx, callee_id))))
with lval} with lval}
} }
typeck::vtable_iface(iid, tps) { typeck::vtable_trait(iid, tps) {
let {bcx, val} = trans_temp_expr(bcx, base); let {bcx, val} = trans_temp_expr(bcx, base);
let fty = node_id_type(bcx, callee_id); let fty = node_id_type(bcx, callee_id);
trans_iface_callee(bcx, val, fty, n_method) trans_trait_callee(bcx, val, fty, n_method)
} }
typeck::vtable_param(n_param, n_bound) { typeck::vtable_param(n_param, n_bound) {
fail "vtable_param left in monomorphized function's vtable substs"; fail "vtable_param left in monomorphized function's vtable substs";
@ -146,11 +146,11 @@ fn trans_monomorphized_callee(bcx: block, callee_id: ast::node_id,
} }
} }
// Method callee where the vtable comes from a boxed iface // Method callee where the vtable comes from a boxed trait
fn trans_iface_callee(bcx: block, val: ValueRef, fn trans_trait_callee(bcx: block, val: ValueRef,
callee_ty: ty::t, n_method: uint) callee_ty: ty::t, n_method: uint)
-> lval_maybe_callee { -> lval_maybe_callee {
let _icx = bcx.insn_ctxt("impl::trans_iface_callee"); let _icx = bcx.insn_ctxt("impl::trans_trait_callee");
let ccx = bcx.ccx(); let ccx = bcx.ccx();
let vtable = Load(bcx, PointerCast(bcx, GEPi(bcx, val, ~[0u, 0u]), let vtable = Load(bcx, PointerCast(bcx, GEPi(bcx, val, ~[0u, 0u]),
T_ptr(T_ptr(T_vtable())))); T_ptr(T_ptr(T_vtable()))));
@ -173,7 +173,7 @@ fn find_vtable_in_fn_ctxt(ps: param_substs, n_param: uint, n_bound: uint)
for vec::each(*ps.bounds) |bounds| { for vec::each(*ps.bounds) |bounds| {
if i >= n_param { break; } if i >= n_param { break; }
for vec::each(*bounds) |bound| { for vec::each(*bounds) |bound| {
alt bound { ty::bound_iface(_) { vtable_off += 1u; } _ {} } alt bound { ty::bound_trait(_) { vtable_off += 1u; } _ {} }
} }
i += 1u; i += 1u;
} }
@ -215,8 +215,8 @@ fn vtable_id(ccx: @crate_ctxt, origin: typeck::vtable_origin) -> mono_id {
if (*sub_vtables).len() == 0u { none } if (*sub_vtables).len() == 0u { none }
else { some(sub_vtables) }, none) else { some(sub_vtables) }, none)
} }
typeck::vtable_iface(iface_id, substs) { typeck::vtable_trait(trait_id, substs) {
@{def: iface_id, @{def: trait_id,
params: vec::map(substs, |t| mono_precise(t, none))} params: vec::map(substs, |t| mono_precise(t, none))}
} }
} }
@ -254,11 +254,11 @@ fn make_impl_vtable(ccx: @crate_ctxt, impl_id: ast::def_id, substs: ~[ty::t],
let _icx = ccx.insn_ctxt("impl::make_impl_vtable"); let _icx = ccx.insn_ctxt("impl::make_impl_vtable");
let tcx = ccx.tcx; let tcx = ccx.tcx;
let ifce_id = expect(ccx.sess, let ifce_id = expect(ccx.sess,
ty::ty_to_def_id(option::get(ty::impl_iface(tcx, ty::ty_to_def_id(option::get(ty::impl_trait(tcx,
impl_id))), impl_id))),
|| "make_impl_vtable: non-iface-type implemented"); || "make_impl_vtable: non-trait-type implemented");
let has_tps = (*ty::lookup_item_type(ccx.tcx, impl_id).bounds).len() > 0u; let has_tps = (*ty::lookup_item_type(ccx.tcx, impl_id).bounds).len() > 0u;
make_vtable(ccx, vec::map(*ty::iface_methods(tcx, ifce_id), |im| { make_vtable(ccx, vec::map(*ty::trait_methods(tcx, ifce_id), |im| {
let fty = ty::subst_tps(tcx, substs, ty::mk_fn(tcx, im.fty)); let fty = ty::subst_tps(tcx, substs, ty::mk_fn(tcx, im.fty));
if (*im.tps).len() > 0u || ty::type_has_self(fty) { if (*im.tps).len() > 0u || ty::type_has_self(fty) {
C_null(T_ptr(T_nil())) C_null(T_ptr(T_nil()))

4
src/rustc/middle/trans/reachable.rs
View File

@ -121,7 +121,7 @@ fn traverse_public_item(cx: ctx, item: @item) {
} }
} }
} }
item_class(tps, _ifaces, items, ctor, m_dtor, _) { item_class(tps, _traits, items, ctor, m_dtor, _) {
cx.rmap.insert(ctor.node.id, ()); cx.rmap.insert(ctor.node.id, ());
do option::iter(m_dtor) |dtor| { do option::iter(m_dtor) |dtor| {
cx.rmap.insert(dtor.node.id, ()); cx.rmap.insert(dtor.node.id, ());
@ -147,7 +147,7 @@ fn traverse_public_item(cx: ctx, item: @item) {
traverse_ty(t, cx, mk_ty_visitor()); traverse_ty(t, cx, mk_ty_visitor());
} }
item_const(*) | item_const(*) |
item_enum(*) | item_iface(*) {} item_enum(*) | item_trait(*) {}
} }
} }

8
src/rustc/middle/trans/reflect.rs
View File

@ -47,7 +47,7 @@ impl methods for reflector {
let v = self.visitor_val; let v = self.visitor_val;
let get_lval = |bcx| { let get_lval = |bcx| {
let callee = let callee =
impl::trans_iface_callee(bcx, v, mth_ty, mth_idx); impl::trans_trait_callee(bcx, v, mth_ty, mth_idx);
#debug("calling mth ty %s, lltype %s", #debug("calling mth ty %s, lltype %s",
ty_to_str(bcx.ccx().tcx, mth_ty), ty_to_str(bcx.ccx().tcx, mth_ty),
val_str(bcx.ccx().tn, callee.val)); val_str(bcx.ccx().tn, callee.val));
@ -256,7 +256,7 @@ impl methods for reflector {
} }
// Miscallaneous extra types // Miscallaneous extra types
ty::ty_iface(_, _) { self.leaf("iface") } ty::ty_trait(_, _) { self.leaf("trait") }
ty::ty_var(_) { self.leaf("var") } ty::ty_var(_) { self.leaf("var") }
ty::ty_var_integral(_) { self.leaf("var_integral") } ty::ty_var_integral(_) { self.leaf("var_integral") }
ty::ty_param(n, _) { self.visit("param", ~[self.c_uint(n)]) } ty::ty_param(n, _) { self.visit("param", ~[self.c_uint(n)]) }
@ -278,13 +278,13 @@ impl methods for reflector {
} }
// Emit a sequence of calls to visit_ty::visit_foo // Emit a sequence of calls to visit_ty::visit_foo
fn emit_calls_to_iface_visit_ty(bcx: block, t: ty::t, fn emit_calls_to_trait_visit_ty(bcx: block, t: ty::t,
visitor_val: ValueRef, visitor_val: ValueRef,
visitor_iid: def_id) -> block { visitor_iid: def_id) -> block {
let r = reflector({ let r = reflector({
visitor_val: visitor_val, visitor_val: visitor_val,
visitor_methods: ty::iface_methods(bcx.tcx(), visitor_iid), visitor_methods: ty::trait_methods(bcx.tcx(), visitor_iid),
mut bcx: bcx mut bcx: bcx
}); });

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

@ -329,7 +329,7 @@ fn shape_of(ccx: @crate_ctxt, t: ty::t) -> ~[u8] {
add_substr(s, sub); add_substr(s, sub);
s s
} }
ty::ty_iface(_, _) { ~[shape_box_fn] } ty::ty_trait(_, _) { ~[shape_box_fn] }
ty::ty_class(did, substs) { ty::ty_class(did, substs) {
// same as records, unless there's a dtor // same as records, unless there's a dtor
let tps = substs.tps; let tps = substs.tps;

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

@ -140,7 +140,7 @@ fn type_of(cx: @crate_ctxt, t: ty::t) -> TypeRef {
T_struct(tys) T_struct(tys)
} }
ty::ty_fn(_) { T_fn_pair(cx, type_of_fn_from_ty(cx, t)) } ty::ty_fn(_) { T_fn_pair(cx, type_of_fn_from_ty(cx, t)) }
ty::ty_iface(_, _) { T_opaque_iface(cx) } ty::ty_trait(_, _) { T_opaque_trait(cx) }
ty::ty_type { T_ptr(cx.tydesc_type) } ty::ty_type { T_ptr(cx.tydesc_type) }
ty::ty_tup(elts) { ty::ty_tup(elts) {
let mut tys = ~[]; let mut tys = ~[];

10
src/rustc/middle/trans/type_use.rs
View File

@ -119,12 +119,12 @@ fn type_needs_inner(cx: ctx, use: uint, ty: ty::t,
alt ty::get(ty).struct { alt ty::get(ty).struct {
/* /*
This previously included ty_box -- that was wrong This previously included ty_box -- that was wrong
because if we cast an @T to an iface (for example) and return because if we cast an @T to an trait (for example) and return
it, we depend on the drop glue for T (we have to write the it, we depend on the drop glue for T (we have to write the
right tydesc into the result) right tydesc into the result)
*/ */
ty::ty_fn(_) | ty::ty_ptr(_) | ty::ty_rptr(_, _) ty::ty_fn(_) | ty::ty_ptr(_) | ty::ty_rptr(_, _)
| ty::ty_iface(_, _) { false } | ty::ty_trait(_, _) { false }
ty::ty_enum(did, substs) { ty::ty_enum(did, substs) {
if option::is_none(list::find(enums_seen, |id| id == did)) { if option::is_none(list::find(enums_seen, |id| id == did)) {
let seen = @cons(did, enums_seen); let seen = @cons(did, enums_seen);
@ -164,8 +164,8 @@ fn mark_for_expr(cx: ctx, e: @expr) {
expr_cast(base, _) { expr_cast(base, _) {
let result_t = ty::node_id_to_type(cx.ccx.tcx, e.id); let result_t = ty::node_id_to_type(cx.ccx.tcx, e.id);
alt ty::get(result_t).struct { alt ty::get(result_t).struct {
ty::ty_iface(*) { ty::ty_trait(*) {
// When we're casting to an iface, we need the // When we're casting to an trait, we need the
// tydesc for the expr that's being cast. // tydesc for the expr that's being cast.
node_type_needs(cx, use_tydesc, base.id); node_type_needs(cx, use_tydesc, base.id);
} }
@ -221,7 +221,7 @@ fn mark_for_expr(cx: ctx, e: @expr) {
typeck::method_param({param_num: param, _}) { typeck::method_param({param_num: param, _}) {
cx.uses[param] |= use_tydesc; cx.uses[param] |= use_tydesc;
} }
typeck::method_iface(_, _) {} typeck::method_trait(_, _) {}
} }
} }
} }

2
src/rustc/middle/tstate/pre_post_conditions.rs
View File

@ -48,7 +48,7 @@ fn find_pre_post_item(ccx: crate_ctxt, i: item) {
} }
item_mod(m) { find_pre_post_mod(m); } item_mod(m) { find_pre_post_mod(m); }
item_foreign_mod(nm) { find_pre_post_foreign_mod(nm); } item_foreign_mod(nm) { find_pre_post_foreign_mod(nm); }
item_ty(*) | item_enum(*) | item_iface(*) { ret; } item_ty(*) | item_enum(*) | item_trait(*) { ret; }
item_class(*) { item_class(*) {
fail "find_pre_post_item: shouldn't be called on item_class"; fail "find_pre_post_item: shouldn't be called on item_class";
} }

76
src/rustc/middle/ty.rs
View File

@ -69,7 +69,7 @@ export subst, subst_tps, substs_is_noop, substs_to_str, substs;
export t; export t;
export new_ty_hash; export new_ty_hash;
export enum_variants, substd_enum_variants, enum_is_univariant; export enum_variants, substd_enum_variants, enum_is_univariant;
export iface_methods, store_iface_methods, impl_iface; export trait_methods, store_trait_methods, impl_trait;
export enum_variant_with_id; export enum_variant_with_id;
export ty_dtor; export ty_dtor;
export ty_param_bounds_and_ty; export ty_param_bounds_and_ty;
@ -92,7 +92,7 @@ export ty_evec, mk_evec;
export ty_unboxed_vec, mk_unboxed_vec, mk_mut_unboxed_vec; export ty_unboxed_vec, mk_unboxed_vec, mk_mut_unboxed_vec;
export vstore, vstore_fixed, vstore_uniq, vstore_box, vstore_slice; export vstore, vstore_fixed, vstore_uniq, vstore_box, vstore_slice;
export ty_nil, mk_nil, type_is_nil; export ty_nil, mk_nil, type_is_nil;
export ty_iface, mk_iface; export ty_trait, mk_trait;
export ty_param, mk_param, ty_params_to_tys; export ty_param, mk_param, ty_params_to_tys;
export ty_ptr, mk_ptr, mk_mut_ptr, mk_imm_ptr, mk_nil_ptr, type_is_unsafe_ptr; export ty_ptr, mk_ptr, mk_mut_ptr, mk_imm_ptr, mk_nil_ptr, type_is_unsafe_ptr;
export ty_rptr, mk_rptr; export ty_rptr, mk_rptr;
@ -154,7 +154,7 @@ export closure_kind;
export ck_block; export ck_block;
export ck_box; export ck_box;
export ck_uniq; export ck_uniq;
export param_bound, param_bounds, bound_copy, bound_send, bound_iface; export param_bound, param_bounds, bound_copy, bound_send, bound_trait;
export param_bounds_to_kind; export param_bounds_to_kind;
export default_arg_mode_for_ty; export default_arg_mode_for_ty;
export item_path; export item_path;
@ -240,7 +240,7 @@ type ctxt =
node_type_substs: hashmap<node_id, ~[t]>, node_type_substs: hashmap<node_id, ~[t]>,
items: ast_map::map, items: ast_map::map,
intrinsic_ifaces: hashmap<ast::ident, (ast::def_id, t)>, intrinsic_traits: hashmap<ast::ident, (ast::def_id, t)>,
freevars: freevars::freevar_map, freevars: freevars::freevar_map,
tcache: type_cache, tcache: type_cache,
rcache: creader_cache, rcache: creader_cache,
@ -250,7 +250,7 @@ type ctxt =
kind_cache: hashmap<t, kind>, kind_cache: hashmap<t, kind>,
ast_ty_to_ty_cache: hashmap<@ast::ty, ast_ty_to_ty_cache_entry>, ast_ty_to_ty_cache: hashmap<@ast::ty, ast_ty_to_ty_cache_entry>,
enum_var_cache: hashmap<def_id, @~[variant_info]>, enum_var_cache: hashmap<def_id, @~[variant_info]>,
iface_method_cache: hashmap<def_id, @~[method]>, trait_method_cache: hashmap<def_id, @~[method]>,
ty_param_bounds: hashmap<ast::node_id, param_bounds>, ty_param_bounds: hashmap<ast::node_id, param_bounds>,
inferred_modes: hashmap<ast::node_id, ast::mode>, inferred_modes: hashmap<ast::node_id, ast::mode>,
// maps the id of borrowed expr to scope of borrowed ptr // maps the id of borrowed expr to scope of borrowed ptr
@ -366,7 +366,7 @@ enum sty {
ty_rptr(region, mt), ty_rptr(region, mt),
ty_rec(~[field]), ty_rec(~[field]),
ty_fn(fn_ty), ty_fn(fn_ty),
ty_iface(def_id, substs), ty_trait(def_id, substs),
ty_class(def_id, substs), ty_class(def_id, substs),
ty_tup(~[t]), ty_tup(~[t]),
@ -426,7 +426,7 @@ enum param_bound {
bound_copy, bound_copy,
bound_send, bound_send,
bound_const, bound_const,
bound_iface(t), bound_trait(t),
} }
enum tv_vid = uint; enum tv_vid = uint;
@ -468,7 +468,7 @@ fn param_bounds_to_kind(bounds: param_bounds) -> kind {
} }
bound_send { kind = raise_kind(kind, kind_send_only()); } bound_send { kind = raise_kind(kind, kind_send_only()); }
bound_const { kind = raise_kind(kind, kind_const()); } bound_const { kind = raise_kind(kind, kind_const()); }
bound_iface(_) {} bound_trait(_) {}
} }
} }
kind kind
@ -519,7 +519,7 @@ fn mk_ctxt(s: session::session, dm: resolve::def_map, amap: ast_map::map,
node_types: @smallintmap::mk(), node_types: @smallintmap::mk(),
node_type_substs: map::int_hash(), node_type_substs: map::int_hash(),
items: amap, items: amap,
intrinsic_ifaces: map::box_str_hash(), intrinsic_traits: map::box_str_hash(),
freevars: freevars, freevars: freevars,
tcache: ast_util::new_def_hash(), tcache: ast_util::new_def_hash(),
rcache: mk_rcache(), rcache: mk_rcache(),
@ -530,7 +530,7 @@ fn mk_ctxt(s: session::session, dm: resolve::def_map, amap: ast_map::map,
ast_ty_to_ty_cache: map::hashmap( ast_ty_to_ty_cache: map::hashmap(
ast_util::hash_ty, ast_util::eq_ty), ast_util::hash_ty, ast_util::eq_ty),
enum_var_cache: new_def_hash(), enum_var_cache: new_def_hash(),
iface_method_cache: new_def_hash(), trait_method_cache: new_def_hash(),
ty_param_bounds: map::int_hash(), ty_param_bounds: map::int_hash(),
inferred_modes: map::int_hash(), inferred_modes: map::int_hash(),
borrowings: map::int_hash(), borrowings: map::int_hash(),
@ -578,7 +578,7 @@ fn mk_t_with_id(cx: ctxt, st: sty, o_def_id: option<ast::def_id>) -> t {
ty_param(_, _) { flags |= has_params as uint; } ty_param(_, _) { flags |= has_params as uint; }
ty_var(_) | ty_var_integral(_) { flags |= needs_infer as uint; } ty_var(_) | ty_var_integral(_) { flags |= needs_infer as uint; }
ty_self { flags |= has_self as uint; } ty_self { flags |= has_self as uint; }
ty_enum(_, substs) | ty_class(_, substs) | ty_iface(_, substs) { ty_enum(_, substs) | ty_class(_, substs) | ty_trait(_, substs) {
flags |= sflags(substs); flags |= sflags(substs);
} }
ty_box(m) | ty_uniq(m) | ty_vec(m) | ty_evec(m, _) | ty_box(m) | ty_uniq(m) | ty_vec(m) | ty_evec(m, _) |
@ -704,8 +704,8 @@ fn mk_tup(cx: ctxt, ts: ~[t]) -> t { mk_t(cx, ty_tup(ts)) }
fn mk_fn(cx: ctxt, fty: fn_ty) -> t { mk_t(cx, ty_fn(fty)) } fn mk_fn(cx: ctxt, fty: fn_ty) -> t { mk_t(cx, ty_fn(fty)) }
fn mk_iface(cx: ctxt, did: ast::def_id, substs: substs) -> t { fn mk_trait(cx: ctxt, did: ast::def_id, substs: substs) -> t {
mk_t(cx, ty_iface(did, substs)) mk_t(cx, ty_trait(did, substs))
} }
fn mk_class(cx: ctxt, class_id: ast::def_id, substs: substs) -> t { fn mk_class(cx: ctxt, class_id: ast::def_id, substs: substs) -> t {
@ -775,7 +775,7 @@ fn maybe_walk_ty(ty: t, f: fn(t) -> bool) {
maybe_walk_ty(tm.ty, f); maybe_walk_ty(tm.ty, f);
} }
ty_enum(_, substs) | ty_class(_, substs) | ty_enum(_, substs) | ty_class(_, substs) |
ty_iface(_, substs) { ty_trait(_, substs) {
for substs.tps.each |subty| { maybe_walk_ty(subty, f); } for substs.tps.each |subty| { maybe_walk_ty(subty, f); }
} }
ty_rec(fields) { ty_rec(fields) {
@ -824,8 +824,8 @@ fn fold_sty(sty: sty, fldop: fn(t) -> t) -> sty {
ty_enum(tid, substs) { ty_enum(tid, substs) {
ty_enum(tid, fold_substs(substs, fldop)) ty_enum(tid, fold_substs(substs, fldop))
} }
ty_iface(did, substs) { ty_trait(did, substs) {
ty_iface(did, fold_substs(substs, fldop)) ty_trait(did, fold_substs(substs, fldop))
} }
ty_rec(fields) { ty_rec(fields) {
let new_fields = do vec::map(fields) |fl| { let new_fields = do vec::map(fields) |fl| {
@ -924,8 +924,8 @@ fn fold_regions_and_ty(
ty_class(def_id, substs) { ty_class(def_id, substs) {
ty::mk_class(cx, def_id, fold_substs(substs, fldr, fldt)) ty::mk_class(cx, def_id, fold_substs(substs, fldr, fldt))
} }
ty_iface(def_id, substs) { ty_trait(def_id, substs) {
ty::mk_iface(cx, def_id, fold_substs(substs, fldr, fldt)) ty::mk_trait(cx, def_id, fold_substs(substs, fldr, fldt))
} }
sty @ ty_fn(_) { sty @ ty_fn(_) {
fold_sty_to_ty(cx, sty, |t| fldfnt(t)) fold_sty_to_ty(cx, sty, |t| fldfnt(t))
@ -1074,7 +1074,7 @@ fn type_is_bool(ty: t) -> bool { get(ty).struct == ty_bool }
fn type_is_structural(ty: t) -> bool { fn type_is_structural(ty: t) -> bool {
alt get(ty).struct { alt get(ty).struct {
ty_rec(_) | ty_class(*) | ty_tup(_) | ty_enum(*) | ty_fn(_) | ty_rec(_) | ty_class(*) | ty_tup(_) | ty_enum(*) | ty_fn(_) |
ty_iface(*) | ty_evec(_, vstore_fixed(_)) ty_trait(*) | ty_evec(_, vstore_fixed(_))
| ty_estr(vstore_fixed(_)) { true } | ty_estr(vstore_fixed(_)) { true }
_ { false } _ { false }
} }
@ -1497,7 +1497,7 @@ fn type_kind(cx: ctxt, ty: t) -> kind {
else { kind_implicitly_copyable() } else { kind_implicitly_copyable() }
} }
} }
ty_iface(_, _) { kind_implicitly_copyable() } ty_trait(_, _) { kind_implicitly_copyable() }
ty_rptr(_, _) { kind_implicitly_copyable() } ty_rptr(_, _) { kind_implicitly_copyable() }
// Unique boxes and vecs have the kind of their contained type, // Unique boxes and vecs have the kind of their contained type,
@ -1669,7 +1669,7 @@ fn is_instantiable(cx: ctxt, r_ty: t) -> bool {
} }
} }
ty_iface(_, _) { ty_trait(_, _) {
false false
} }
@ -1834,7 +1834,7 @@ fn type_is_pod(cx: ctxt, ty: t) -> bool {
ty_str | ty_box(_) | ty_uniq(_) | ty_vec(_) | ty_fn(_) | ty_str | ty_box(_) | ty_uniq(_) | ty_vec(_) | ty_fn(_) |
ty_estr(vstore_uniq) | ty_estr(vstore_box) | ty_estr(vstore_uniq) | ty_estr(vstore_box) |
ty_evec(_, vstore_uniq) | ty_evec(_, vstore_box) | ty_evec(_, vstore_uniq) | ty_evec(_, vstore_box) |
ty_iface(_, _) | ty_rptr(_,_) | ty_opaque_box { result = false; } ty_trait(_, _) | ty_rptr(_,_) | ty_opaque_box { result = false; }
// Structural types // Structural types
ty_enum(did, substs) { ty_enum(did, substs) {
let variants = enum_variants(cx, did); let variants = enum_variants(cx, did);
@ -2066,7 +2066,7 @@ fn hash_type_structure(st: sty) -> uint {
h h
} }
ty_uniq(mt) { hash_subty(37u, mt.ty) } ty_uniq(mt) { hash_subty(37u, mt.ty) }
ty_iface(did, substs) { ty_trait(did, substs) {
let mut h = hash_def(40u, did); let mut h = hash_def(40u, did);
hash_substs(h, substs) hash_substs(h, substs)
} }
@ -2402,7 +2402,7 @@ fn ty_sort_str(cx: ctxt, t: t) -> str {
ty_rptr(_, _) { "&-ptr" } ty_rptr(_, _) { "&-ptr" }
ty_rec(_) { "record" } ty_rec(_) { "record" }
ty_fn(_) { "fn" } ty_fn(_) { "fn" }
ty_iface(id, _) { #fmt["iface %s", item_path_str(cx, id)] } ty_trait(id, _) { #fmt["trait %s", item_path_str(cx, id)] }
ty_class(id, _) { #fmt["class %s", item_path_str(cx, id)] } ty_class(id, _) { #fmt["class %s", item_path_str(cx, id)] }
ty_tup(_) { "tuple" } ty_tup(_) { "tuple" }
ty_var(_) { "variable" } ty_var(_) { "variable" }
@ -2513,25 +2513,25 @@ fn def_has_ty_params(def: ast::def) -> bool {
} }
} }
fn store_iface_methods(cx: ctxt, id: ast::node_id, ms: @~[method]) { fn store_trait_methods(cx: ctxt, id: ast::node_id, ms: @~[method]) {
cx.iface_method_cache.insert(ast_util::local_def(id), ms); cx.trait_method_cache.insert(ast_util::local_def(id), ms);
} }
fn iface_methods(cx: ctxt, id: ast::def_id) -> @~[method] { fn trait_methods(cx: ctxt, id: ast::def_id) -> @~[method] {
alt cx.iface_method_cache.find(id) { alt cx.trait_method_cache.find(id) {
some(ms) { ret ms; } some(ms) { ret ms; }
_ {} _ {}
} }
// Local interfaces are supposed to have been added explicitly. // Local interfaces are supposed to have been added explicitly.
assert id.crate != ast::local_crate; assert id.crate != ast::local_crate;
let result = csearch::get_iface_methods(cx, id); let result = csearch::get_trait_methods(cx, id);
cx.iface_method_cache.insert(id, result); cx.trait_method_cache.insert(id, result);
result result
} }
fn impl_iface(cx: ctxt, id: ast::def_id) -> option<t> { fn impl_trait(cx: ctxt, id: ast::def_id) -> option<t> {
if id.crate == ast::local_crate { if id.crate == ast::local_crate {
#debug("(impl_iface) searching for iface impl %?", id); #debug("(impl_trait) searching for trait impl %?", id);
alt cx.items.find(id.node) { alt cx.items.find(id.node) {
some(ast_map::node_item(@{node: ast::item_impl( some(ast_map::node_item(@{node: ast::item_impl(
_, _, some(@{id: id, _}), _, _), _}, _)) { _, _, some(@{id: id, _}), _, _), _}, _)) {
@ -2540,13 +2540,13 @@ fn impl_iface(cx: ctxt, id: ast::def_id) -> option<t> {
some(ast_map::node_item(@{node: ast::item_class(_, _, _, _, _, _), some(ast_map::node_item(@{node: ast::item_class(_, _, _, _, _, _),
_},_)) { _},_)) {
alt cx.def_map.find(id.node) { alt cx.def_map.find(id.node) {
some(def_ty(iface_id)) { some(def_ty(trait_id)) {
// XXX: Doesn't work cross-crate. // XXX: Doesn't work cross-crate.
#debug("(impl_iface) found iface id %?", iface_id); #debug("(impl_trait) found trait id %?", trait_id);
some(node_id_to_type(cx, iface_id.node)) some(node_id_to_type(cx, trait_id.node))
} }
some(x) { some(x) {
cx.sess.bug(#fmt("impl_iface: iface ref is in iface map \ cx.sess.bug(#fmt("impl_trait: trait ref is in trait map \
but is bound to %?", x)); but is bound to %?", x));
} }
none { none {
@ -2557,13 +2557,13 @@ fn impl_iface(cx: ctxt, id: ast::def_id) -> option<t> {
_ { none } _ { none }
} }
} else { } else {
csearch::get_impl_iface(cx, id) csearch::get_impl_trait(cx, id)
} }
} }
fn ty_to_def_id(ty: t) -> option<ast::def_id> { fn ty_to_def_id(ty: t) -> option<ast::def_id> {
alt get(ty).struct { alt get(ty).struct {
ty_iface(id, _) | ty_class(id, _) | ty_enum(id, _) { ty_trait(id, _) | ty_class(id, _) | ty_enum(id, _) {
some(id) some(id)
} }
_ { none } _ { none }

22
src/rustc/middle/typeck.rs
View File

@ -5,7 +5,7 @@ typeck.rs, an introduction
The type checker is responsible for: The type checker is responsible for:
1. Determining the type of each expression 1. Determining the type of each expression
2. Resolving methods and ifaces 2. Resolving methods and traits
3. Guaranteeing that most type rules are met ("most?", you say, "why most?" 3. Guaranteeing that most type rules are met ("most?", you say, "why most?"
Well, dear reader, read on) Well, dear reader, read on)
@ -81,28 +81,28 @@ enum method_origin {
// fully statically resolved method // fully statically resolved method
method_static(ast::def_id), method_static(ast::def_id),
// method invoked on a type parameter with a bounded iface // method invoked on a type parameter with a bounded trait
method_param(method_param), method_param(method_param),
// method invoked on a boxed iface // method invoked on a boxed trait
method_iface(ast::def_id, uint), method_trait(ast::def_id, uint),
} }
// details for a method invoked with a receiver whose type is a type parameter // details for a method invoked with a receiver whose type is a type parameter
// with a bounded iface. // with a bounded trait.
#[auto_serialize] #[auto_serialize]
type method_param = { type method_param = {
// the iface containing the method to be invoked // the trait containing the method to be invoked
iface_id: ast::def_id, trait_id: ast::def_id,
// index of the method to be invoked amongst the iface's methods // index of the method to be invoked amongst the trait's methods
method_num: uint, method_num: uint,
// index of the type parameter (from those that are in scope) that is // index of the type parameter (from those that are in scope) that is
// the type of the receiver // the type of the receiver
param_num: uint, param_num: uint,
// index of the bound for this type parameter which specifies the iface // index of the bound for this type parameter which specifies the trait
bound_num: uint bound_num: uint
}; };
@ -140,9 +140,9 @@ enum vtable_origin {
vtable_param(uint, uint), vtable_param(uint, uint),
/* /*
Dynamic vtable, comes from something known to have an interface Dynamic vtable, comes from something known to have an interface
type. def_id refers to the iface item, tys are the substs type. def_id refers to the trait item, tys are the substs
*/ */
vtable_iface(ast::def_id, ~[ty::t]), vtable_trait(ast::def_id, ~[ty::t]),
} }
type vtable_map = hashmap<ast::node_id, vtable_res>; type vtable_map = hashmap<ast::node_id, vtable_res>;

6
src/rustc/middle/typeck/astconv.rs
View File

@ -21,7 +21,7 @@
* region, or `type_rscope`, which permits the self region if the type in * region, or `type_rscope`, which permits the self region if the type in
* question is parameterized by a region. * question is parameterized by a region.
* *
* Unlike the `ast_conv` iface, the region scope can change as we descend * Unlike the `ast_conv` trait, the region scope can change as we descend
* the type. This is to accommodate the fact that (a) fn types are binding * the type. This is to accommodate the fact that (a) fn types are binding
* scopes and (b) the default region may change. To understand case (a), * scopes and (b) the default region may change. To understand case (a),
* consider something like: * consider something like:
@ -304,8 +304,8 @@ fn ast_ty_to_ty<AC: ast_conv, RS: region_scope copy>(
ty::mk_param(tcx, n, id) ty::mk_param(tcx, n, id)
} }
ast::def_self(_) { ast::def_self(_) {
// n.b.: resolve guarantees that the self type only appears in an // n.b.: resolve guarantees that the self type only appears in a
// iface, which we rely upon in various places when creating // trait, which we rely upon in various places when creating
// substs // substs
check_path_args(tcx, path, NO_TPS | NO_REGIONS); check_path_args(tcx, path, NO_TPS | NO_REGIONS);
ty::mk_self(tcx) ty::mk_self(tcx)

18
src/rustc/middle/typeck/check.rs
View File

@ -30,7 +30,7 @@ can be broken down into several distinct phases:
final assignments of the various region variables if there is some final assignments of the various region variables if there is some
flexibility. flexibility.
- vtable: find and records the impls to use for each iface bound that - vtable: find and records the impls to use for each trait bound that
appears on a type parameter. appears on a type parameter.
- writeback: writes the final types within a function body, replacing - writeback: writes the final types within a function body, replacing
@ -358,7 +358,7 @@ fn check_item(ccx: @crate_ctxt, it: @ast::item) {
let self_ty = ccx.to_ty(rscope::type_rscope(rp), ty); let self_ty = ccx.to_ty(rscope::type_rscope(rp), ty);
for ms.each |m| { check_method(ccx, m, self_ty);} for ms.each |m| { check_method(ccx, m, self_ty);}
} }
ast::item_class(tps, ifaces, members, ctor, m_dtor, rp) { ast::item_class(tps, traits, members, ctor, m_dtor, rp) {
let tcx = ccx.tcx; let tcx = ccx.tcx;
let class_t = ty::node_id_to_type(tcx, it.id); let class_t = ty::node_id_to_type(tcx, it.id);
// typecheck the ctor // typecheck the ctor
@ -1090,8 +1090,8 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
// Something of a hack: special rules for comparison operators that // Something of a hack: special rules for comparison operators that
// simply unify LHS and RHS. This helps with inference as LHS and RHS // simply unify LHS and RHS. This helps with inference as LHS and RHS
// do not need to be "resolvable". Some tests, particularly those with // do not need to be "resolvable". Some tests, particularly those with
// complicated iface requirements, fail without this---I think this code // complicated trait requirements, fail without this---I think this code
// can be removed if we improve iface resolution to be more eager when // can be removed if we improve trait resolution to be more eager when
// possible. // possible.
ast::expr_binary(ast::eq, lhs, rhs) | ast::expr_binary(ast::eq, lhs, rhs) |
ast::expr_binary(ast::ne, lhs, rhs) | ast::expr_binary(ast::ne, lhs, rhs) |
@ -1392,7 +1392,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
alt ty::get(t_1).struct { alt ty::get(t_1).struct {
// This will be looked up later on // This will be looked up later on
ty::ty_iface(*) {} ty::ty_trait(*) {}
_ { _ {
if ty::type_is_nil(t_e) { if ty::type_is_nil(t_e) {
@ -1518,7 +1518,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
} }
ty::ty_class(base_id, substs) { ty::ty_class(base_id, substs) {
// This is just for fields -- the same code handles // This is just for fields -- the same code handles
// methods in both classes and ifaces // methods in both classes and traits
// (1) verify that the class id actually has a field called // (1) verify that the class id actually has a field called
// field // field
@ -2259,9 +2259,9 @@ fn check_intrinsic_type(ccx: @crate_ctxt, it: @ast::foreign_item) {
} }
"visit_ty" { "visit_ty" {
assert ccx.tcx.intrinsic_ifaces.contains_key(@"ty_visitor"); assert ccx.tcx.intrinsic_traits.contains_key(@"ty_visitor");
let (_, visitor_iface) = ccx.tcx.intrinsic_ifaces.get(@"ty_visitor"); let (_, visitor_trait) = ccx.tcx.intrinsic_traits.get(@"ty_visitor");
(1u, ~[arg(ast::by_ref, visitor_iface)], ty::mk_nil(tcx)) (1u, ~[arg(ast::by_ref, visitor_trait)], ty::mk_nil(tcx))
} }
"frame_address" { "frame_address" {
let fty = ty::mk_fn(ccx.tcx, { let fty = ty::mk_fn(ccx.tcx, {

48
src/rustc/middle/typeck/check/method.rs
View File

@ -64,8 +64,8 @@ class lookup {
ty::ty_param(n, did) { ty::ty_param(n, did) {
self.add_candidates_from_param(n, did); self.add_candidates_from_param(n, did);
} }
ty::ty_iface(did, substs) { ty::ty_trait(did, substs) {
self.add_candidates_from_iface(did, substs); self.add_candidates_from_trait(did, substs);
} }
ty::ty_class(did, substs) { ty::ty_class(did, substs) {
self.add_candidates_from_class(did, substs); self.add_candidates_from_class(did, substs);
@ -111,10 +111,10 @@ class lookup {
self.report_static_candidate(i, did); self.report_static_candidate(i, did);
} }
method_param(p) { method_param(p) {
self.report_param_candidate(i, p.iface_id); self.report_param_candidate(i, p.trait_id);
} }
method_iface(did, _) { method_trait(did, _) {
self.report_iface_candidate(i, did); self.report_trait_candidate(i, did);
} }
} }
} }
@ -148,11 +148,11 @@ class lookup {
ty::item_path_str(self.tcx(), did)]); ty::item_path_str(self.tcx(), did)]);
} }
fn report_iface_candidate(idx: uint, did: ast::def_id) { fn report_trait_candidate(idx: uint, did: ast::def_id) {
self.tcx().sess.span_note( self.tcx().sess.span_note(
self.expr.span, self.expr.span,
#fmt["candidate #%u derives from the type of the receiver, \ #fmt["candidate #%u derives from the type of the receiver, \
which is the iface `%s`", which is the trait `%s`",
(idx+1u), (idx+1u),
ty::item_path_str(self.tcx(), did)]); ty::item_path_str(self.tcx(), did)]);
} }
@ -161,25 +161,25 @@ class lookup {
#debug["candidates_from_param"]; #debug["candidates_from_param"];
let tcx = self.tcx(); let tcx = self.tcx();
let mut iface_bnd_idx = 0u; // count only iface bounds let mut trait_bnd_idx = 0u; // count only trait bounds
let bounds = tcx.ty_param_bounds.get(did.node); let bounds = tcx.ty_param_bounds.get(did.node);
for vec::each(*bounds) |bound| { for vec::each(*bounds) |bound| {
let (iid, bound_substs) = alt bound { let (iid, bound_substs) = alt bound {
ty::bound_copy | ty::bound_send | ty::bound_const { ty::bound_copy | ty::bound_send | ty::bound_const {
cont; /* ok */ cont; /* ok */
} }
ty::bound_iface(bound_t) { ty::bound_trait(bound_t) {
alt check ty::get(bound_t).struct { alt check ty::get(bound_t).struct {
ty::ty_iface(i, substs) { (i, substs) } ty::ty_trait(i, substs) { (i, substs) }
} }
} }
}; };
let ifce_methods = ty::iface_methods(tcx, iid); let ifce_methods = ty::trait_methods(tcx, iid);
alt vec::position(*ifce_methods, |m| m.ident == self.m_name) { alt vec::position(*ifce_methods, |m| m.ident == self.m_name) {
none { none {
/* check next bound */ /* check next bound */
iface_bnd_idx += 1u; trait_bnd_idx += 1u;
} }
some(pos) { some(pos) {
@ -187,7 +187,7 @@ class lookup {
// generic parameter itself. Note that this is the only case // generic parameter itself. Note that this is the only case
// where this replacement is necessary: in all other cases, we // where this replacement is necessary: in all other cases, we
// are either invoking a method directly from an impl or class // are either invoking a method directly from an impl or class
// (where the self type is not permitted), or from a iface // (where the self type is not permitted), or from a trait
// type (in which case methods that refer to self are not // type (in which case methods that refer to self are not
// permitted). // permitted).
let substs = {self_ty: some(self.self_ty) let substs = {self_ty: some(self.self_ty)
@ -195,21 +195,21 @@ class lookup {
self.add_candidates_from_m( self.add_candidates_from_m(
substs, ifce_methods[pos], substs, ifce_methods[pos],
method_param({iface_id:iid, method_param({trait_id:iid,
method_num:pos, method_num:pos,
param_num:n, param_num:n,
bound_num:iface_bnd_idx})); bound_num:trait_bnd_idx}));
} }
} }
} }
} }
fn add_candidates_from_iface(did: ast::def_id, iface_substs: ty::substs) { fn add_candidates_from_trait(did: ast::def_id, trait_substs: ty::substs) {
#debug["method_from_iface"]; #debug["method_from_trait"];
let ms = *ty::iface_methods(self.tcx(), did); let ms = *ty::trait_methods(self.tcx(), did);
for ms.eachi |i, m| { for ms.eachi |i, m| {
if m.ident != self.m_name { cont; } if m.ident != self.m_name { cont; }
@ -226,17 +226,17 @@ class lookup {
self.tcx().sess.span_err( self.tcx().sess.span_err(
self.expr.span, self.expr.span,
"can not call a generic method through a \ "can not call a generic method through a \
boxed iface"); boxed trait");
} }
// Note: although it is illegal to invoke a method that uses self // Note: although it is illegal to invoke a method that uses self
// through a iface instance, we use a dummy subst here so that we // through a trait instance, we use a dummy subst here so that we
// can soldier on with the compilation. // can soldier on with the compilation.
let substs = {self_ty: some(self.self_ty) let substs = {self_ty: some(self.self_ty)
with iface_substs}; with trait_substs};
self.add_candidates_from_m( self.add_candidates_from_m(
substs, m, method_iface(did, i)); substs, m, method_trait(did, i));
} }
} }
@ -244,7 +244,7 @@ class lookup {
#debug["method_from_class"]; #debug["method_from_class"];
let ms = *ty::iface_methods(self.tcx(), did); let ms = *ty::trait_methods(self.tcx(), did);
for ms.each |m| { for ms.each |m| {
if m.ident != self.m_name { cont; } if m.ident != self.m_name { cont; }
@ -275,7 +275,7 @@ class lookup {
if did.crate == ast::local_crate { if did.crate == ast::local_crate {
alt check self.tcx().items.get(did.node) { alt check self.tcx().items.get(did.node) {
ast_map::node_method(m, _, _) { ast_map::node_method(m, _, _) {
// NDM iface/impl regions // NDM trait/impl regions
let mt = ty_of_method(self.fcx.ccx, m, ast::rp_none); let mt = ty_of_method(self.fcx.ccx, m, ast::rp_none);
ty::mk_fn(self.tcx(), {proto: ast::proto_box with mt.fty}) ty::mk_fn(self.tcx(), {proto: ast::proto_box with mt.fty})
} }

96
src/rustc/middle/typeck/check/vtable.rs
View File

@ -1,9 +1,9 @@
import check::{fn_ctxt, impl_self_ty, methods}; import check::{fn_ctxt, impl_self_ty, methods};
fn has_iface_bounds(tps: ~[ty::param_bounds]) -> bool { fn has_trait_bounds(tps: ~[ty::param_bounds]) -> bool {
vec::any(tps, |bs| { vec::any(tps, |bs| {
vec::any(*bs, |b| { vec::any(*bs, |b| {
alt b { ty::bound_iface(_) { true } _ { false } } alt b { ty::bound_trait(_) { true } _ { false } }
}) })
}) })
} }
@ -16,7 +16,7 @@ fn lookup_vtables(fcx: @fn_ctxt, isc: resolve::iscopes, sp: span,
for substs.tps.each |ty| { for substs.tps.each |ty| {
for vec::each(*bounds[i]) |bound| { for vec::each(*bounds[i]) |bound| {
alt bound { alt bound {
ty::bound_iface(i_ty) { ty::bound_trait(i_ty) {
let i_ty = ty::subst(tcx, substs, i_ty); let i_ty = ty::subst(tcx, substs, i_ty);
vec::push(result, lookup_vtable(fcx, isc, sp, ty, i_ty, vec::push(result, lookup_vtable(fcx, isc, sp, ty, i_ty,
allow_unsafe)); allow_unsafe));
@ -33,33 +33,33 @@ fn fixup_substs(fcx: @fn_ctxt, sp: span,
id: ast::def_id, substs: ty::substs) -> ty::substs { id: ast::def_id, substs: ty::substs) -> ty::substs {
let tcx = fcx.ccx.tcx; let tcx = fcx.ccx.tcx;
// use a dummy type just to package up the substs that need fixing up // use a dummy type just to package up the substs that need fixing up
let t = ty::mk_iface(tcx, id, substs); let t = ty::mk_trait(tcx, id, substs);
let t_f = fixup_ty(fcx, sp, t); let t_f = fixup_ty(fcx, sp, t);
alt check ty::get(t_f).struct { alt check ty::get(t_f).struct {
ty::ty_iface(_, substs_f) { substs_f } ty::ty_trait(_, substs_f) { substs_f }
} }
} }
fn relate_iface_tys(fcx: @fn_ctxt, sp: span, fn relate_trait_tys(fcx: @fn_ctxt, sp: span,
exp_iface_ty: ty::t, act_iface_ty: ty::t) { exp_trait_ty: ty::t, act_trait_ty: ty::t) {
demand::suptype(fcx, sp, exp_iface_ty, act_iface_ty) demand::suptype(fcx, sp, exp_trait_ty, act_trait_ty)
} }
/* /*
Look up the vtable to use when treating an item of type <t> Look up the vtable to use when treating an item of type <t>
as if it has type <iface_ty> as if it has type <trait_ty>
*/ */
fn lookup_vtable(fcx: @fn_ctxt, isc: resolve::iscopes, sp: span, fn lookup_vtable(fcx: @fn_ctxt, isc: resolve::iscopes, sp: span,
ty: ty::t, iface_ty: ty::t, allow_unsafe: bool) ty: ty::t, trait_ty: ty::t, allow_unsafe: bool)
-> vtable_origin { -> vtable_origin {
#debug["lookup_vtable(ty=%s, iface_ty=%s)", #debug["lookup_vtable(ty=%s, trait_ty=%s)",
fcx.infcx.ty_to_str(ty), fcx.infcx.ty_to_str(iface_ty)]; fcx.infcx.ty_to_str(ty), fcx.infcx.ty_to_str(trait_ty)];
let _i = indenter(); let _i = indenter();
let tcx = fcx.ccx.tcx; let tcx = fcx.ccx.tcx;
let (iface_id, iface_substs) = alt check ty::get(iface_ty).struct { let (trait_id, trait_substs) = alt check ty::get(trait_ty).struct {
ty::ty_iface(did, substs) { (did, substs) } ty::ty_trait(did, substs) { (did, substs) }
}; };
let ty = fixup_ty(fcx, sp, ty); let ty = fixup_ty(fcx, sp, ty);
alt ty::get(ty).struct { alt ty::get(ty).struct {
@ -70,13 +70,13 @@ fn lookup_vtable(fcx: @fn_ctxt, isc: resolve::iscopes, sp: span,
ty::bound_send | ty::bound_copy | ty::bound_const { ty::bound_send | ty::bound_copy | ty::bound_const {
/* ignore */ /* ignore */
} }
ty::bound_iface(ity) { ty::bound_trait(ity) {
alt check ty::get(ity).struct { alt check ty::get(ity).struct {
ty::ty_iface(idid, substs) { ty::ty_trait(idid, substs) {
if iface_id == idid { if trait_id == idid {
#debug("(checking vtable) @0 relating ty to iface ty #debug("(checking vtable) @0 relating ty to trait ty
with did %?", idid); with did %?", idid);
relate_iface_tys(fcx, sp, iface_ty, ity); relate_trait_tys(fcx, sp, trait_ty, ity);
ret vtable_param(n, n_bound); ret vtable_param(n, n_bound);
} }
} }
@ -87,13 +87,13 @@ fn lookup_vtable(fcx: @fn_ctxt, isc: resolve::iscopes, sp: span,
} }
} }
ty::ty_iface(did, substs) if iface_id == did { ty::ty_trait(did, substs) if trait_id == did {
#debug("(checking vtable) @1 relating ty to iface ty with did %?", #debug("(checking vtable) @1 relating ty to trait ty with did %?",
did); did);
relate_iface_tys(fcx, sp, iface_ty, ty); relate_trait_tys(fcx, sp, trait_ty, ty);
if !allow_unsafe { if !allow_unsafe {
for vec::each(*ty::iface_methods(tcx, did)) |m| { for vec::each(*ty::trait_methods(tcx, did)) |m| {
if ty::type_has_self(ty::mk_fn(tcx, m.fty)) { if ty::type_has_self(ty::mk_fn(tcx, m.fty)) {
tcx.sess.span_err( tcx.sess.span_err(
sp, "a boxed iface with self types may not be \ sp, "a boxed iface with self types may not be \
@ -106,7 +106,7 @@ fn lookup_vtable(fcx: @fn_ctxt, isc: resolve::iscopes, sp: span,
} }
} }
} }
ret vtable_iface(did, substs.tps); ret vtable_trait(did, substs.tps);
} }
_ { _ {
@ -116,15 +116,15 @@ fn lookup_vtable(fcx: @fn_ctxt, isc: resolve::iscopes, sp: span,
/* For each impl in scope... */ /* For each impl in scope... */
for vec::each(*impls) |im| { for vec::each(*impls) |im| {
// im = one specific impl // im = one specific impl
// find the iface that im implements (if any) // find the trait that im implements (if any)
let of_ty = alt ty::impl_iface(tcx, im.did) { let of_ty = alt ty::impl_trait(tcx, im.did) {
some(of_ty) { of_ty } some(of_ty) { of_ty }
_ { cont; } _ { cont; }
}; };
// it must have the same id as the expected one // it must have the same id as the expected one
alt ty::get(of_ty).struct { alt ty::get(of_ty).struct {
ty::ty_iface(id, _) if id != iface_id { cont; } ty::ty_trait(id, _) if id != trait_id { cont; }
_ { /* ok */ } _ { /* ok */ }
} }
@ -138,19 +138,19 @@ fn lookup_vtable(fcx: @fn_ctxt, isc: resolve::iscopes, sp: span,
result::ok(()) { } result::ok(()) { }
} }
// check that desired iface type unifies // check that desired trait type unifies
#debug("(checking vtable) @2 relating iface ty %s to \ #debug("(checking vtable) @2 relating trait ty %s to \
of_ty %s", of_ty %s",
fcx.infcx.ty_to_str(iface_ty), fcx.infcx.ty_to_str(trait_ty),
fcx.infcx.ty_to_str(of_ty)); fcx.infcx.ty_to_str(of_ty));
let of_ty = ty::subst(tcx, substs, of_ty); let of_ty = ty::subst(tcx, substs, of_ty);
relate_iface_tys(fcx, sp, iface_ty, of_ty); relate_trait_tys(fcx, sp, trait_ty, of_ty);
// recursively process the bounds // recursively process the bounds
let iface_tps = iface_substs.tps; let trait_tps = trait_substs.tps;
let substs_f = fixup_substs(fcx, sp, iface_id, substs); let substs_f = fixup_substs(fcx, sp, trait_id, substs);
connect_iface_tps(fcx, sp, substs_f.tps, connect_trait_tps(fcx, sp, substs_f.tps,
iface_tps, im.did); trait_tps, im.did);
let subres = lookup_vtables(fcx, isc, sp, let subres = lookup_vtables(fcx, isc, sp,
im_bs, substs_f, false); im_bs, substs_f, false);
vec::push(found, vec::push(found,
@ -172,7 +172,7 @@ fn lookup_vtable(fcx: @fn_ctxt, isc: resolve::iscopes, sp: span,
tcx.sess.span_fatal( tcx.sess.span_fatal(
sp, "failed to find an implementation of interface " + sp, "failed to find an implementation of interface " +
ty_to_str(tcx, iface_ty) + " for " + ty_to_str(tcx, trait_ty) + " for " +
ty_to_str(tcx, ty)); ty_to_str(tcx, ty));
} }
@ -190,16 +190,16 @@ fn fixup_ty(fcx: @fn_ctxt, sp: span, ty: ty::t) -> ty::t {
} }
} }
fn connect_iface_tps(fcx: @fn_ctxt, sp: span, impl_tys: ~[ty::t], fn connect_trait_tps(fcx: @fn_ctxt, sp: span, impl_tys: ~[ty::t],
iface_tys: ~[ty::t], impl_did: ast::def_id) { trait_tys: ~[ty::t], impl_did: ast::def_id) {
let tcx = fcx.ccx.tcx; let tcx = fcx.ccx.tcx;
let ity = option::get(ty::impl_iface(tcx, impl_did)); let ity = option::get(ty::impl_trait(tcx, impl_did));
let iface_ty = ty::subst_tps(tcx, impl_tys, ity); let trait_ty = ty::subst_tps(tcx, impl_tys, ity);
#debug("(connect iface tps) iface type is %?, impl did is %?", #debug("(connect trait tps) trait type is %?, impl did is %?",
ty::get(iface_ty).struct, impl_did); ty::get(trait_ty).struct, impl_did);
alt check ty::get(iface_ty).struct { alt check ty::get(trait_ty).struct {
ty::ty_iface(_, substs) { ty::ty_trait(_, substs) {
vec::iter2(substs.tps, iface_tys, vec::iter2(substs.tps, trait_tys,
|a, b| demand::suptype(fcx, sp, a, b)); |a, b| demand::suptype(fcx, sp, a, b));
} }
} }
@ -213,7 +213,7 @@ fn resolve_expr(ex: @ast::expr, &&fcx: @fn_ctxt, v: visit::vt<@fn_ctxt>) {
some(substs) { some(substs) {
let did = ast_util::def_id_of_def(cx.tcx.def_map.get(ex.id)); let did = ast_util::def_id_of_def(cx.tcx.def_map.get(ex.id));
let item_ty = ty::lookup_item_type(cx.tcx, did); let item_ty = ty::lookup_item_type(cx.tcx, did);
if has_iface_bounds(*item_ty.bounds) { if has_trait_bounds(*item_ty.bounds) {
let impls = cx.impl_map.get(ex.id); let impls = cx.impl_map.get(ex.id);
cx.vtable_map.insert(ex.id, lookup_vtables( cx.vtable_map.insert(ex.id, lookup_vtables(
fcx, impls, ex.span, fcx, impls, ex.span,
@ -230,7 +230,7 @@ fn resolve_expr(ex: @ast::expr, &&fcx: @fn_ctxt, v: visit::vt<@fn_ctxt>) {
alt cx.method_map.find(ex.id) { alt cx.method_map.find(ex.id) {
some({origin: method_static(did), _}) { some({origin: method_static(did), _}) {
let bounds = ty::lookup_item_type(cx.tcx, did).bounds; let bounds = ty::lookup_item_type(cx.tcx, did).bounds;
if has_iface_bounds(*bounds) { if has_trait_bounds(*bounds) {
let callee_id = alt ex.node { let callee_id = alt ex.node {
ast::expr_field(_, _, _) { ex.id } ast::expr_field(_, _, _) { ex.id }
_ { ast_util::op_expr_callee_id(ex) } _ { ast_util::op_expr_callee_id(ex) }
@ -247,7 +247,7 @@ fn resolve_expr(ex: @ast::expr, &&fcx: @fn_ctxt, v: visit::vt<@fn_ctxt>) {
ast::expr_cast(src, _) { ast::expr_cast(src, _) {
let target_ty = fcx.expr_ty(ex); let target_ty = fcx.expr_ty(ex);
alt ty::get(target_ty).struct { alt ty::get(target_ty).struct {
ty::ty_iface(*) { ty::ty_trait(*) {
/* Casting to an interface type. /* Casting to an interface type.
Look up all impls for the cast expr... Look up all impls for the cast expr...
*/ */

80
src/rustc/middle/typeck/collect.rs
View File

@ -34,12 +34,12 @@ fn collect_item_types(ccx: @crate_ctxt, crate: @ast::crate) {
ast::item_mod(m) { ast::item_mod(m) {
for m.items.each |intrinsic_item| { for m.items.each |intrinsic_item| {
alt intrinsic_item.node { alt intrinsic_item.node {
ast::item_iface(_, _, _) { ast::item_trait(_, _, _) {
let def_id = { crate: ast::local_crate, let def_id = { crate: ast::local_crate,
node: intrinsic_item.id }; node: intrinsic_item.id };
let substs = {self_r: none, self_ty: none, tps: ~[]}; let substs = {self_r: none, self_ty: none, tps: ~[]};
let ty = ty::mk_iface(ccx.tcx, def_id, substs); let ty = ty::mk_trait(ccx.tcx, def_id, substs);
ccx.tcx.intrinsic_ifaces.insert ccx.tcx.intrinsic_traits.insert
(intrinsic_item.ident, (def_id, ty)); (intrinsic_item.ident, (def_id, ty));
} }
_ { } _ { }
@ -128,15 +128,15 @@ fn get_enum_variant_types(ccx: @crate_ctxt,
} }
} }
fn ensure_iface_methods(ccx: @crate_ctxt, id: ast::node_id) { fn ensure_trait_methods(ccx: @crate_ctxt, id: ast::node_id) {
fn store_methods<T>(ccx: @crate_ctxt, id: ast::node_id, fn store_methods<T>(ccx: @crate_ctxt, id: ast::node_id,
stuff: ~[T], f: fn@(T) -> ty::method) { stuff: ~[T], f: fn@(T) -> ty::method) {
ty::store_iface_methods(ccx.tcx, id, @vec::map(stuff, f)); ty::store_trait_methods(ccx.tcx, id, @vec::map(stuff, f));
} }
let tcx = ccx.tcx; let tcx = ccx.tcx;
alt check tcx.items.get(id) { alt check tcx.items.get(id) {
ast_map::node_item(@{node: ast::item_iface(_, rp, ms), _}, _) { ast_map::node_item(@{node: ast::item_trait(_, rp, ms), _}, _) {
store_methods::<ast::ty_method>(ccx, id, ms, |m| { store_methods::<ast::ty_method>(ccx, id, ms, |m| {
ty_of_ty_method(ccx, m, rp) ty_of_ty_method(ccx, m, rp)
}); });
@ -154,14 +154,14 @@ fn ensure_iface_methods(ccx: @crate_ctxt, id: ast::node_id) {
/** /**
* Checks that a method from an impl/class conforms to the signature of * Checks that a method from an impl/class conforms to the signature of
* the same method as declared in the iface. * the same method as declared in the trait.
* *
* # Parameters * # Parameters
* *
* - impl_m: the method in the impl * - impl_m: the method in the impl
* - impl_tps: the type params declared on the impl itself (not the method!) * - impl_tps: the type params declared on the impl itself (not the method!)
* - if_m: the method in the iface * - if_m: the method in the trait
* - if_substs: the substitutions used on the type of the iface * - if_substs: the substitutions used on the type of the trait
* - self_ty: the self type of the impl * - self_ty: the self type of the impl
*/ */
fn compare_impl_method(tcx: ty::ctxt, sp: span, fn compare_impl_method(tcx: ty::ctxt, sp: span,
@ -184,10 +184,10 @@ fn compare_impl_method(tcx: ty::ctxt, sp: span,
ret; ret;
} }
// Perform substitutions so that the iface/impl methods are expressed // Perform substitutions so that the trait/impl methods are expressed
// in terms of the same set of type/region parameters: // in terms of the same set of type/region parameters:
// - replace iface type parameters with those from `if_substs` // - replace trait type parameters with those from `if_substs`
// - replace method parameters on the iface with fresh, dummy parameters // - replace method parameters on the trait with fresh, dummy parameters
// that correspond to the parameters we will find on the impl // that correspond to the parameters we will find on the impl
// - replace self region with a fresh, dummy region // - replace self region with a fresh, dummy region
let dummy_self_r = ty::re_free(0, ty::br_self); let dummy_self_r = ty::re_free(0, ty::br_self);
@ -223,25 +223,25 @@ fn compare_impl_method(tcx: ty::ctxt, sp: span,
} }
} }
fn check_methods_against_iface(ccx: @crate_ctxt, fn check_methods_against_trait(ccx: @crate_ctxt,
tps: ~[ast::ty_param], tps: ~[ast::ty_param],
rp: ast::region_param, rp: ast::region_param,
selfty: ty::t, selfty: ty::t,
a_ifacety: @ast::iface_ref, a_trait_ty: @ast::trait_ref,
ms: ~[converted_method]) { ms: ~[converted_method]) {
let tcx = ccx.tcx; let tcx = ccx.tcx;
let (did, tpt) = instantiate_iface_ref(ccx, a_ifacety, rp); let (did, tpt) = instantiate_trait_ref(ccx, a_trait_ty, rp);
if did.crate == ast::local_crate { if did.crate == ast::local_crate {
ensure_iface_methods(ccx, did.node); ensure_trait_methods(ccx, did.node);
} }
for vec::each(*ty::iface_methods(tcx, did)) |if_m| { for vec::each(*ty::trait_methods(tcx, did)) |if_m| {
alt vec::find(ms, |m| if_m.ident == m.mty.ident) { alt vec::find(ms, |m| if_m.ident == m.mty.ident) {
some({mty: m, id, span}) { some({mty: m, id, span}) {
if m.purity != if_m.purity { if m.purity != if_m.purity {
ccx.tcx.sess.span_err( ccx.tcx.sess.span_err(
span, #fmt["method `%s`'s purity \ span, #fmt["method `%s`'s purity \
not match the iface method's \ not match the trait method's \
purity", *m.ident]); purity", *m.ident]);
} }
compare_impl_method( compare_impl_method(
@ -250,7 +250,7 @@ fn check_methods_against_iface(ccx: @crate_ctxt,
} }
none { none {
tcx.sess.span_err( tcx.sess.span_err(
a_ifacety.path.span, a_trait_ty.path.span,
#fmt["missing method `%s`", *if_m.ident]); #fmt["missing method `%s`", *if_m.ident]);
} }
} // alt } // alt
@ -314,17 +314,17 @@ fn convert(ccx: @crate_ctxt, it: @ast::item) {
let cms = convert_methods(ccx, ms, rp, i_bounds, selfty); let cms = convert_methods(ccx, ms, rp, i_bounds, selfty);
for ifce.each |t| { for ifce.each |t| {
check_methods_against_iface(ccx, tps, rp, selfty, t, cms); check_methods_against_trait(ccx, tps, rp, selfty, t, cms);
} }
} }
ast::item_iface(*) { ast::item_trait(*) {
let tpt = ty_of_item(ccx, it); let tpt = ty_of_item(ccx, it);
#debug["item_iface(it.id=%d, tpt.ty=%s)", #debug["item_trait(it.id=%d, tpt.ty=%s)",
it.id, ty_to_str(tcx, tpt.ty)]; it.id, ty_to_str(tcx, tpt.ty)];
write_ty_to_tcx(tcx, it.id, tpt.ty); write_ty_to_tcx(tcx, it.id, tpt.ty);
ensure_iface_methods(ccx, it.id); ensure_trait_methods(ccx, it.id);
} }
ast::item_class(tps, ifaces, members, ctor, m_dtor, rp) { ast::item_class(tps, traits, members, ctor, m_dtor, rp) {
// Write the class type // Write the class type
let tpt = ty_of_item(ccx, it); let tpt = ty_of_item(ccx, it);
write_ty_to_tcx(tcx, it.id, tpt.ty); write_ty_to_tcx(tcx, it.id, tpt.ty);
@ -362,7 +362,7 @@ fn convert(ccx: @crate_ctxt, it: @ast::item) {
rp: rp, rp: rp,
ty: t_dtor}); ty: t_dtor});
}; };
ensure_iface_methods(ccx, it.id); ensure_trait_methods(ccx, it.id);
// Write the type of each of the members // Write the type of each of the members
let (fields, methods) = split_class_items(members); let (fields, methods) = split_class_items(members);
@ -372,16 +372,16 @@ fn convert(ccx: @crate_ctxt, it: @ast::item) {
let {bounds, substs} = mk_substs(ccx, tps, rp); let {bounds, substs} = mk_substs(ccx, tps, rp);
let selfty = ty::mk_class(tcx, local_def(it.id), substs); let selfty = ty::mk_class(tcx, local_def(it.id), substs);
let cms = convert_methods(ccx, methods, rp, bounds, selfty); let cms = convert_methods(ccx, methods, rp, bounds, selfty);
for ifaces.each |ifce| { for traits.each |ifce| {
check_methods_against_iface(ccx, tps, rp, selfty, ifce, cms); check_methods_against_trait(ccx, tps, rp, selfty, ifce, cms);
// FIXME #2434---this is somewhat bogus, but it seems that // FIXME #2434---this is somewhat bogus, but it seems that
// the id of iface_ref is also the id of the impl, and so // the id of trait_ref is also the id of the impl, and so
// we want to store the "self type" of the impl---in this // we want to store the "self type" of the impl---in this
// case, the class. The reason I say this is somewhat // case, the class. The reason I say this is somewhat
// bogus (and should be refactored) is that the tcache // bogus (and should be refactored) is that the tcache
// stores the class type for ifce.id but the node_type // stores the class type for ifce.id but the node_type
// table stores the iface type. Weird. Probably just // table stores the trait type. Weird. Probably just
// adding a "self type" table rather than overloading the // adding a "self type" table rather than overloading the
// tcache would be ok, or else adding more than one id. // tcache would be ok, or else adding more than one id.
tcx.tcache.insert(local_def(ifce.id), tpt); tcx.tcache.insert(local_def(ifce.id), tpt);
@ -427,16 +427,16 @@ fn ty_of_ty_method(self: @crate_ctxt,
tps: ty_param_bounds(self, m.tps), tps: ty_param_bounds(self, m.tps),
fty: ty_of_fn_decl(self, type_rscope(rp), ast::proto_bare, fty: ty_of_fn_decl(self, type_rscope(rp), ast::proto_bare,
m.decl, none), m.decl, none),
// assume public, because this is only invoked on iface methods // assume public, because this is only invoked on trait methods
purity: m.decl.purity, vis: ast::public} purity: m.decl.purity, vis: ast::public}
} }
/* /*
Instantiates the path for the given iface reference, assuming that Instantiates the path for the given trait reference, assuming that
it's bound to a valid iface type. Returns the def_id for the defining it's bound to a valid trait type. Returns the def_id for the defining
iface. Fails if the type is a type other than an iface type. trait. Fails if the type is a type other than an trait type.
*/ */
fn instantiate_iface_ref(ccx: @crate_ctxt, t: @ast::iface_ref, fn instantiate_trait_ref(ccx: @crate_ctxt, t: @ast::trait_ref,
rp: ast::region_param) rp: ast::region_param)
-> (ast::def_id, ty_param_substs_and_ty) { -> (ast::def_id, ty_param_substs_and_ty) {
@ -449,7 +449,7 @@ fn instantiate_iface_ref(ccx: @crate_ctxt, t: @ast::iface_ref,
ast::def_ty(t_id) { ast::def_ty(t_id) {
let tpt = astconv::ast_path_to_ty(ccx, rscope, t_id, t.path, t.id); let tpt = astconv::ast_path_to_ty(ccx, rscope, t_id, t.path, t.id);
alt ty::get(tpt.ty).struct { alt ty::get(tpt.ty).struct {
ty::ty_iface(*) { ty::ty_trait(*) {
(t_id, tpt) (t_id, tpt)
} }
_ { sess.span_fatal(sp, err); } _ { sess.span_fatal(sp, err); }
@ -520,9 +520,9 @@ fn ty_of_item(ccx: @crate_ctxt, it: @ast::item)
tcx.tcache.insert(local_def(it.id), tpt); tcx.tcache.insert(local_def(it.id), tpt);
ret tpt; ret tpt;
} }
ast::item_iface(tps, rp, ms) { ast::item_trait(tps, rp, ms) {
let {bounds, substs} = mk_substs(ccx, tps, rp); let {bounds, substs} = mk_substs(ccx, tps, rp);
let t = ty::mk_iface(tcx, local_def(it.id), substs); let t = ty::mk_trait(tcx, local_def(it.id), substs);
let tpt = {bounds: bounds, rp: rp, ty: t}; let tpt = {bounds: bounds, rp: rp, ty: t};
tcx.tcache.insert(local_def(it.id), tpt); tcx.tcache.insert(local_def(it.id), tpt);
ret tpt; ret tpt;
@ -558,11 +558,11 @@ fn ty_param_bounds(ccx: @crate_ctxt,
ast::bound_send { ~[ty::bound_send] } ast::bound_send { ~[ty::bound_send] }
ast::bound_copy { ~[ty::bound_copy] } ast::bound_copy { ~[ty::bound_copy] }
ast::bound_const { ~[ty::bound_const] } ast::bound_const { ~[ty::bound_const] }
ast::bound_iface(t) { ast::bound_trait(t) {
let ity = ast_ty_to_ty(ccx, empty_rscope, t); let ity = ast_ty_to_ty(ccx, empty_rscope, t);
alt ty::get(ity).struct { alt ty::get(ity).struct {
ty::ty_iface(*) { ty::ty_trait(*) {
~[ty::bound_iface(ity)] ~[ty::bound_trait(ity)]
} }
_ { _ {
ccx.tcx.sess.span_err( ccx.tcx.sess.span_err(

4
src/rustc/middle/typeck/infer.rs
View File

@ -1781,10 +1781,10 @@ fn super_tys<C:combine>(
} }
} }
(ty::ty_iface(a_id, a_substs), ty::ty_iface(b_id, b_substs)) (ty::ty_trait(a_id, a_substs), ty::ty_trait(b_id, b_substs))
if a_id == b_id { if a_id == b_id {
do self.substs(a_substs, b_substs).chain |substs| { do self.substs(a_substs, b_substs).chain |substs| {
ok(ty::mk_iface(tcx, a_id, substs)) ok(ty::mk_trait(tcx, a_id, substs))
} }
} }

4
src/rustc/util/ppaux.rs
View File

@ -4,7 +4,7 @@ import middle::ty::{arg, bound_region, br_anon, br_named, canon_mode};
import middle::ty::{ck_block, ck_box, ck_uniq, constr, ctxt, field, method}; import middle::ty::{ck_block, ck_box, ck_uniq, constr, ctxt, field, method};
import middle::ty::{mt, re_bound, re_free, re_scope, re_var, region, t}; import middle::ty::{mt, re_bound, re_free, re_scope, re_var, region, t};
import middle::ty::{ty_bool, ty_bot, ty_box, ty_class, ty_constr, ty_enum}; import middle::ty::{ty_bool, ty_bot, ty_box, ty_class, ty_constr, ty_enum};
import middle::ty::{ty_estr, ty_evec, ty_float, ty_fn, ty_iface, ty_int}; import middle::ty::{ty_estr, ty_evec, ty_float, ty_fn, ty_trait, ty_int};
import middle::ty::{ty_nil, ty_opaque_box, ty_opaque_closure_ptr, ty_param}; import middle::ty::{ty_nil, ty_opaque_box, ty_opaque_closure_ptr, ty_param};
import middle::ty::{ty_ptr, ty_rec, ty_rptr, ty_self, ty_str, ty_tup}; import middle::ty::{ty_ptr, ty_rec, ty_rptr, ty_self, ty_str, ty_tup};
import middle::ty::{ty_type, ty_uniq, ty_uint, ty_var, ty_var_integral}; import middle::ty::{ty_type, ty_uniq, ty_uint, ty_var, ty_var_integral};
@ -213,7 +213,7 @@ fn ty_to_str(cx: ctxt, typ: t) -> str {
let base = ast_map::path_to_str(path); let base = ast_map::path_to_str(path);
parameterized(cx, base, substs.self_r, substs.tps) parameterized(cx, base, substs.self_r, substs.tps)
} }
ty_iface(did, substs) { ty_trait(did, substs) {
let path = ty::item_path(cx, did); let path = ty::item_path(cx, did);
let base = ast_map::path_to_str(path); let base = ast_map::path_to_str(path);
parameterized(cx, base, substs.self_r, substs.tps) parameterized(cx, base, substs.self_r, substs.tps)

20
src/rustdoc/attr_pass.rs
View File

@ -27,7 +27,7 @@ fn run(
fold_crate: fold_crate, fold_crate: fold_crate,
fold_item: fold_item, fold_item: fold_item,
fold_enum: fold_enum, fold_enum: fold_enum,
fold_iface: fold_iface, fold_trait: fold_trait,
fold_impl: fold_impl fold_impl: fold_impl
with *fold::default_any_fold(srv) with *fold::default_any_fold(srv)
}); });
@ -181,12 +181,12 @@ fn should_extract_variant_docs() {
assert doc.cratemod().enums()[0].variants[0].desc == some("c"); assert doc.cratemod().enums()[0].variants[0].desc == some("c");
} }
fn fold_iface( fn fold_trait(
fold: fold::fold<astsrv::srv>, fold: fold::fold<astsrv::srv>,
doc: doc::ifacedoc doc: doc::traitdoc
) -> doc::ifacedoc { ) -> doc::traitdoc {
let srv = fold.ctxt; let srv = fold.ctxt;
let doc = fold::default_seq_fold_iface(fold, doc); let doc = fold::default_seq_fold_trait(fold, doc);
{ {
methods: merge_method_attrs(srv, doc.id(), doc.methods) methods: merge_method_attrs(srv, doc.id(), doc.methods)
@ -204,7 +204,7 @@ fn merge_method_attrs(
let attrs: ~[(str, option<str>)] = do astsrv::exec(srv) |ctxt| { let attrs: ~[(str, option<str>)] = do astsrv::exec(srv) |ctxt| {
alt ctxt.ast_map.get(item_id) { alt ctxt.ast_map.get(item_id) {
ast_map::node_item(@{ ast_map::node_item(@{
node: ast::item_iface(_, _, methods), _ node: ast::item_trait(_, _, methods), _
}, _) { }, _) {
par::seqmap(methods, |method| { par::seqmap(methods, |method| {
(*method.ident, attr_parser::parse_desc(method.attrs)) (*method.ident, attr_parser::parse_desc(method.attrs))
@ -233,19 +233,19 @@ fn merge_method_attrs(
} }
#[test] #[test]
fn should_extract_iface_docs() { fn should_extract_trait_docs() {
let doc = test::mk_doc("#[doc = \"whatever\"] iface i { fn a(); }"); let doc = test::mk_doc("#[doc = \"whatever\"] iface i { fn a(); }");
assert doc.cratemod().ifaces()[0].desc() == some("whatever"); assert doc.cratemod().traits()[0].desc() == some("whatever");
} }
#[test] #[test]
fn should_extract_iface_method_docs() { fn should_extract_trait_method_docs() {
let doc = test::mk_doc( let doc = test::mk_doc(
"iface i {\ "iface i {\
#[doc = \"desc\"]\ #[doc = \"desc\"]\
fn f(a: bool) -> bool;\ fn f(a: bool) -> bool;\
}"); }");
assert doc.cratemod().ifaces()[0].methods[0].desc == some("desc"); assert doc.cratemod().traits()[0].methods[0].desc == some("desc");
} }

10
src/rustdoc/desc_to_brief_pass.rs
View File

@ -20,7 +20,7 @@ fn run(
) -> doc::doc { ) -> doc::doc {
let fold = fold::fold({ let fold = fold::fold({
fold_item: fold_item, fold_item: fold_item,
fold_iface: fold_iface, fold_trait: fold_trait,
fold_impl: fold_impl fold_impl: fold_impl
with *fold::default_any_fold(()) with *fold::default_any_fold(())
}); });
@ -36,8 +36,8 @@ fn fold_item(fold: fold::fold<()>, doc: doc::itemdoc) -> doc::itemdoc {
} }
} }
fn fold_iface(fold: fold::fold<()>, doc: doc::ifacedoc) -> doc::ifacedoc { fn fold_trait(fold: fold::fold<()>, doc: doc::traitdoc) -> doc::traitdoc {
let doc =fold::default_seq_fold_iface(fold, doc); let doc =fold::default_seq_fold_trait(fold, doc);
{ {
methods: par::anymap(doc.methods, |doc| { methods: par::anymap(doc.methods, |doc| {
@ -67,9 +67,9 @@ fn should_promote_desc() {
} }
#[test] #[test]
fn should_promote_iface_method_desc() { fn should_promote_trait_method_desc() {
let doc = test::mk_doc("iface i { #[doc = \"desc\"] fn a(); }"); let doc = test::mk_doc("iface i { #[doc = \"desc\"] fn a(); }");
assert doc.cratemod().ifaces()[0].methods[0].brief == some("desc"); assert doc.cratemod().traits()[0].methods[0].brief == some("desc");
} }
#[test] #[test]

18
src/rustdoc/doc.rs
View File

@ -33,7 +33,7 @@ enum itemtag {
consttag(constdoc), consttag(constdoc),
fntag(fndoc), fntag(fndoc),
enumtag(enumdoc), enumtag(enumdoc),
ifacetag(ifacedoc), traittag(traitdoc),
impltag(impldoc), impltag(impldoc),
tytag(tydoc) tytag(tydoc)
} }
@ -81,7 +81,7 @@ type variantdoc = {
sig: option<str> sig: option<str>
}; };
type ifacedoc = { type traitdoc = {
item: itemdoc, item: itemdoc,
methods: ~[methoddoc] methods: ~[methoddoc]
}; };
@ -96,7 +96,7 @@ type methoddoc = {
type impldoc = { type impldoc = {
item: itemdoc, item: itemdoc,
iface_ty: option<str>, trait_ty: option<str>,
self_ty: option<str>, self_ty: option<str>,
methods: ~[methoddoc] methods: ~[methoddoc]
}; };
@ -187,10 +187,10 @@ impl util for moddoc {
} }
} }
fn ifaces() -> ~[ifacedoc] { fn traits() -> ~[traitdoc] {
do vec::filter_map(self.items) |itemtag| { do vec::filter_map(self.items) |itemtag| {
alt itemtag { alt itemtag {
ifacetag(ifacedoc) { some(ifacedoc) } traittag(traitdoc) { some(traitdoc) }
_ { none } _ { none }
} }
} }
@ -262,10 +262,10 @@ impl util for ~[page] {
} }
} }
fn ifaces() -> ~[ifacedoc] { fn traits() -> ~[traitdoc] {
do vec::filter_map(self) |page| { do vec::filter_map(self) |page| {
alt page { alt page {
itempage(ifacetag(ifacedoc)) { some(ifacedoc) } itempage(traittag(traitdoc)) { some(traitdoc) }
_ { none } _ { none }
} }
} }
@ -302,7 +302,7 @@ impl of item for itemtag {
doc::fntag(doc) { doc.item } doc::fntag(doc) { doc.item }
doc::consttag(doc) { doc.item } doc::consttag(doc) { doc.item }
doc::enumtag(doc) { doc.item } doc::enumtag(doc) { doc.item }
doc::ifacetag(doc) { doc.item } doc::traittag(doc) { doc.item }
doc::impltag(doc) { doc.item } doc::impltag(doc) { doc.item }
doc::tytag(doc) { doc.item } doc::tytag(doc) { doc.item }
} }
@ -325,7 +325,7 @@ impl of item for enumdoc {
fn item() -> itemdoc { self.item } fn item() -> itemdoc { self.item }
} }
impl of item for ifacedoc { impl of item for traitdoc {
fn item() -> itemdoc { self.item } fn item() -> itemdoc { self.item }
} }

24
src/rustdoc/extract.rs
View File

@ -83,9 +83,9 @@ fn moddoc_from_mod(
enumdoc_from_enum(itemdoc, variants) enumdoc_from_enum(itemdoc, variants)
)) ))
} }
ast::item_iface(_, _, methods) { ast::item_trait(_, _, methods) {
some(doc::ifacetag( some(doc::traittag(
ifacedoc_from_iface(itemdoc, methods) traitdoc_from_trait(itemdoc, methods)
)) ))
} }
ast::item_impl(_, _, _, _, methods) { ast::item_impl(_, _, _, _, methods) {
@ -183,10 +183,10 @@ fn should_extract_enum_variants() {
assert doc.cratemod().enums()[0].variants[0].name == "v"; assert doc.cratemod().enums()[0].variants[0].name == "v";
} }
fn ifacedoc_from_iface( fn traitdoc_from_trait(
itemdoc: doc::itemdoc, itemdoc: doc::itemdoc,
methods: ~[ast::ty_method] methods: ~[ast::ty_method]
) -> doc::ifacedoc { ) -> doc::traitdoc {
{ {
item: itemdoc, item: itemdoc,
methods: do par::seqmap(methods) |method| { methods: do par::seqmap(methods) |method| {
@ -202,15 +202,15 @@ fn ifacedoc_from_iface(
} }
#[test] #[test]
fn should_extract_ifaces() { fn should_extract_traits() {
let doc = test::mk_doc("iface i { fn f(); }"); let doc = test::mk_doc("trait i { fn f(); }");
assert doc.cratemod().ifaces()[0].name() == "i"; assert doc.cratemod().traits()[0].name() == "i";
} }
#[test] #[test]
fn should_extract_iface_methods() { fn should_extract_trait_methods() {
let doc = test::mk_doc("iface i { fn f(); }"); let doc = test::mk_doc("trait i { fn f(); }");
assert doc.cratemod().ifaces()[0].methods[0].name == "f"; assert doc.cratemod().traits()[0].methods[0].name == "f";
} }
fn impldoc_from_impl( fn impldoc_from_impl(
@ -219,7 +219,7 @@ fn impldoc_from_impl(
) -> doc::impldoc { ) -> doc::impldoc {
{ {
item: itemdoc, item: itemdoc,
iface_ty: none, trait_ty: none,
self_ty: none, self_ty: none,
methods: do par::seqmap(methods) |method| { methods: do par::seqmap(methods) |method| {
{ {

26
src/rustdoc/fold.rs
View File

@ -8,7 +8,7 @@ export default_seq_fold_nmod;
export default_seq_fold_fn; export default_seq_fold_fn;
export default_seq_fold_const; export default_seq_fold_const;
export default_seq_fold_enum; export default_seq_fold_enum;
export default_seq_fold_iface; export default_seq_fold_trait;
export default_seq_fold_impl; export default_seq_fold_impl;
export default_seq_fold_type; export default_seq_fold_type;
export default_par_fold; export default_par_fold;
@ -28,7 +28,7 @@ type fold_nmod<T> = fn~(fold: fold<T>, doc: doc::nmoddoc) -> doc::nmoddoc;
type fold_fn<T> = fn~(fold: fold<T>, doc: doc::fndoc) -> doc::fndoc; type fold_fn<T> = fn~(fold: fold<T>, doc: doc::fndoc) -> doc::fndoc;
type fold_const<T> = fn~(fold: fold<T>, doc: doc::constdoc) -> doc::constdoc; type fold_const<T> = fn~(fold: fold<T>, doc: doc::constdoc) -> doc::constdoc;
type fold_enum<T> = fn~(fold: fold<T>, doc: doc::enumdoc) -> doc::enumdoc; type fold_enum<T> = fn~(fold: fold<T>, doc: doc::enumdoc) -> doc::enumdoc;
type fold_iface<T> = fn~(fold: fold<T>, doc: doc::ifacedoc) -> doc::ifacedoc; type fold_trait<T> = fn~(fold: fold<T>, doc: doc::traitdoc) -> doc::traitdoc;
type fold_impl<T> = fn~(fold: fold<T>, doc: doc::impldoc) -> doc::impldoc; type fold_impl<T> = fn~(fold: fold<T>, doc: doc::impldoc) -> doc::impldoc;
type fold_type<T> = fn~(fold: fold<T>, doc: doc::tydoc) -> doc::tydoc; type fold_type<T> = fn~(fold: fold<T>, doc: doc::tydoc) -> doc::tydoc;
@ -42,7 +42,7 @@ type t<T> = {
fold_fn: fold_fn<T>, fold_fn: fold_fn<T>,
fold_const: fold_const<T>, fold_const: fold_const<T>,
fold_enum: fold_enum<T>, fold_enum: fold_enum<T>,
fold_iface: fold_iface<T>, fold_trait: fold_trait<T>,
fold_impl: fold_impl<T>, fold_impl: fold_impl<T>,
fold_type: fold_type<T> fold_type: fold_type<T>
}; };
@ -60,7 +60,7 @@ fn mk_fold<T:copy>(
+fold_fn: fold_fn<T>, +fold_fn: fold_fn<T>,
+fold_const: fold_const<T>, +fold_const: fold_const<T>,
+fold_enum: fold_enum<T>, +fold_enum: fold_enum<T>,
+fold_iface: fold_iface<T>, +fold_trait: fold_trait<T>,
+fold_impl: fold_impl<T>, +fold_impl: fold_impl<T>,
+fold_type: fold_type<T> +fold_type: fold_type<T>
) -> fold<T> { ) -> fold<T> {
@ -74,7 +74,7 @@ fn mk_fold<T:copy>(
fold_fn: fold_fn, fold_fn: fold_fn,
fold_const: fold_const, fold_const: fold_const,
fold_enum: fold_enum, fold_enum: fold_enum,
fold_iface: fold_iface, fold_trait: fold_trait,
fold_impl: fold_impl, fold_impl: fold_impl,
fold_type: fold_type fold_type: fold_type
}) })
@ -91,7 +91,7 @@ fn default_any_fold<T:send copy>(ctxt: T) -> fold<T> {
|f, d| default_seq_fold_fn(f, d), |f, d| default_seq_fold_fn(f, d),
|f, d| default_seq_fold_const(f, d), |f, d| default_seq_fold_const(f, d),
|f, d| default_seq_fold_enum(f, d), |f, d| default_seq_fold_enum(f, d),
|f, d| default_seq_fold_iface(f, d), |f, d| default_seq_fold_trait(f, d),
|f, d| default_seq_fold_impl(f, d), |f, d| default_seq_fold_impl(f, d),
|f, d| default_seq_fold_type(f, d) |f, d| default_seq_fold_type(f, d)
) )
@ -108,7 +108,7 @@ fn default_seq_fold<T:copy>(ctxt: T) -> fold<T> {
|f, d| default_seq_fold_fn(f, d), |f, d| default_seq_fold_fn(f, d),
|f, d| default_seq_fold_const(f, d), |f, d| default_seq_fold_const(f, d),
|f, d| default_seq_fold_enum(f, d), |f, d| default_seq_fold_enum(f, d),
|f, d| default_seq_fold_iface(f, d), |f, d| default_seq_fold_trait(f, d),
|f, d| default_seq_fold_impl(f, d), |f, d| default_seq_fold_impl(f, d),
|f, d| default_seq_fold_type(f, d) |f, d| default_seq_fold_type(f, d)
) )
@ -125,7 +125,7 @@ fn default_par_fold<T:send copy>(ctxt: T) -> fold<T> {
|f, d| default_seq_fold_fn(f, d), |f, d| default_seq_fold_fn(f, d),
|f, d| default_seq_fold_const(f, d), |f, d| default_seq_fold_const(f, d),
|f, d| default_seq_fold_enum(f, d), |f, d| default_seq_fold_enum(f, d),
|f, d| default_seq_fold_iface(f, d), |f, d| default_seq_fold_trait(f, d),
|f, d| default_seq_fold_impl(f, d), |f, d| default_seq_fold_impl(f, d),
|f, d| default_seq_fold_type(f, d) |f, d| default_seq_fold_type(f, d)
) )
@ -258,8 +258,8 @@ fn fold_itemtag<T>(fold: fold<T>, doc: doc::itemtag) -> doc::itemtag {
doc::enumtag(enumdoc) { doc::enumtag(enumdoc) {
doc::enumtag(fold.fold_enum(fold, enumdoc)) doc::enumtag(fold.fold_enum(fold, enumdoc))
} }
doc::ifacetag(ifacedoc) { doc::traittag(traitdoc) {
doc::ifacetag(fold.fold_iface(fold, ifacedoc)) doc::traittag(fold.fold_trait(fold, traitdoc))
} }
doc::impltag(impldoc) { doc::impltag(impldoc) {
doc::impltag(fold.fold_impl(fold, impldoc)) doc::impltag(fold.fold_impl(fold, impldoc))
@ -300,10 +300,10 @@ fn default_seq_fold_enum<T>(
} }
} }
fn default_seq_fold_iface<T>( fn default_seq_fold_trait<T>(
fold: fold<T>, fold: fold<T>,
doc: doc::ifacedoc doc: doc::traitdoc
) -> doc::ifacedoc { ) -> doc::traitdoc {
{ {
item: fold.fold_item(fold, doc.item) item: fold.fold_item(fold, doc.item)
with doc with doc

22
src/rustdoc/markdown_pass.rs
View File

@ -198,7 +198,7 @@ fn header_kind(doc: doc::itemtag) -> str {
doc::enumtag(_) { doc::enumtag(_) {
"Enum" "Enum"
} }
doc::ifacetag(_) { doc::traittag(_) {
"Interface" "Interface"
} }
doc::impltag(doc) { doc::impltag(doc) {
@ -222,9 +222,9 @@ fn header_name(doc: doc::itemtag) -> str {
doc::impltag(doc) { doc::impltag(doc) {
assert option::is_some(doc.self_ty); assert option::is_some(doc.self_ty);
let self_ty = option::get(doc.self_ty); let self_ty = option::get(doc.self_ty);
alt doc.iface_ty { alt doc.trait_ty {
some(iface_ty) { some(trait_ty) {
#fmt("%s of %s for %s", doc.name(), iface_ty, self_ty) #fmt("%s of %s for %s", doc.name(), trait_ty, self_ty)
} }
none { none {
#fmt("%s for %s", doc.name(), self_ty) #fmt("%s for %s", doc.name(), self_ty)
@ -349,7 +349,7 @@ fn write_item_(ctxt: ctxt, doc: doc::itemtag, write_header: bool) {
doc::fntag(fndoc) { write_fn(ctxt, fndoc) } doc::fntag(fndoc) { write_fn(ctxt, fndoc) }
doc::consttag(constdoc) { write_const(ctxt, constdoc) } doc::consttag(constdoc) { write_const(ctxt, constdoc) }
doc::enumtag(enumdoc) { write_enum(ctxt, enumdoc) } doc::enumtag(enumdoc) { write_enum(ctxt, enumdoc) }
doc::ifacetag(ifacedoc) { write_iface(ctxt, ifacedoc) } doc::traittag(traitdoc) { write_trait(ctxt, traitdoc) }
doc::impltag(impldoc) { write_impl(ctxt, impldoc) } doc::impltag(impldoc) { write_impl(ctxt, impldoc) }
doc::tytag(tydoc) { write_type(ctxt, tydoc) } doc::tytag(tydoc) { write_type(ctxt, tydoc) }
} }
@ -639,7 +639,7 @@ fn should_write_variant_list_with_signatures() {
\n* `c(int)` - a\n\n"); \n* `c(int)` - a\n\n");
} }
fn write_iface(ctxt: ctxt, doc: doc::ifacedoc) { fn write_trait(ctxt: ctxt, doc: doc::traitdoc) {
write_common(ctxt, doc.desc(), doc.sections()); write_common(ctxt, doc.desc(), doc.sections());
write_methods(ctxt, doc.methods); write_methods(ctxt, doc.methods);
} }
@ -659,27 +659,27 @@ fn write_method(ctxt: ctxt, doc: doc::methoddoc) {
} }
#[test] #[test]
fn should_write_iface_header() { fn should_write_trait_header() {
let markdown = test::render("iface i { fn a(); }"); let markdown = test::render("iface i { fn a(); }");
assert str::contains(markdown, "## Interface `i`"); assert str::contains(markdown, "## Interface `i`");
} }
#[test] #[test]
fn should_write_iface_desc() { fn should_write_trait_desc() {
let markdown = test::render( let markdown = test::render(
"#[doc = \"desc\"] iface i { fn a(); }"); "#[doc = \"desc\"] iface i { fn a(); }");
assert str::contains(markdown, "desc"); assert str::contains(markdown, "desc");
} }
#[test] #[test]
fn should_write_iface_method_header() { fn should_write_trait_method_header() {
let markdown = test::render( let markdown = test::render(
"iface i { fn a(); }"); "iface i { fn a(); }");
assert str::contains(markdown, "### Method `a`"); assert str::contains(markdown, "### Method `a`");
} }
#[test] #[test]
fn should_write_iface_method_signature() { fn should_write_trait_method_signature() {
let markdown = test::render( let markdown = test::render(
"iface i { fn a(); }"); "iface i { fn a(); }");
assert str::contains(markdown, "\n fn a()"); assert str::contains(markdown, "\n fn a()");
@ -697,7 +697,7 @@ fn should_write_impl_header() {
} }
#[test] #[test]
fn should_write_impl_header_with_iface() { fn should_write_impl_header_with_trait() {
let markdown = test::render("impl i of j for int { fn a() { } }"); let markdown = test::render("impl i of j for int { fn a() { } }");
assert str::contains(markdown, "## Implementation `i of j for int`"); assert str::contains(markdown, "## Implementation `i of j for int`");
} }

4
src/rustdoc/prune_unexported_pass.rs
View File

@ -202,9 +202,9 @@ fn should_prune_unexported_variants() {
} }
#[test] #[test]
fn should_prune_unexported_ifaces_from_top_mod() { fn should_prune_unexported_traits_from_top_mod() {
let doc = test::mk_doc("export a; mod a { } iface b { fn c(); }"); let doc = test::mk_doc("export a; mod a { } iface b { fn c(); }");
assert vec::is_empty(doc.cratemod().ifaces()); assert vec::is_empty(doc.cratemod().traits());
} }
#[test] #[test]

4
src/rustdoc/reexport_pass.rs
View File

@ -374,8 +374,8 @@ fn merge_reexports(
with doc with doc
}) })
} }
doc::ifacetag(doc @ {item, _}) { doc::traittag(doc @ {item, _}) {
doc::ifacetag({ doc::traittag({
item: reexport(item, name) item: reexport(item, name)
with doc with doc
}) })

10
src/rustdoc/sectionalize_pass.rs
View File

@ -12,7 +12,7 @@ fn mk_pass() -> pass {
fn run(_srv: astsrv::srv, doc: doc::doc) -> doc::doc { fn run(_srv: astsrv::srv, doc: doc::doc) -> doc::doc {
let fold = fold::fold({ let fold = fold::fold({
fold_item: fold_item, fold_item: fold_item,
fold_iface: fold_iface, fold_trait: fold_trait,
fold_impl: fold_impl fold_impl: fold_impl
with *fold::default_any_fold(()) with *fold::default_any_fold(())
}); });
@ -30,8 +30,8 @@ fn fold_item(fold: fold::fold<()>, doc: doc::itemdoc) -> doc::itemdoc {
} }
} }
fn fold_iface(fold: fold::fold<()>, doc: doc::ifacedoc) -> doc::ifacedoc { fn fold_trait(fold: fold::fold<()>, doc: doc::traitdoc) -> doc::traitdoc {
let doc = fold::default_seq_fold_iface(fold, doc); let doc = fold::default_seq_fold_trait(fold, doc);
{ {
methods: do par::anymap(doc.methods) |method| { methods: do par::anymap(doc.methods) |method| {
@ -202,14 +202,14 @@ fn should_eliminate_desc_if_it_is_just_whitespace() {
} }
#[test] #[test]
fn should_sectionalize_iface_methods() { fn should_sectionalize_trait_methods() {
let doc = test::mk_doc( let doc = test::mk_doc(
"iface i { "iface i {
#[doc = \"\ #[doc = \"\
# Header\n\ # Header\n\
Body\"]\ Body\"]\
fn a(); }"); fn a(); }");
assert doc.cratemod().ifaces()[0].methods[0].sections.len() == 1u; assert doc.cratemod().traits()[0].methods[0].sections.len() == 1u;
} }
#[test] #[test]

2
src/rustdoc/sort_item_type_pass.rs
View File

@ -9,7 +9,7 @@ fn mk_pass() -> pass {
doc::consttag(_) { 0 } doc::consttag(_) { 0 }
doc::tytag(_) { 1 } doc::tytag(_) { 1 }
doc::enumtag(_) { 2 } doc::enumtag(_) { 2 }
doc::ifacetag(_) { 3 } doc::traittag(_) { 3 }
doc::impltag(_) { 4 } doc::impltag(_) { 4 }
doc::fntag(_) { 5 } doc::fntag(_) { 5 }
doc::modtag(_) { 6 } doc::modtag(_) { 6 }

30
src/rustdoc/text_pass.rs
View File

@ -22,7 +22,7 @@ fn run(
let fold = fold::fold({ let fold = fold::fold({
fold_item: fold_item, fold_item: fold_item,
fold_enum: fold_enum, fold_enum: fold_enum,
fold_iface: fold_iface, fold_trait: fold_trait,
fold_impl: fold_impl fold_impl: fold_impl
with *fold::default_any_fold(op) with *fold::default_any_fold(op)
}); });
@ -65,8 +65,8 @@ fn fold_enum(fold: fold::fold<op>, doc: doc::enumdoc) -> doc::enumdoc {
} }
} }
fn fold_iface(fold: fold::fold<op>, doc: doc::ifacedoc) -> doc::ifacedoc { fn fold_trait(fold: fold::fold<op>, doc: doc::traitdoc) -> doc::traitdoc {
let doc = fold::default_seq_fold_iface(fold, doc); let doc = fold::default_seq_fold_trait(fold, doc);
{ {
methods: apply_to_methods(fold.ctxt, doc.methods) methods: apply_to_methods(fold.ctxt, doc.methods)
@ -113,31 +113,31 @@ fn should_execute_op_on_variant_desc() {
} }
#[test] #[test]
fn should_execute_op_on_iface_brief() { fn should_execute_op_on_trait_brief() {
let doc = test::mk_doc( let doc = test::mk_doc(
"#[doc = \" a \"] iface i { fn a(); }"); "#[doc = \" a \"] iface i { fn a(); }");
assert doc.cratemod().ifaces()[0].brief() == some("a"); assert doc.cratemod().traits()[0].brief() == some("a");
} }
#[test] #[test]
fn should_execute_op_on_iface_desc() { fn should_execute_op_on_trait_desc() {
let doc = test::mk_doc( let doc = test::mk_doc(
"#[doc = \" a \"] iface i { fn a(); }"); "#[doc = \" a \"] iface i { fn a(); }");
assert doc.cratemod().ifaces()[0].desc() == some("a"); assert doc.cratemod().traits()[0].desc() == some("a");
} }
#[test] #[test]
fn should_execute_op_on_iface_method_brief() { fn should_execute_op_on_trait_method_brief() {
let doc = test::mk_doc( let doc = test::mk_doc(
"iface i { #[doc = \" a \"] fn a(); }"); "iface i { #[doc = \" a \"] fn a(); }");
assert doc.cratemod().ifaces()[0].methods[0].brief == some("a"); assert doc.cratemod().traits()[0].methods[0].brief == some("a");
} }
#[test] #[test]
fn should_execute_op_on_iface_method_desc() { fn should_execute_op_on_trait_method_desc() {
let doc = test::mk_doc( let doc = test::mk_doc(
"iface i { #[doc = \" a \"] fn a(); }"); "iface i { #[doc = \" a \"] fn a(); }");
assert doc.cratemod().ifaces()[0].methods[0].desc == some("a"); assert doc.cratemod().traits()[0].methods[0].desc == some("a");
} }
#[test] #[test]
@ -203,26 +203,26 @@ fn should_execute_on_item_section_bodies() {
} }
#[test] #[test]
fn should_execute_on_iface_method_section_headers() { fn should_execute_on_trait_method_section_headers() {
let doc = test::mk_doc( let doc = test::mk_doc(
"iface i { "iface i {
#[doc = \"\ #[doc = \"\
# Header \n\ # Header \n\
Body\"]\ Body\"]\
fn a(); }"); fn a(); }");
assert doc.cratemod().ifaces()[0].methods[0].sections[0].header assert doc.cratemod().traits()[0].methods[0].sections[0].header
== "Header"; == "Header";
} }
#[test] #[test]
fn should_execute_on_iface_method_section_bodies() { fn should_execute_on_trait_method_section_bodies() {
let doc = test::mk_doc( let doc = test::mk_doc(
"iface i { "iface i {
#[doc = \"\ #[doc = \"\
# Header\n\ # Header\n\
Body \"]\ Body \"]\
fn a(); }"); fn a(); }");
assert doc.cratemod().ifaces()[0].methods[0].sections[0].body == "Body"; assert doc.cratemod().traits()[0].methods[0].sections[0].body == "Body";
} }
#[test] #[test]

32
src/rustdoc/tystr_pass.rs
View File

@ -22,7 +22,7 @@ fn run(
fold_fn: fold_fn, fold_fn: fold_fn,
fold_const: fold_const, fold_const: fold_const,
fold_enum: fold_enum, fold_enum: fold_enum,
fold_iface: fold_iface, fold_trait: fold_trait,
fold_impl: fold_impl, fold_impl: fold_impl,
fold_type: fold_type fold_type: fold_type
with *fold::default_any_fold(srv) with *fold::default_any_fold(srv)
@ -137,10 +137,10 @@ fn should_add_variant_sigs() {
assert doc.cratemod().enums()[0].variants[0].sig == some("b(int)"); assert doc.cratemod().enums()[0].variants[0].sig == some("b(int)");
} }
fn fold_iface( fn fold_trait(
fold: fold::fold<astsrv::srv>, fold: fold::fold<astsrv::srv>,
doc: doc::ifacedoc doc: doc::traitdoc
) -> doc::ifacedoc { ) -> doc::traitdoc {
{ {
methods: merge_methods(fold.ctxt, doc.id(), doc.methods) methods: merge_methods(fold.ctxt, doc.id(), doc.methods)
with doc with doc
@ -168,7 +168,7 @@ fn get_method_sig(
do astsrv::exec(srv) |ctxt| { do astsrv::exec(srv) |ctxt| {
alt check ctxt.ast_map.get(item_id) { alt check ctxt.ast_map.get(item_id) {
ast_map::node_item(@{ ast_map::node_item(@{
node: ast::item_iface(_, _, methods), _ node: ast::item_trait(_, _, methods), _
}, _) { }, _) {
alt check vec::find(methods, |method| { alt check vec::find(methods, |method| {
*method.ident == method_name *method.ident == method_name
@ -202,9 +202,9 @@ fn get_method_sig(
} }
#[test] #[test]
fn should_add_iface_method_sigs() { fn should_add_trait_method_sigs() {
let doc = test::mk_doc("iface i { fn a<T>() -> int; }"); let doc = test::mk_doc("iface i { fn a<T>() -> int; }");
assert doc.cratemod().ifaces()[0].methods[0].sig assert doc.cratemod().traits()[0].methods[0].sig
== some("fn a<T>() -> int"); == some("fn a<T>() -> int");
} }
@ -215,22 +215,22 @@ fn fold_impl(
let srv = fold.ctxt; let srv = fold.ctxt;
let (iface_ty, self_ty) = do astsrv::exec(srv) |ctxt| { let (trait_ty, self_ty) = do astsrv::exec(srv) |ctxt| {
alt ctxt.ast_map.get(doc.id()) { alt ctxt.ast_map.get(doc.id()) {
ast_map::node_item(@{ ast_map::node_item(@{
node: ast::item_impl(_, _, iface_ty, self_ty, _), _ node: ast::item_impl(_, _, trait_ty, self_ty, _), _
}, _) { }, _) {
let iface_ty = option::map(iface_ty, |p| { let trait_ty = option::map(trait_ty, |p| {
pprust::path_to_str(p.path) pprust::path_to_str(p.path)
}); });
(iface_ty, some(pprust::ty_to_str(self_ty))) (trait_ty, some(pprust::ty_to_str(self_ty)))
} }
_ { fail "expected impl" } _ { fail "expected impl" }
} }
}; };
{ {
iface_ty: iface_ty, trait_ty: trait_ty,
self_ty: self_ty, self_ty: self_ty,
methods: merge_methods(fold.ctxt, doc.id(), doc.methods) methods: merge_methods(fold.ctxt, doc.id(), doc.methods)
with doc with doc
@ -238,15 +238,15 @@ fn fold_impl(
} }
#[test] #[test]
fn should_add_impl_iface_ty() { fn should_add_impl_trait_ty() {
let doc = test::mk_doc("impl i of j for int { fn a<T>() { } }"); let doc = test::mk_doc("impl i of j for int { fn a<T>() { } }");
assert doc.cratemod().impls()[0].iface_ty == some("j"); assert doc.cratemod().impls()[0].trait_ty == some("j");
} }
#[test] #[test]
fn should_not_add_impl_iface_ty_if_none() { fn should_not_add_impl_trait_ty_if_none() {
let doc = test::mk_doc("impl i for int { fn a() { } }"); let doc = test::mk_doc("impl i for int { fn a() { } }");
assert doc.cratemod().impls()[0].iface_ty == none; assert doc.cratemod().impls()[0].trait_ty == none;
} }
#[test] #[test]