bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

update librustc to use name comparison in most cases, and mtwt_resolve comparison in others

Browse source
This commit is contained in:
John Clements 2013-06-26 15:56:13 -07:00
parent 71e72ee862
commit 39ca2dbbc5
10 changed files with 124 additions and 114 deletions
Download patch file Download diff file Expand all files Collapse all files

163
src/librustc/middle/resolve.rs
View file

@ -23,7 +23,7 @@ use middle::pat_util::pat_bindings;
use syntax::ast::*;
use syntax::ast;
use syntax::ast_util::{def_id_of_def, local_def};
use syntax::ast_util::{def_id_of_def, local_def}; // mtwt_resolve
use syntax::ast_util::{path_to_ident, walk_pat, trait_method_to_ty_method};
use syntax::ast_util::{Privacy, Public, Private};
use syntax::ast_util::{variant_visibility_to_privacy, visibility_to_privacy};
@ -51,7 +51,7 @@ pub struct binding_info {
}
// Map from the name in a pattern to its binding mode.
pub type BindingMap = HashMap<Ident,binding_info>;
pub type BindingMap = HashMap<Name,binding_info>;
// Trait method resolution
pub type TraitMap = HashMap<NodeId,@mut ~[DefId]>;
@ -445,12 +445,12 @@ pub struct Module {
def_id: Option<DefId>,
kind: ModuleKind,
children: @mut HashMap<Ident, @mut NameBindings>,
children: @mut HashMap<Name, @mut NameBindings>,
imports: @mut ~[@ImportDirective],
// The external module children of this node that were declared with
// `extern mod`.
external_module_children: @mut HashMap<Ident, @mut Module>,
external_module_children: @mut HashMap<Name, @mut Module>,
// The anonymous children of this node. Anonymous children are pseudo-
// modules that are implicitly created around items contained within
@ -469,7 +469,7 @@ pub struct Module {
anonymous_children: @mut HashMap<NodeId,@mut Module>,
// The status of resolving each import in this module.
import_resolutions: @mut HashMap<Ident, @mut ImportResolution>,
import_resolutions: @mut HashMap<Name, @mut ImportResolution>,
// The number of unresolved globs that this module exports.
glob_count: uint,
@ -759,15 +759,14 @@ pub fn NameBindings() -> NameBindings {
/// Interns the names of the primitive types.
pub struct PrimitiveTypeTable {
primitive_types: HashMap<Ident,prim_ty>,
primitive_types: HashMap<Name,prim_ty>,
}
impl PrimitiveTypeTable {
pub fn intern(&mut self,
string: &str,
primitive_type: prim_ty) {
let ident = token::str_to_ident(string);
self.primitive_types.insert(ident, primitive_type);
self.primitive_types.insert(token::intern(string), primitive_type);
}
}
@ -873,7 +872,7 @@ pub struct Resolver {
graph_root: @mut NameBindings,
method_map: @mut HashMap<Ident, HashSet<DefId>>,
method_map: @mut HashMap<Name, HashSet<DefId>>,
structs: HashSet<DefId>,
// The number of imports that are currently unresolved.
@ -1036,10 +1035,10 @@ impl Resolver {
// Add or reuse the child.
let new_parent = ModuleReducedGraphParent(module_);
match module_.children.find(&name) {
match module_.children.find(&name.name) {
None => {
let child = @mut NameBindings();
module_.children.insert(name, child);
module_.children.insert(name.name, child);
return (child, new_parent);
}
Some(&child) => {
@ -1307,7 +1306,7 @@ impl Resolver {
} if path.segments.len() == 1 => {
let name = path_to_ident(path);
let new_parent = match parent.children.find(&name) {
let new_parent = match parent.children.find(&name.name) {
// It already exists
Some(&child) if child.get_module_if_available()
.is_some() &&
@ -1426,7 +1425,7 @@ impl Resolver {
match ty_m.explicit_self.node {
sty_static => {}
_ => {
method_names.insert(ident, ());
method_names.insert(ident.name, ());
}
}
}
@ -1582,7 +1581,7 @@ impl Resolver {
false);
parent.external_module_children.insert(
name,
name.name,
external_module);
self.build_reduced_graph_for_external_crate(
@ -1727,7 +1726,7 @@ impl Resolver {
// Add it to the trait info if not static.
if explicit_self != sty_static {
interned_method_names.insert(method_name);
interned_method_names.insert(method_name.name);
}
}
for name in interned_method_names.iter() {
@ -1981,7 +1980,7 @@ impl Resolver {
self.idents_to_str(directive.module_path),
self.session.str_of(target));
match module_.import_resolutions.find(&target) {
match module_.import_resolutions.find(&target.name) {
Some(&resolution) => {
debug!("(building import directive) bumping \
reference");
@ -1996,7 +1995,7 @@ impl Resolver {
debug!("(building import directive) creating new");
let resolution = @mut ImportResolution::new(privacy, id);
resolution.outstanding_references = 1;
module_.import_resolutions.insert(target, resolution);
module_.import_resolutions.insert(target.name, resolution);
}
}
}
@ -2281,7 +2280,7 @@ impl Resolver {
// Search for direct children of the containing module.
self.populate_module_if_necessary(containing_module);
match containing_module.children.find(&source) {
match containing_module.children.find(&source.name) {
None => {
// Continue.
}
@ -2315,7 +2314,7 @@ impl Resolver {
// Now search the exported imports within the containing
// module.
match containing_module.import_resolutions.find(&source) {
match containing_module.import_resolutions.find(&source.name) {
None => {
// The containing module definitely doesn't have an
// exported import with the name in question. We can
@ -2386,7 +2385,7 @@ impl Resolver {
BoundResult(*) => {}
_ => {
match containing_module.external_module_children
.find(&source) {
.find(&source.name) {
None => {} // Continue.
Some(module) => {
let name_bindings =
@ -2400,8 +2399,8 @@ impl Resolver {
}
// We've successfully resolved the import. Write the results in.
assert!(module_.import_resolutions.contains_key(&target));
let import_resolution = module_.import_resolutions.get(&target);
assert!(module_.import_resolutions.contains_key(&target.name));
let import_resolution = module_.import_resolutions.get(&target.name);
match value_result {
BoundResult(target_module, name_bindings) => {
@ -2563,15 +2562,15 @@ impl Resolver {
}
}
let merge_import_resolution = |ident,
let merge_import_resolution = |name,
name_bindings: @mut NameBindings| {
let dest_import_resolution;
match module_.import_resolutions.find(&ident) {
match module_.import_resolutions.find(&name) {
None => {
// Create a new import resolution from this child.
dest_import_resolution = @mut ImportResolution::new(privacy, id);
module_.import_resolutions.insert
(ident, dest_import_resolution);
(name, dest_import_resolution);
}
Some(&existing_import_resolution) => {
dest_import_resolution = existing_import_resolution;
@ -2580,7 +2579,7 @@ impl Resolver {
debug!("(resolving glob import) writing resolution `%s` in `%s` \
to `%s`, privacy=%?",
self.session.str_of(ident),
interner_get(name),
self.module_to_str(containing_module),
self.module_to_str(module_),
dest_import_resolution.privacy);
@ -2602,15 +2601,15 @@ impl Resolver {
// Add all children from the containing module.
self.populate_module_if_necessary(containing_module);
for (&ident, name_bindings) in containing_module.children.iter() {
merge_import_resolution(ident, *name_bindings);
for (&name, name_bindings) in containing_module.children.iter() {
merge_import_resolution(name, *name_bindings);
}
// Add external module children from the containing module.
for (&ident, module) in containing_module.external_module_children.iter() {
for (&name, module) in containing_module.external_module_children.iter() {
let name_bindings =
@mut Resolver::create_name_bindings_from_module(*module);
merge_import_resolution(ident, name_bindings);
merge_import_resolution(name, name_bindings);
}
debug!("(resolving glob import) successfully resolved import");
@ -2836,7 +2835,7 @@ impl Resolver {
// The current module node is handled specially. First, check for
// its immediate children.
self.populate_module_if_necessary(module_);
match module_.children.find(&name) {
match module_.children.find(&name.name) {
Some(name_bindings)
if name_bindings.defined_in_namespace(namespace) => {
return Success(Target::new(module_, *name_bindings));
@ -2848,7 +2847,7 @@ impl Resolver {
// all its imports in the usual way; this is because chains of
// adjacent import statements are processed as though they mutated the
// current scope.
match module_.import_resolutions.find(&name) {
match module_.import_resolutions.find(&name.name) {
None => {
// Not found; continue.
}
@ -2872,7 +2871,7 @@ impl Resolver {
// Search for external modules.
if namespace == TypeNS {
match module_.external_module_children.find(&name) {
match module_.external_module_children.find(&name.name) {
None => {}
Some(module) => {
let name_bindings =
@ -3034,8 +3033,9 @@ impl Resolver {
}
}
/// Resolves a "module prefix". A module prefix is one of (a) `self::`;
/// Resolves a "module prefix". A module prefix is one or both of (a) `self::`;
/// (b) some chain of `super::`.
/// grammar: (SELF MOD_SEP ) ? (SUPER MOD_SEP) *
pub fn resolve_module_prefix(@mut self,
module_: @mut Module,
module_path: &[Ident])
@ -3091,7 +3091,7 @@ impl Resolver {
// First, check the direct children of the module.
self.populate_module_if_necessary(module_);
match module_.children.find(&name) {
match module_.children.find(&name.name) {
Some(name_bindings)
if name_bindings.defined_in_namespace(namespace) => {
debug!("(resolving name in module) found node as child");
@ -3112,7 +3112,7 @@ impl Resolver {
}
// Check the list of resolved imports.
match module_.import_resolutions.find(&name) {
match module_.import_resolutions.find(&name.name) {
Some(import_resolution) => {
if import_resolution.privacy == Public &&
import_resolution.outstanding_references != 0 {
@ -3147,7 +3147,7 @@ impl Resolver {
// Finally, search through external children.
if namespace == TypeNS {
match module_.external_module_children.find(&name) {
match module_.external_module_children.find(&name.name) {
None => {}
Some(module) => {
let name_bindings =
@ -3273,7 +3273,7 @@ impl Resolver {
pub fn add_exports_of_namebindings(@mut self,
exports2: &mut ~[Export2],
ident: Ident,
name: Name,
namebindings: @mut NameBindings,
ns: Namespace,
reexport: bool) {
@ -3282,11 +3282,11 @@ impl Resolver {
(Some(d), Some(Public)) => {
debug!("(computing exports) YES: %s '%s' => %?",
if reexport { ~"reexport" } else { ~"export"},
self.session.str_of(ident),
interner_get(name),
def_id_of_def(d));
exports2.push(Export2 {
reexport: reexport,
name: self.session.str_of(ident),
name: interner_get(name),
def_id: def_id_of_def(d)
});
}
@ -3302,10 +3302,10 @@ impl Resolver {
pub fn add_exports_for_module(@mut self,
exports2: &mut ~[Export2],
module_: @mut Module) {
for (ident, importresolution) in module_.import_resolutions.iter() {
for (name, importresolution) in module_.import_resolutions.iter() {
if importresolution.privacy != Public {
debug!("(computing exports) not reexporting private `%s`",
self.session.str_of(*ident));
interner_get(*name));
loop;
}
let xs = [TypeNS, ValueNS];
@ -3313,9 +3313,9 @@ impl Resolver {
match importresolution.target_for_namespace(*ns) {
Some(target) => {
debug!("(computing exports) maybe reexport '%s'",
self.session.str_of(*ident));
interner_get(*name));
self.add_exports_of_namebindings(&mut *exports2,
*ident,
*name,
target.bindings,
*ns,
true)
@ -3354,7 +3354,7 @@ impl Resolver {
}
Some(name) => {
self.populate_module_if_necessary(orig_module);
match orig_module.children.find(&name) {
match orig_module.children.find(&name.name) {
None => {
debug!("!!! (with scope) didn't find `%s` in `%s`",
self.session.str_of(name),
@ -3498,7 +3498,7 @@ impl Resolver {
pub fn search_ribs(@mut self,
ribs: &mut ~[@Rib],
name: Ident,
name: Name,
span: Span,
allow_capturing_self: AllowCapturingSelfFlag)
-> Option<DefLike> {
@ -3508,7 +3508,7 @@ impl Resolver {
let mut i = ribs.len();
while i != 0 {
i -= 1;
match ribs[i].bindings.find(&name.name) {
match ribs[i].bindings.find(&name) {
Some(&def_like) => {
return self.upvarify(ribs, i, def_like, span,
allow_capturing_self);
@ -3591,7 +3591,9 @@ impl Resolver {
// Create a new rib for the self type.
let self_type_rib = @Rib::new(NormalRibKind);
self.type_ribs.push(self_type_rib);
self_type_rib.bindings.insert(self.type_self_ident.name,
// plain insert (no renaming)
let name = self.type_self_ident.name;
self_type_rib.bindings.insert(name,
DlDef(DefSelfTy(item.id)));
// Create a new rib for the trait-wide type parameters.
@ -3733,6 +3735,7 @@ impl Resolver {
// the item that bound it
self.record_def(type_parameter.id,
DefTyParamBinder(node_id));
// plain insert (no renaming)
function_type_rib.bindings.insert(ident.name, def_like);
}
}
@ -4067,8 +4070,8 @@ impl Resolver {
pub fn binding_mode_map(@mut self, pat: @Pat) -> BindingMap {
let mut result = HashMap::new();
do pat_bindings(self.def_map, pat) |binding_mode, _id, sp, path| {
let ident = path_to_ident(path);
result.insert(ident,
let name = path_to_ident(path).name; // mtwt_resolve(path_to_ident(path));
result.insert(name,
binding_info {span: sp,
binding_mode: binding_mode});
}
@ -4088,7 +4091,7 @@ impl Resolver {
p.span,
fmt!("variable `%s` from pattern #1 is \
not bound in pattern #%u",
self.session.str_of(key), i + 1));
interner_get(key), i + 1));
}
Some(binding_i) => {
if binding_0.binding_mode != binding_i.binding_mode {
@ -4096,7 +4099,7 @@ impl Resolver {
binding_i.span,
fmt!("variable `%s` is bound with different \
mode in pattern #%u than in pattern #1",
self.session.str_of(key), i + 1));
interner_get(key), i + 1));
}
}
}
@ -4108,7 +4111,7 @@ impl Resolver {
binding.span,
fmt!("variable `%s` from pattern #%u is \
not bound in pattern #1",
self.session.str_of(key), i + 1));
interner_get(key), i + 1));
}
}
}
@ -4170,11 +4173,11 @@ impl Resolver {
// First, check to see whether the name is a primitive type.
if path.segments.len() == 1 {
let name = path.segments.last().identifier;
let id = path.segments.last().identifier;
match self.primitive_type_table
.primitive_types
.find(&name) {
.find(&id.name) {
Some(&primitive_type) => {
result_def =
@ -4272,7 +4275,7 @@ impl Resolver {
mutability: Mutability,
// Maps idents to the node ID for the (outermost)
// pattern that binds them
bindings_list: Option<@mut HashMap<Ident,NodeId>>,
bindings_list: Option<@mut HashMap<Name,NodeId>>,
visitor: &mut ResolveVisitor) {
let pat_id = pattern.id;
do walk_pat(pattern) |pattern| {
@ -4290,13 +4293,14 @@ impl Resolver {
// what you want).
let ident = path.segments[0].identifier;
let renamed = ident.name; // mtwt_resolve(ident);
match self.resolve_bare_identifier_pattern(ident) {
FoundStructOrEnumVariant(def)
if mode == RefutableMode => {
debug!("(resolving pattern) resolving `%s` to \
struct or enum variant",
self.session.str_of(ident));
interner_get(renamed));
self.enforce_default_binding_mode(
pattern,
@ -4310,13 +4314,12 @@ impl Resolver {
shadows an enum \
variant or unit-like \
struct in scope",
self.session
.str_of(ident)));
interner_get(renamed)));
}
FoundConst(def) if mode == RefutableMode => {
debug!("(resolving pattern) resolving `%s` to \
constant",
self.session.str_of(ident));
interner_get(renamed));
self.enforce_default_binding_mode(
pattern,
@ -4331,7 +4334,7 @@ impl Resolver {
}
BareIdentifierPatternUnresolved => {
debug!("(resolving pattern) binding `%s`",
self.session.str_of(ident));
interner_get(renamed));
let is_mutable = mutability == Mutable;
@ -4366,16 +4369,16 @@ impl Resolver {
match bindings_list {
Some(bindings_list)
if !bindings_list.contains_key(&ident) => {
if !bindings_list.contains_key(&renamed) => {
let this = &mut *self;
let last_rib = this.value_ribs[
this.value_ribs.len() - 1];
last_rib.bindings.insert(ident.name,
last_rib.bindings.insert(renamed,
DlDef(def));
bindings_list.insert(ident, pat_id);
bindings_list.insert(renamed, pat_id);
}
Some(b) => {
if b.find(&ident) == Some(&pat_id) {
if b.find(&renamed) == Some(&pat_id) {
// Then this is a duplicate variable
// in the same disjunct, which is an
// error
@ -4391,7 +4394,7 @@ impl Resolver {
let this = &mut *self;
let last_rib = this.value_ribs[
this.value_ribs.len() - 1];
last_rib.bindings.insert(ident.name,
last_rib.bindings.insert(renamed,
DlDef(def));
}
}
@ -4640,7 +4643,7 @@ impl Resolver {
-> NameDefinition {
// First, search children.
self.populate_module_if_necessary(containing_module);
match containing_module.children.find(&name) {
match containing_module.children.find(&name.name) {
Some(child_name_bindings) => {
match (child_name_bindings.def_for_namespace(namespace),
child_name_bindings.privacy_for_namespace(namespace)) {
@ -4663,7 +4666,7 @@ impl Resolver {
}
// Next, search import resolutions.
match containing_module.import_resolutions.find(&name) {
match containing_module.import_resolutions.find(&name.name) {
Some(import_resolution) if import_resolution.privacy == Public ||
xray == Xray => {
match (*import_resolution).target_for_namespace(namespace) {
@ -4691,7 +4694,7 @@ impl Resolver {
// Finally, search through external children.
if namespace == TypeNS {
match containing_module.external_module_children.find(&name) {
match containing_module.external_module_children.find(&name.name) {
None => {}
Some(module) => {
match module.def_id {
@ -4738,9 +4741,9 @@ impl Resolver {
}
}
let name = path.segments.last().identifier;
let ident = path.segments.last().identifier;
let def = match self.resolve_definition_of_name_in_module(containing_module,
name,
ident,
namespace,
xray) {
NoNameDefinition => {
@ -4753,7 +4756,7 @@ impl Resolver {
};
match containing_module.kind {
TraitModuleKind | ImplModuleKind => {
match self.method_map.find(&name) {
match self.method_map.find(&ident.name) {
Some(s) => {
match containing_module.def_id {
Some(def_id) if s.contains(&def_id) => {
@ -4830,12 +4833,14 @@ impl Resolver {
let search_result;
match namespace {
ValueNS => {
search_result = self.search_ribs(self.value_ribs, ident,
let renamed = ident.name; // mtwt_resolve(ident);
search_result = self.search_ribs(self.value_ribs, renamed,
span,
DontAllowCapturingSelf);
}
TypeNS => {
search_result = self.search_ribs(self.type_ribs, ident,
let name = ident.name;
search_result = self.search_ribs(self.type_ribs, name,
span, AllowCapturingSelf);
}
}
@ -5135,6 +5140,7 @@ impl Resolver {
let this = &mut *self;
let def_like = DlDef(DefLabel(expr.id));
let rib = this.label_ribs[this.label_ribs.len() - 1];
// plain insert (no renaming)
rib.bindings.insert(label.name, def_like);
}
@ -5145,7 +5151,8 @@ impl Resolver {
ExprForLoop(*) => fail!("non-desugared expr_for_loop"),
ExprBreak(Some(label)) | ExprAgain(Some(label)) => {
match self.search_ribs(self.label_ribs, label, expr.span,
let name = label.name;
match self.search_ribs(self.label_ribs, name, expr.span,
DontAllowCapturingSelf) {
None =>
self.resolve_error(expr.span,
@ -5273,7 +5280,7 @@ impl Resolver {
let mut found_traits = ~[];
let mut search_module = self.current_module;
match self.method_map.find(&name) {
match self.method_map.find(&name.name) {
Some(candidate_traits) => loop {
// Look for the current trait.
match self.current_trait_refs {
@ -5495,7 +5502,7 @@ impl Resolver {
debug!("Children:");
self.populate_module_if_necessary(module_);
for (&name, _) in module_.children.iter() {
debug!("* %s", self.session.str_of(name));
debug!("* %s", interner_get(name));
}
debug!("Import resolutions:");
@ -5518,7 +5525,7 @@ impl Resolver {
}
}
debug!("* %s:%s%s", self.session.str_of(*name),
debug!("* %s:%s%s", interner_get(*name),
value_repr, type_repr);
}
}

4
src/librustc/middle/trans/_match.rs
View file

@ -1482,7 +1482,7 @@ fn compile_submatch_continue(mut bcx: @mut Block,
let pat_repr = adt::represent_type(bcx.ccx(), pat_ty);
do expr::with_field_tys(tcx, pat_ty, None) |discr, field_tys| {
let rec_vals = rec_fields.map(|field_name| {
let ix = ty::field_idx_strict(tcx, *field_name, field_tys);
let ix = ty::field_idx_strict(tcx, field_name.name, field_tys);
adt::trans_field_ptr(bcx, pat_repr, val, discr, ix)
});
compile_submatch(
@ -2159,7 +2159,7 @@ fn bind_irrefutable_pat(bcx: @mut Block,
let pat_repr = adt::represent_type(bcx.ccx(), pat_ty);
do expr::with_field_tys(tcx, pat_ty, None) |discr, field_tys| {
for f in fields.iter() {
let ix = ty::field_idx_strict(tcx, f.ident, field_tys);
let ix = ty::field_idx_strict(tcx, f.ident.name, field_tys);
let fldptr = adt::trans_field_ptr(bcx, pat_repr, val,
discr, ix);
bcx = bind_irrefutable_pat(bcx, f.pat, fldptr, binding_mode);

4
src/librustc/middle/trans/consts.rs
View file

@ -374,7 +374,7 @@ fn const_expr_unadjusted(cx: @mut CrateContext, e: &ast::Expr) -> ValueRef {
let brepr = adt::represent_type(cx, bt);
let bv = const_expr(cx, base);
do expr::with_field_tys(cx.tcx, bt, None) |discr, field_tys| {
let ix = ty::field_idx_strict(cx.tcx, field, field_tys);
let ix = ty::field_idx_strict(cx.tcx, field.name, field_tys);
adt::const_get_field(cx, brepr, bv, discr, ix)
}
}
@ -502,7 +502,7 @@ fn const_expr_unadjusted(cx: @mut CrateContext, e: &ast::Expr) -> ValueRef {
|discr, field_tys| {
let cs: ~[ValueRef] = field_tys.iter().enumerate()
.map(|(ix, &field_ty)| {
match fs.iter().find(|f| field_ty.ident == f.ident) {
match fs.iter().find(|f| field_ty.ident.name == f.ident.name) {
Some(f) => const_expr(cx, (*f).expr),
None => {
match base_val {

5
src/librustc/middle/trans/expr.rs
View file

@ -903,7 +903,7 @@ fn trans_lvalue_unadjusted(bcx: @mut Block, expr: @ast::Expr) -> DatumBlock {
let base_datum = unpack_datum!(bcx, trans_to_datum(bcx, base));
let repr = adt::represent_type(bcx.ccx(), base_datum.ty);
do with_field_tys(bcx.tcx(), base_datum.ty, None) |discr, field_tys| {
let ix = ty::field_idx_strict(bcx.tcx(), field, field_tys);
let ix = ty::field_idx_strict(bcx.tcx(), field.name, field_tys);
DatumBlock {
datum: do base_datum.get_element(bcx,
field_tys[ix].mt.ty,
@ -1176,7 +1176,8 @@ fn trans_rec_or_struct(bcx: @mut Block,
let mut need_base = vec::from_elem(field_tys.len(), true);
let numbered_fields = do fields.map |field| {
let opt_pos = field_tys.iter().position(|field_ty| field_ty.ident == field.ident);
let opt_pos = field_tys.iter().position(|field_ty|
field_ty.ident.name == field.ident.name);
match opt_pos {
Some(i) => {
need_base[i] = false;

3
src/librustc/middle/trans/meth.rs
View file

@ -295,6 +295,7 @@ pub fn trans_static_method_callee(bcx: @mut Block,
pub fn method_with_name(ccx: &mut CrateContext,
impl_id: ast::DefId,
name: ast::Ident) -> ast::DefId {
// NOTE : SHOULD USE NAME (chonged later)
let meth_id_opt = ccx.impl_method_cache.find_copy(&(impl_id, name));
match meth_id_opt {
Some(m) => return m,
@ -303,7 +304,7 @@ pub fn method_with_name(ccx: &mut CrateContext,
let imp = ccx.tcx.impls.find(&impl_id)
.expect("could not find impl while translating");
let meth = imp.methods.iter().find(|m| m.ident == name)
let meth = imp.methods.iter().find(|m| m.ident.name == name.name)
.expect("could not find method while translating");
ccx.impl_method_cache.insert((impl_id, name), meth.def_id);

10
src/librustc/middle/ty.rs
View file

@ -3360,19 +3360,19 @@ pub fn stmt_node_id(s: &ast::Stmt) -> ast::NodeId {
}
}
pub fn field_idx(id: ast::Ident, fields: &[field]) -> Option<uint> {
pub fn field_idx(name: ast::Name, fields: &[field]) -> Option<uint> {
let mut i = 0u;
for f in fields.iter() { if f.ident == id { return Some(i); } i += 1u; }
for f in fields.iter() { if f.ident.name == name { return Some(i); } i += 1u; }
return None;
}
pub fn field_idx_strict(tcx: ty::ctxt, id: ast::Ident, fields: &[field])
pub fn field_idx_strict(tcx: ty::ctxt, name: ast::Name, fields: &[field])
-> uint {
let mut i = 0u;
for f in fields.iter() { if f.ident == id { return i; } i += 1u; }
for f in fields.iter() { if f.ident.name == name { return i; } i += 1u; }
tcx.sess.bug(fmt!(
"No field named `%s` found in the list of fields `%?`",
tcx.sess.str_of(id),
token::interner_get(name),
fields.map(|f| tcx.sess.str_of(f.ident))));
}

11
src/librustc/middle/typeck/check/method.rs
View file

@ -105,6 +105,7 @@ use syntax::ast::{sty_uniq, sty_static, NodeId};
use syntax::ast::{MutMutable, MutImmutable};
use syntax::ast;
use syntax::ast_map;
use syntax::parse::token;
#[deriving(Eq)]
pub enum CheckTraitsFlag {
@ -126,7 +127,7 @@ pub fn lookup(
self_expr: @ast::Expr, // The expression `a`.
callee_id: NodeId, /* Where to store `a.b`'s type,
* also the scope of the call */
m_name: ast::Ident, // The ident `b`.
m_name: ast::Name, // The name `b`.
self_ty: ty::t, // The type of `a`.
supplied_tps: &[ty::t], // The list of types X, Y, ... .
deref_args: check::DerefArgs, // Whether we autopointer first.
@ -173,7 +174,7 @@ pub struct LookupContext<'self> {
expr: @ast::Expr,
self_expr: @ast::Expr,
callee_id: NodeId,
m_name: ast::Ident,
m_name: ast::Name,
supplied_tps: &'self [ty::t],
impl_dups: @mut HashSet<DefId>,
inherent_candidates: @mut ~[Candidate],
@ -515,7 +516,7 @@ impl<'self> LookupContext<'self> {
let trait_methods = ty::trait_methods(tcx, bound_trait_ref.def_id);
match trait_methods.iter().position(|m| {
m.explicit_self != ast::sty_static &&
m.ident == self.m_name })
m.ident.name == self.m_name })
{
Some(pos) => {
let method = trait_methods[pos];
@ -558,12 +559,12 @@ impl<'self> LookupContext<'self> {
return; // already visited
}
debug!("push_candidates_from_impl: %s %s %s",
self.m_name.repr(self.tcx()),
token::interner_get(self.m_name),
impl_info.ident.repr(self.tcx()),
impl_info.methods.map(|m| m.ident).repr(self.tcx()));
let idx = {
match impl_info.methods.iter().position(|m| m.ident == self.m_name) {
match impl_info.methods.iter().position(|m| m.ident.name == self.m_name) {
Some(idx) => idx,
None => { return; } // No method with the right name.
}

32
src/librustc/middle/typeck/check/mod.rs
View file

@ -1117,10 +1117,10 @@ pub fn impl_self_ty(vcx: &VtableContext,
pub fn lookup_field_ty(tcx: ty::ctxt,
class_id: ast::DefId,
items: &[ty::field_ty],
fieldname: ast::Ident,
fieldname: ast::Name,
substs: &ty::substs) -> Option<ty::t> {
let o_field = items.iter().find(|f| f.ident == fieldname);
let o_field = items.iter().find(|f| f.ident.name == fieldname);
do o_field.map() |f| {
ty::lookup_field_type(tcx, class_id, f.id, substs)
}
@ -1553,7 +1553,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
expr,
rcvr,
callee_id,
method_name,
method_name.name,
expr_t,
tps,
DontDerefArgs,
@ -1637,7 +1637,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
op_ex: @ast::Expr,
self_ex: @ast::Expr,
self_t: ty::t,
opname: ast::Ident,
opname: ast::Name,
args: ~[@ast::Expr],
deref_args: DerefArgs,
autoderef_receiver: AutoderefReceiverFlag,
@ -1777,7 +1777,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
lhs_resolved_t, None)
};
return lookup_op_method(fcx, callee_id, ex, lhs_expr, lhs_resolved_t,
fcx.tcx().sess.ident_of(*name),
token::intern(*name),
~[rhs], DoDerefArgs, DontAutoderefReceiver, if_op_unbound,
expected_result);
}
@ -1811,7 +1811,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
-> ty::t {
lookup_op_method(
fcx, callee_id, ex, rhs_expr, rhs_t,
fcx.tcx().sess.ident_of(mname), ~[],
token::intern(mname), ~[],
DoDerefArgs, DontAutoderefReceiver,
|| {
fcx.type_error_message(ex.span, |actual| {
@ -1937,7 +1937,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
fn check_field(fcx: @mut FnCtxt,
expr: @ast::Expr,
base: @ast::Expr,
field: ast::Ident,
field: ast::Name,
tys: &[ast::Ty]) {
let tcx = fcx.ccx.tcx;
let bot = check_expr(fcx, base);
@ -1985,7 +1985,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
|actual| {
fmt!("attempted to take value of method `%s` on type `%s` \
(try writing an anonymous function)",
tcx.sess.str_of(field), actual)
token::interner_get(field), actual)
},
expr_t, None);
}
@ -1996,7 +1996,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
|actual| {
fmt!("attempted access of field `%s` on type `%s`, \
but no field with that name was found",
tcx.sess.str_of(field), actual)
token::interner_get(field), actual)
},
expr_t, None);
}
@ -2018,7 +2018,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
let mut class_field_map = HashMap::new();
let mut fields_found = 0;
for field in field_types.iter() {
class_field_map.insert(field.ident, (field.id, false));
class_field_map.insert(field.ident.name, (field.id, false));
}
let mut error_happened = false;
@ -2027,7 +2027,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
for field in ast_fields.iter() {
let mut expected_field_type = ty::mk_err();
let pair = class_field_map.find(&field.ident).map_move(|x| *x);
let pair = class_field_map.find(&field.ident.name).map_move(|x| *x);
match pair {
None => {
tcx.sess.span_err(
@ -2048,7 +2048,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
ty::lookup_field_type(
tcx, class_id, field_id, &substitutions);
class_field_map.insert(
field.ident, (field_id, true));
field.ident.name, (field_id, true));
fields_found += 1;
}
}
@ -2070,11 +2070,11 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
if fields_found < field_types.len() {
let mut missing_fields = ~[];
for class_field in field_types.iter() {
let name = class_field.ident;
let name = class_field.ident.name;
let (_, seen) = *class_field_map.get(&name);
if !seen {
missing_fields.push(
~"`" + tcx.sess.str_of(name) + "`");
~"`" + token::interner_get(name) + "`");
}
}
@ -2846,7 +2846,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
}
}
ast::ExprField(base, field, ref tys) => {
check_field(fcx, expr, base, field, *tys);
check_field(fcx, expr, base, field.name, *tys);
}
ast::ExprIndex(callee_id, base, idx) => {
check_expr(fcx, base);
@ -2886,7 +2886,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
expr,
base,
resolved,
index_ident,
index_ident.name,
~[idx],
DoDerefArgs,
AutoderefReceiver,

4
src/librustc/middle/typeck/coherence.rs
View file

@ -553,13 +553,13 @@ impl CoherenceChecker {
let mut provided_names = HashSet::new();
// Implemented methods
for elt in all_methods.iter() {
provided_names.insert(elt.ident);
provided_names.insert(elt.ident.name);
}
let r = ty::trait_methods(tcx, trait_did);
for method in r.iter() {
debug!("checking for %s", method.ident.repr(tcx));
if provided_names.contains(&method.ident) { loop; }
if provided_names.contains(&method.ident.name) { loop; }
tcx.sess.span_err(trait_ref_span,
fmt!("missing method `%s`",

2
src/librustc/middle/typeck/collect.rs
View file

@ -698,7 +698,7 @@ pub fn check_methods_against_trait(ccx: &CrateCtxt,
// we'll catch it in coherence
let trait_ms = ty::trait_methods(tcx, trait_ref.def_id);
for impl_m in impl_ms.iter() {
match trait_ms.iter().find(|trait_m| trait_m.ident == impl_m.mty.ident) {
match trait_ms.iter().find(|trait_m| trait_m.ident.name == impl_m.mty.ident.name) {
Some(trait_m) => {
let num_impl_tps = generics.ty_params.len();
compare_impl_method(