use middle::lang_items::LanguageItems;
use middle::lint::{UnnecessaryQualification, UnusedImports};
use middle::pat_util::pat_bindings;
+use util::nodemap::{NodeMap, DefIdSet};
use syntax::ast::*;
use syntax::ast;
-use syntax::ast_util::{def_id_of_def, local_def, mtwt_resolve};
+use syntax::ast_util::{def_id_of_def, local_def};
use syntax::ast_util::{path_to_ident, walk_pat, trait_method_to_ty_method};
+use syntax::ext::mtwt;
use syntax::parse::token::special_idents;
use syntax::parse::token;
use syntax::print::pprust::path_to_str;
use syntax::codemap::{Span, DUMMY_SP, Pos};
-use syntax::opt_vec::OptVec;
+use syntax::owned_slice::OwnedSlice;
use syntax::visit;
use syntax::visit::Visitor;
use collections::{HashMap, HashSet};
// Definition mapping
-pub type DefMap = @RefCell<HashMap<NodeId,Def>>;
+pub type DefMap = @RefCell<NodeMap<Def>>;
struct binding_info {
span: Span,
type BindingMap = HashMap<Name,binding_info>;
// Trait method resolution
-pub type TraitMap = HashMap<NodeId,@RefCell<~[DefId]>>;
+pub type TraitMap = NodeMap<Vec<DefId> >;
// This is the replacement export map. It maps a module to all of the exports
// within.
-pub type ExportMap2 = @RefCell<HashMap<NodeId, ~[Export2]>>;
+pub type ExportMap2 = @RefCell<NodeMap<Vec<Export2> >>;
pub struct Export2 {
name: ~str, // The name of the target.
// This set contains all exported definitions from external crates. The set does
// not contain any entries from local crates.
-pub type ExternalExports = HashSet<DefId>;
+pub type ExternalExports = DefIdSet;
// FIXME: dox
-pub type LastPrivateMap = HashMap<NodeId, LastPrivate>;
+pub type LastPrivateMap = NodeMap<LastPrivate>;
pub enum LastPrivate {
LastMod(PrivateDep),
ArgumentIrrefutableMode,
}
-#[deriving(Eq, Hash)]
+#[deriving(Eq, TotalEq, Hash)]
enum Namespace {
TypeNS,
ValueNS
ImportNameDefinition(Def, LastPrivate) //< The name identifies an import.
}
-impl Visitor<()> for Resolver {
+impl<'a> Visitor<()> for Resolver<'a> {
fn visit_item(&mut self, item: &Item, _: ()) {
self.resolve_item(item);
}
/// One import directive.
struct ImportDirective {
- module_path: ~[Ident],
+ module_path: Vec<Ident> ,
subclass: @ImportDirectiveSubclass,
span: Span,
id: NodeId,
}
impl ImportDirective {
- fn new(module_path: ~[Ident],
+ fn new(module_path: Vec<Ident> ,
subclass: @ImportDirectiveSubclass,
span: Span,
id: NodeId,
is_public: bool,
children: RefCell<HashMap<Name, @NameBindings>>,
- imports: RefCell<~[@ImportDirective]>,
+ imports: RefCell<Vec<@ImportDirective> >,
// The external module children of this node that were declared with
// `extern crate`.
//
// There will be an anonymous module created around `g` with the ID of the
// entry block for `f`.
- anonymous_children: RefCell<HashMap<NodeId,@Module>>,
+ anonymous_children: RefCell<NodeMap<@Module>>,
// The status of resolving each import in this module.
import_resolutions: RefCell<HashMap<Name, @ImportResolution>>,
kind: Cell::new(kind),
is_public: is_public,
children: RefCell::new(HashMap::new()),
- imports: RefCell::new(~[]),
+ imports: RefCell::new(Vec::new()),
external_module_children: RefCell::new(HashMap::new()),
- anonymous_children: RefCell::new(HashMap::new()),
+ anonymous_children: RefCell::new(NodeMap::new()),
import_resolutions: RefCell::new(HashMap::new()),
glob_count: Cell::new(0),
resolved_import_count: Cell::new(0),
}
fn all_imports_resolved(&self) -> bool {
- let mut imports = self.imports.borrow_mut();
- return imports.get().len() == self.resolved_import_count.get();
+ self.imports.borrow().len() == self.resolved_import_count.get()
}
}
/// Returns the module node if applicable.
fn get_module_if_available(&self) -> Option<@Module> {
- let type_def = self.type_def.borrow();
- match *type_def.get() {
+ match *self.type_def.borrow() {
Some(ref type_def) => (*type_def).module_def,
None => None
}
}
}
-fn Resolver(session: Session,
- lang_items: @LanguageItems,
- crate_span: Span) -> Resolver {
+fn Resolver<'a>(session: &'a Session,
+ lang_items: @LanguageItems,
+ crate_span: Span) -> Resolver<'a> {
let graph_root = @NameBindings();
graph_root.define_module(NoParentLink,
let current_module = graph_root.get_module();
let this = Resolver {
- session: @session,
+ session: session,
lang_items: lang_items,
// The outermost module has def ID 0; this is not reflected in the
unresolved_imports: 0,
current_module: current_module,
- value_ribs: @RefCell::new(~[]),
- type_ribs: @RefCell::new(~[]),
- label_ribs: @RefCell::new(~[]),
+ value_ribs: @RefCell::new(Vec::new()),
+ type_ribs: @RefCell::new(Vec::new()),
+ label_ribs: @RefCell::new(Vec::new()),
current_trait_refs: None,
primitive_type_table: @PrimitiveTypeTable(),
- namespaces: ~[ TypeNS, ValueNS ],
+ namespaces: vec!(TypeNS, ValueNS),
- def_map: @RefCell::new(HashMap::new()),
- export_map2: @RefCell::new(HashMap::new()),
- trait_map: HashMap::new(),
+ def_map: @RefCell::new(NodeMap::new()),
+ export_map2: @RefCell::new(NodeMap::new()),
+ trait_map: NodeMap::new(),
used_imports: HashSet::new(),
- external_exports: HashSet::new(),
- last_private: HashMap::new(),
+ external_exports: DefIdSet::new(),
+ last_private: NodeMap::new(),
emit_errors: true,
};
}
/// The main resolver class.
-struct Resolver {
- session: @Session,
+struct Resolver<'a> {
+ session: &'a Session,
lang_items: @LanguageItems,
graph_root: @NameBindings,
// The current set of local scopes, for values.
// FIXME #4948: Reuse ribs to avoid allocation.
- value_ribs: @RefCell<~[@Rib]>,
+ value_ribs: @RefCell<Vec<@Rib> >,
// The current set of local scopes, for types.
- type_ribs: @RefCell<~[@Rib]>,
+ type_ribs: @RefCell<Vec<@Rib> >,
// The current set of local scopes, for labels.
- label_ribs: @RefCell<~[@Rib]>,
+ label_ribs: @RefCell<Vec<@Rib> >,
// The trait that the current context can refer to.
- current_trait_refs: Option<~[DefId]>,
+ current_trait_refs: Option<Vec<DefId> >,
// The ident for the keyword "self".
self_ident: Ident,
primitive_type_table: @PrimitiveTypeTable,
// The four namespaces.
- namespaces: ~[Namespace],
+ namespaces: Vec<Namespace> ,
def_map: DefMap,
export_map2: ExportMap2,
used_imports: HashSet<(NodeId, Namespace)>,
}
-struct BuildReducedGraphVisitor<'a> {
- resolver: &'a mut Resolver,
+struct BuildReducedGraphVisitor<'a, 'b> {
+ resolver: &'a mut Resolver<'b>,
}
-impl<'a> Visitor<ReducedGraphParent> for BuildReducedGraphVisitor<'a> {
+impl<'a, 'b> Visitor<ReducedGraphParent> for BuildReducedGraphVisitor<'a, 'b> {
fn visit_item(&mut self, item: &Item, context: ReducedGraphParent) {
let p = self.resolver.build_reduced_graph_for_item(item, context);
}
-struct UnusedImportCheckVisitor<'a> { resolver: &'a mut Resolver }
+struct UnusedImportCheckVisitor<'a, 'b> { resolver: &'a mut Resolver<'b> }
-impl<'a> Visitor<()> for UnusedImportCheckVisitor<'a> {
+impl<'a, 'b> Visitor<()> for UnusedImportCheckVisitor<'a, 'b> {
fn visit_view_item(&mut self, vi: &ViewItem, _: ()) {
self.resolver.check_for_item_unused_imports(vi);
visit::walk_view_item(self, vi, ());
}
}
-impl Resolver {
+impl<'a> Resolver<'a> {
/// The main name resolution procedure.
fn resolve(&mut self, krate: &ast::Crate) {
self.build_reduced_graph(krate);
// Add or reuse the child.
let new_parent = ModuleReducedGraphParent(module_);
- let child_opt = {
- let children = module_.children.borrow();
- children.get().find_copy(&name.name)
- };
+ let child_opt = module_.children.borrow().find_copy(&name.name);
match child_opt {
None => {
let child = @NameBindings();
- let mut children = module_.children.borrow_mut();
- children.get().insert(name.name, child);
+ module_.children.borrow_mut().insert(name.name, child);
return (child, new_parent);
}
Some(child) => {
TyPath(ref path, _, _) if path.segments.len() == 1 => {
let name = path_to_ident(path);
- let existing_parent_opt = {
- let children = parent.module().children.borrow();
- children.get().find_copy(&name.name)
- };
- let new_parent = match existing_parent_opt {
+ let parent_opt = parent.module().children.borrow()
+ .find_copy(&name.name);
+ let new_parent = match parent_opt {
// It already exists
Some(child) if child.get_module_if_available()
.is_some() &&
let def_id = local_def(item.id);
for (name, _) in method_names.iter() {
let mut method_map = self.method_map.borrow_mut();
- if !method_map.get().contains_key(name) {
- method_map.get().insert(*name, HashSet::new());
+ if !method_map.contains_key(name) {
+ method_map.insert(*name, HashSet::new());
}
- match method_map.get().find_mut(name) {
+ match method_map.find_mut(name) {
Some(s) => { s.insert(def_id); },
_ => fail!("can't happen"),
}
// globs and lists, the path is found directly in the AST;
// for simple paths we have to munge the path a little.
- let mut module_path = ~[];
+ let mut module_path = Vec::new();
match view_path.node {
ViewPathSimple(_, ref full_path, _) => {
let path_len = full_path.segments.len();
}
}
- ViewItemExternMod(name, _, node_id) => {
+ ViewItemExternCrate(name, _, node_id) => {
// n.b. we don't need to look at the path option here, because cstore already did
match self.session.cstore.find_extern_mod_stmt_cnum(node_id) {
Some(crate_id) => {
false,
true);
- {
- let mut external_module_children =
- parent.module().external_module_children.borrow_mut();
- external_module_children.get().insert(
- name.name,
- external_module);
- }
+ parent.module().external_module_children
+ .borrow_mut().insert(name.name,
+ external_module);
self.build_reduced_graph_for_external_crate(
external_module);
AnonymousModuleKind,
false,
false);
- {
- let mut anonymous_children = parent_module.anonymous_children
- .borrow_mut();
- anonymous_children.get().insert(block_id, new_module);
- ModuleReducedGraphParent(new_module)
- }
+ parent_module.anonymous_children.borrow_mut()
+ .insert(block_id, new_module);
+ ModuleReducedGraphParent(new_module)
} else {
parent
}
// to the trait info.
let method_def_ids =
- csearch::get_trait_method_def_ids(self.session.cstore, def_id);
+ csearch::get_trait_method_def_ids(&self.session.cstore, def_id);
let mut interned_method_names = HashSet::new();
for &method_def_id in method_def_ids.iter() {
let (method_name, explicit_self) =
- csearch::get_method_name_and_explicit_self(self.session.cstore,
+ csearch::get_method_name_and_explicit_self(&self.session.cstore,
method_def_id);
debug!("(building reduced graph for \
}
for name in interned_method_names.iter() {
let mut method_map = self.method_map.borrow_mut();
- if !method_map.get().contains_key(name) {
- method_map.get().insert(*name, HashSet::new());
+ if !method_map.contains_key(name) {
+ method_map.insert(*name, HashSet::new());
}
- match method_map.get().find_mut(name) {
+ match method_map.find_mut(name) {
Some(s) => { s.insert(def_id); },
_ => fail!("can't happen"),
}
crate) building type and value for {}",
final_ident);
child_name_bindings.define_type(def, DUMMY_SP, is_public);
- if csearch::get_struct_fields(self.session.cstore, def_id).len() == 0 {
+ if csearch::get_struct_fields(&self.session.cstore, def_id).len() == 0 {
child_name_bindings.define_value(def, DUMMY_SP, is_public);
}
self.structs.insert(def_id);
DefForeignMod(def_id) => {
// Foreign modules have no names. Recur and populate
// eagerly.
- csearch::each_child_of_item(self.session.cstore,
+ csearch::each_child_of_item(&self.session.cstore,
def_id,
|def_like,
child_ident,
}
DlImpl(def) => {
// We only process static methods of impls here.
- match csearch::get_type_name_if_impl(self.session.cstore, def) {
+ match csearch::get_type_name_if_impl(&self.session.cstore, def) {
None => {}
Some(final_ident) => {
let static_methods_opt =
- csearch::get_static_methods_if_impl(self.session.cstore, def);
+ csearch::get_static_methods_if_impl(&self.session.cstore, def);
match static_methods_opt {
Some(ref static_methods) if
static_methods.len() >= 1 => {
Some(def_id) => def_id,
};
- csearch::each_child_of_item(self.session.cstore,
+ csearch::each_child_of_item(&self.session.cstore,
def_id,
|def_like, child_ident, visibility| {
debug!("(populating external module) ... found ident: {}",
/// crate.
fn build_reduced_graph_for_external_crate(&mut self,
root: @Module) {
- csearch::each_top_level_item_of_crate(self.session.cstore,
+ csearch::each_top_level_item_of_crate(&self.session.cstore,
root.def_id
.get()
.unwrap()
/// Creates and adds an import directive to the given module.
fn build_import_directive(&mut self,
module_: @Module,
- module_path: ~[Ident],
+ module_path: Vec<Ident> ,
subclass: @ImportDirectiveSubclass,
span: Span,
id: NodeId,
let directive = @ImportDirective::new(module_path,
subclass, span, id,
is_public);
-
- {
- let mut imports = module_.imports.borrow_mut();
- imports.get().push(directive);
- }
-
+ module_.imports.borrow_mut().push(directive);
// Bump the reference count on the name. Or, if this is a glob, set
// the appropriate flag.
SingleImport(target, _) => {
debug!("(building import directive) building import \
directive: {}::{}",
- self.idents_to_str(directive.module_path),
+ self.idents_to_str(directive.module_path.as_slice()),
token::get_ident(target));
let mut import_resolutions = module_.import_resolutions
.borrow_mut();
- match import_resolutions.get().find(&target.name) {
+ match import_resolutions.find(&target.name) {
Some(&resolution) => {
debug!("(building import directive) bumping \
reference");
debug!("(building import directive) creating new");
let resolution = @ImportResolution::new(id, is_public);
resolution.outstanding_references.set(1);
- import_resolutions.get().insert(target.name,
- resolution);
+ import_resolutions.insert(target.name, resolution);
}
}
}
self.resolve_imports_for_module(module_);
self.populate_module_if_necessary(module_);
- {
- let children = module_.children.borrow();
- for (_, &child_node) in children.get().iter() {
- match child_node.get_module_if_available() {
- None => {
- // Nothing to do.
- }
- Some(child_module) => {
- self.resolve_imports_for_module_subtree(child_module);
- }
+ for (_, &child_node) in module_.children.borrow().iter() {
+ match child_node.get_module_if_available() {
+ None => {
+ // Nothing to do.
+ }
+ Some(child_module) => {
+ self.resolve_imports_for_module_subtree(child_module);
}
}
}
- let anonymous_children = module_.anonymous_children.borrow();
- for (_, &child_module) in anonymous_children.get().iter() {
+ for (_, &child_module) in module_.anonymous_children.borrow().iter() {
self.resolve_imports_for_module_subtree(child_module);
}
}
}
let mut imports = module.imports.borrow_mut();
- let import_count = imports.get().len();
+ let import_count = imports.len();
while module.resolved_import_count.get() < import_count {
let import_index = module.resolved_import_count.get();
- let import_directive = imports.get()[import_index];
+ let import_directive = *imports.get(import_index);
match self.resolve_import_for_module(module, import_directive) {
Failed => {
// We presumably emitted an error. Continue.
let msg = format!("failed to resolve import `{}`",
self.import_path_to_str(
- import_directive.module_path,
+ import_directive.module_path
+ .as_slice(),
*import_directive.subclass));
self.resolve_error(import_directive.span, msg);
}
}
fn path_idents_to_str(&mut self, path: &Path) -> ~str {
- let identifiers: ~[ast::Ident] = path.segments
+ let identifiers: Vec<ast::Ident> = path.segments
.iter()
.map(|seg| seg.identifier)
.collect();
- self.idents_to_str(identifiers)
+ self.idents_to_str(identifiers.as_slice())
}
fn import_directive_subclass_to_str(&mut self,
debug!("(resolving import for module) resolving import `{}::...` in \
`{}`",
- self.idents_to_str(*module_path),
+ self.idents_to_str(module_path.as_slice()),
self.module_to_str(module_));
// First, resolve the module path for the directive, if necessary.
Some((self.graph_root.get_module(), LastMod(AllPublic)))
} else {
match self.resolve_module_path(module_,
- *module_path,
+ module_path.as_slice(),
DontUseLexicalScope,
import_directive.span,
ImportSearch) {
// Search for direct children of the containing module.
self.populate_module_if_necessary(containing_module);
- {
- let children = containing_module.children.borrow();
- match children.get().find(&source.name) {
- None => {
- // Continue.
+ match containing_module.children.borrow().find(&source.name) {
+ None => {
+ // Continue.
+ }
+ Some(child_name_bindings) => {
+ if child_name_bindings.defined_in_namespace(ValueNS) {
+ value_result = BoundResult(containing_module,
+ *child_name_bindings);
}
- Some(child_name_bindings) => {
- if child_name_bindings.defined_in_namespace(ValueNS) {
- value_result = BoundResult(containing_module,
- *child_name_bindings);
- }
- if child_name_bindings.defined_in_namespace(TypeNS) {
- type_result = BoundResult(containing_module,
- *child_name_bindings);
- }
+ if child_name_bindings.defined_in_namespace(TypeNS) {
+ type_result = BoundResult(containing_module,
+ *child_name_bindings);
}
}
}
let import_resolutions = containing_module.import_resolutions
.borrow();
- match import_resolutions.get().find(&source.name) {
+ match import_resolutions.find(&source.name) {
None => {
// The containing module definitely doesn't have an
// exported import with the name in question. We can
match type_result {
BoundResult(..) => {}
_ => {
- let module_opt = {
- let mut external_module_children =
- containing_module.external_module_children
- .borrow_mut();
- external_module_children.get().find_copy(&source.name)
- };
- match module_opt {
+ match containing_module.external_module_children.borrow_mut()
+ .find_copy(&source.name) {
None => {} // Continue.
Some(module) => {
let name_bindings =
// We've successfully resolved the import. Write the results in.
let import_resolution = {
let import_resolutions = module_.import_resolutions.borrow();
- assert!(import_resolutions.get().contains_key(&target.name));
- import_resolutions.get().get_copy(&target.name)
+ assert!(import_resolutions.contains_key(&target.name));
+ import_resolutions.get_copy(&target.name)
};
match value_result {
let value_private = match import_resolution.value_target.get() {
Some(target) => {
let def = target.bindings.def_for_namespace(ValueNS).unwrap();
- let mut def_map = self.def_map.borrow_mut();
- def_map.get().insert(directive.id, def);
+ self.def_map.borrow_mut().insert(directive.id, def);
let did = def_id_of_def(def);
if value_used_public {Some(lp)} else {Some(DependsOn(did))}
},
let type_private = match import_resolution.type_target.get() {
Some(target) => {
let def = target.bindings.def_for_namespace(TypeNS).unwrap();
- let mut def_map = self.def_map.borrow_mut();
- def_map.get().insert(directive.id, def);
+ self.def_map.borrow_mut().insert(directive.id, def);
let did = def_id_of_def(def);
if type_used_public {Some(lp)} else {Some(DependsOn(did))}
},
// Add all resolved imports from the containing module.
let import_resolutions = containing_module.import_resolutions
.borrow();
- for (ident, target_import_resolution) in import_resolutions.get()
- .iter() {
+ for (ident, target_import_resolution) in import_resolutions.iter() {
debug!("(resolving glob import) writing module resolution \
{:?} into `{}`",
target_import_resolution.type_target.get().is_none(),
}
// Here we merge two import resolutions.
- let mut import_resolutions = module_.import_resolutions
- .borrow_mut();
- match import_resolutions.get().find(ident) {
+ let mut import_resolutions = module_.import_resolutions.borrow_mut();
+ match import_resolutions.find(ident) {
None => {
// Simple: just copy the old import resolution.
let new_import_resolution =
new_import_resolution.type_target.set(
target_import_resolution.type_target.get());
- import_resolutions.get().insert
+ import_resolutions.insert
(*ident, new_import_resolution);
}
Some(&dest_import_resolution) => {
// Add all children from the containing module.
self.populate_module_if_necessary(containing_module);
- {
- let children = containing_module.children.borrow();
- for (&name, name_bindings) in children.get().iter() {
- self.merge_import_resolution(module_, containing_module,
- id, is_public,
- name, *name_bindings);
- }
+ for (&name, name_bindings) in containing_module.children
+ .borrow().iter() {
+ self.merge_import_resolution(module_, containing_module,
+ id, is_public,
+ name, *name_bindings);
}
// Add external module children from the containing module.
- {
- let external_module_children =
- containing_module.external_module_children.borrow();
- for (&name, module) in external_module_children.get().iter() {
- let name_bindings =
- @Resolver::create_name_bindings_from_module(*module);
- self.merge_import_resolution(module_, containing_module,
- id, is_public,
- name, name_bindings);
- }
+ for (&name, module) in containing_module.external_module_children
+ .borrow().iter() {
+ let name_bindings =
+ @Resolver::create_name_bindings_from_module(*module);
+ self.merge_import_resolution(module_, containing_module,
+ id, is_public,
+ name, name_bindings);
}
// Record the destination of this import
match containing_module.def_id.get() {
Some(did) => {
- let mut def_map = self.def_map.borrow_mut();
- def_map.get().insert(id, DefMod(did));
+ self.def_map.borrow_mut().insert(id, DefMod(did));
self.last_private.insert(id, lp);
}
None => {}
name_bindings: @NameBindings) {
let dest_import_resolution;
let mut import_resolutions = module_.import_resolutions.borrow_mut();
- match import_resolutions.get().find(&name) {
+ match import_resolutions.find(&name) {
None => {
// Create a new import resolution from this child.
dest_import_resolution =
@ImportResolution::new(id, is_public);
- import_resolutions.get().insert(name,
+ import_resolutions.insert(name,
dest_import_resolution);
}
Some(&existing_import_resolution) => {
// its immediate children.
self.populate_module_if_necessary(module_);
- {
- let children = module_.children.borrow();
- match children.get().find(&name.name) {
- Some(name_bindings)
- if name_bindings.defined_in_namespace(namespace) => {
- debug!("top name bindings succeeded");
- return Success((Target::new(module_, *name_bindings),
- false));
- }
- Some(_) | None => { /* Not found; continue. */ }
+ match module_.children.borrow().find(&name.name) {
+ Some(name_bindings)
+ if name_bindings.defined_in_namespace(namespace) => {
+ debug!("top name bindings succeeded");
+ return Success((Target::new(module_, *name_bindings),
+ false));
}
+ Some(_) | None => { /* Not found; continue. */ }
}
// Now check for its import directives. We don't have to have resolved
// all its imports in the usual way; this is because chains of
// adjacent import statements are processed as though they mutated the
// current scope.
- let import_resolutions = module_.import_resolutions.borrow();
- match import_resolutions.get().find(&name.name) {
+ match module_.import_resolutions.borrow().find(&name.name) {
None => {
// Not found; continue.
}
// Search for external modules.
if namespace == TypeNS {
- let module_opt = {
- let external_module_children =
- module_.external_module_children.borrow();
- external_module_children.get().find_copy(&name.name)
- };
- match module_opt {
+ match module_.external_module_children.borrow().find_copy(&name.name) {
None => {}
Some(module) => {
let name_bindings =
// First, check the direct children of the module.
self.populate_module_if_necessary(module_);
- {
- let children = module_.children.borrow();
- match children.get().find(&name.name) {
- Some(name_bindings)
- if name_bindings.defined_in_namespace(namespace) => {
- debug!("(resolving name in module) found node as child");
- return Success((Target::new(module_, *name_bindings),
- false));
- }
- Some(_) | None => {
- // Continue.
- }
+ match module_.children.borrow().find(&name.name) {
+ Some(name_bindings)
+ if name_bindings.defined_in_namespace(namespace) => {
+ debug!("(resolving name in module) found node as child");
+ return Success((Target::new(module_, *name_bindings),
+ false));
+ }
+ Some(_) | None => {
+ // Continue.
}
}
}
// Check the list of resolved imports.
- let import_resolutions = module_.import_resolutions.borrow();
- match import_resolutions.get().find(&name.name) {
+ match module_.import_resolutions.borrow().find(&name.name) {
Some(import_resolution) => {
if import_resolution.is_public.get() &&
import_resolution.outstanding_references.get() != 0 {
// Finally, search through external children.
if namespace == TypeNS {
- let module_opt = {
- let external_module_children =
- module_.external_module_children.borrow();
- external_module_children.get().find_copy(&name.name)
- };
- match module_opt {
+ match module_.external_module_children.borrow().find_copy(&name.name) {
None => {}
Some(module) => {
let name_bindings =
fn report_unresolved_imports(&mut self, module_: @Module) {
let index = module_.resolved_import_count.get();
- let mut imports = module_.imports.borrow_mut();
- let import_count = imports.get().len();
+ let imports = module_.imports.borrow();
+ let import_count = imports.len();
if index != import_count {
let sn = self.session
- .codemap
- .span_to_snippet(imports.get()[index].span)
+ .codemap()
+ .span_to_snippet(imports.get(index).span)
.unwrap();
if sn.contains("::") {
- self.resolve_error(imports.get()[index].span,
+ self.resolve_error(imports.get(index).span,
"unresolved import");
} else {
let err = format!("unresolved import (maybe you meant `{}::*`?)",
sn.slice(0, sn.len()));
- self.resolve_error(imports.get()[index].span, err);
+ self.resolve_error(imports.get(index).span, err);
}
}
// Descend into children and anonymous children.
self.populate_module_if_necessary(module_);
- {
- let children = module_.children.borrow();
- for (_, &child_node) in children.get().iter() {
- match child_node.get_module_if_available() {
- None => {
- // Continue.
- }
- Some(child_module) => {
- self.report_unresolved_imports(child_module);
- }
+ for (_, &child_node) in module_.children.borrow().iter() {
+ match child_node.get_module_if_available() {
+ None => {
+ // Continue.
+ }
+ Some(child_module) => {
+ self.report_unresolved_imports(child_module);
}
}
}
- let anonymous_children = module_.anonymous_children.borrow();
- for (_, &module_) in anonymous_children.get().iter() {
+ for (_, &module_) in module_.anonymous_children.borrow().iter() {
self.report_unresolved_imports(module_);
}
}
self.record_exports_for_module(module_);
self.populate_module_if_necessary(module_);
- {
- let children = module_.children.borrow();
- for (_, &child_name_bindings) in children.get().iter() {
- match child_name_bindings.get_module_if_available() {
- None => {
- // Nothing to do.
- }
- Some(child_module) => {
- self.record_exports_for_module_subtree(child_module);
- }
+ for (_, &child_name_bindings) in module_.children.borrow().iter() {
+ match child_name_bindings.get_module_if_available() {
+ None => {
+ // Nothing to do.
+ }
+ Some(child_module) => {
+ self.record_exports_for_module_subtree(child_module);
}
}
}
- let anonymous_children = module_.anonymous_children.borrow();
- for (_, &child_module) in anonymous_children.get().iter() {
+ for (_, &child_module) in module_.anonymous_children.borrow().iter() {
self.record_exports_for_module_subtree(child_module);
}
}
fn record_exports_for_module(&mut self, module_: @Module) {
- let mut exports2 = ~[];
+ let mut exports2 = Vec::new();
self.add_exports_for_module(&mut exports2, module_);
match module_.def_id.get() {
Some(def_id) => {
- let mut export_map2 = self.export_map2.borrow_mut();
- export_map2.get().insert(def_id.node, exports2);
+ self.export_map2.borrow_mut().insert(def_id.node, exports2);
debug!("(computing exports) writing exports for {} (some)",
def_id.node);
}
}
fn add_exports_of_namebindings(&mut self,
- exports2: &mut ~[Export2],
+ exports2: &mut Vec<Export2> ,
name: Name,
namebindings: @NameBindings,
ns: Namespace) {
}
fn add_exports_for_module(&mut self,
- exports2: &mut ~[Export2],
+ exports2: &mut Vec<Export2> ,
module_: @Module) {
- let import_resolutions = module_.import_resolutions.borrow();
- for (name, importresolution) in import_resolutions.get().iter() {
+ for (name, importresolution) in module_.import_resolutions.borrow().iter() {
if !importresolution.is_public.get() {
continue
}
Some(name) => {
self.populate_module_if_necessary(orig_module);
- let children = orig_module.children.borrow();
- match children.get().find(&name.name) {
+ match orig_module.children.borrow().find(&name.name) {
None => {
debug!("!!! (with scope) didn't find `{}` in `{}`",
token::get_ident(name),
/// Wraps the given definition in the appropriate number of `def_upvar`
/// wrappers.
fn upvarify(&mut self,
- ribs: &mut ~[@Rib],
+ ribs: &mut Vec<@Rib> ,
rib_index: uint,
def_like: DefLike,
span: Span)
let mut rib_index = rib_index + 1;
while rib_index < ribs.len() {
- match ribs[rib_index].kind {
+ match ribs.get(rib_index).kind {
NormalRibKind => {
// Nothing to do. Continue.
}
// item, it's ok
match def {
DefTyParam(did, _) if {
- let def_map = self.def_map.borrow();
- def_map.get().find(&did.node).map(|x| *x)
+ self.def_map.borrow().find(&did.node).map(|x| *x)
== Some(DefTyParamBinder(item_id))
} => {
// ok
}
fn search_ribs(&mut self,
- ribs: &mut ~[@Rib],
+ ribs: &mut Vec<@Rib> ,
name: Name,
span: Span)
-> Option<DefLike> {
let mut i = ribs.len();
while i != 0 {
i -= 1;
- let binding_opt = {
- let bindings = ribs[i].bindings.borrow();
- bindings.get().find_copy(&name)
- };
+ let binding_opt = ribs.get(i).bindings.borrow().find_copy(&name);
match binding_opt {
Some(def_like) => {
return self.upvarify(ribs, i, def_like, span);
generics,
implemented_traits,
self_type,
- *methods);
+ methods.as_slice());
}
ItemTrait(ref generics, ref traits, ref methods) => {
// Create a new rib for the self type.
let self_type_rib = @Rib::new(NormalRibKind);
- {
- let mut type_ribs = self.type_ribs.borrow_mut();
- type_ribs.get().push(self_type_rib);
- }
+ self.type_ribs.borrow_mut().push(self_type_rib);
// plain insert (no renaming)
let name = self.type_self_ident.name;
- {
- let mut bindings = self_type_rib.bindings.borrow_mut();
- bindings.get().insert(name, DlDef(DefSelfTy(item.id)));
- }
+ self_type_rib.bindings.borrow_mut()
+ .insert(name, DlDef(DefSelfTy(item.id)));
// Create a new rib for the trait-wide type parameters.
self.with_type_parameter_rib(HasTypeParameters(generics,
}
});
- let mut type_ribs = self.type_ribs.borrow_mut();
- type_ribs.get().pop();
+ self.type_ribs.borrow_mut().pop();
}
ItemStruct(ref struct_def, ref generics) => {
self.resolve_struct(item.id,
generics,
- struct_def.fields);
+ struct_def.fields.as_slice());
}
ItemMod(ref module_) => {
rib_kind) => {
let function_type_rib = @Rib::new(rib_kind);
- {
- let mut type_ribs = self.type_ribs.borrow_mut();
- type_ribs.get().push(function_type_rib);
- }
+ self.type_ribs.borrow_mut().push(function_type_rib);
for (index, type_parameter) in generics.ty_params.iter().enumerate() {
let ident = type_parameter.ident;
self.record_def(type_parameter.id,
(DefTyParamBinder(node_id), LastMod(AllPublic)));
// plain insert (no renaming)
- let mut bindings = function_type_rib.bindings
- .borrow_mut();
- bindings.get().insert(ident.name, def_like);
+ function_type_rib.bindings.borrow_mut()
+ .insert(ident.name, def_like);
}
}
f(self);
match type_parameters {
- HasTypeParameters(..) => {
- let mut type_ribs = self.type_ribs.borrow_mut();
- type_ribs.get().pop();
- }
-
- NoTypeParameters => {
- // Nothing to do.
- }
+ HasTypeParameters(..) => { self.type_ribs.borrow_mut().pop(); }
+ NoTypeParameters => { }
}
}
fn with_label_rib(&mut self, f: |&mut Resolver|) {
- {
- let mut label_ribs = self.label_ribs.borrow_mut();
- label_ribs.get().push(@Rib::new(NormalRibKind));
- }
-
+ self.label_ribs.borrow_mut().push(@Rib::new(NormalRibKind));
f(self);
-
- {
- let mut label_ribs = self.label_ribs.borrow_mut();
- label_ribs.get().pop();
- }
+ self.label_ribs.borrow_mut().pop();
}
fn with_constant_rib(&mut self, f: |&mut Resolver|) {
- {
- let mut value_ribs = self.value_ribs.borrow_mut();
- let mut type_ribs = self.type_ribs.borrow_mut();
- value_ribs.get().push(@Rib::new(ConstantItemRibKind));
- type_ribs.get().push(@Rib::new(ConstantItemRibKind));
- }
+ self.value_ribs.borrow_mut().push(@Rib::new(ConstantItemRibKind));
+ self.type_ribs.borrow_mut().push(@Rib::new(ConstantItemRibKind));
f(self);
- {
- let mut value_ribs = self.value_ribs.borrow_mut();
- let mut type_ribs = self.type_ribs.borrow_mut();
- type_ribs.get().pop();
- value_ribs.get().pop();
- }
+ self.type_ribs.borrow_mut().pop();
+ self.value_ribs.borrow_mut().pop();
}
fn resolve_function(&mut self,
block: P<Block>) {
// Create a value rib for the function.
let function_value_rib = @Rib::new(rib_kind);
- {
- let mut value_ribs = self.value_ribs.borrow_mut();
- value_ribs.get().push(function_value_rib);
- }
+ self.value_ribs.borrow_mut().push(function_value_rib);
// Create a label rib for the function.
- {
- let mut label_ribs = self.label_ribs.borrow_mut();
- let function_label_rib = @Rib::new(rib_kind);
- label_ribs.get().push(function_label_rib);
- }
+ let function_label_rib = @Rib::new(rib_kind);
+ self.label_ribs.borrow_mut().push(function_label_rib);
// If this function has type parameters, add them now.
self.with_type_parameter_rib(type_parameters, |this| {
debug!("(resolving function) leaving function");
});
- let mut label_ribs = self.label_ribs.borrow_mut();
- label_ribs.get().pop();
-
- let mut value_ribs = self.value_ribs.borrow_mut();
- value_ribs.get().pop();
+ self.label_ribs.borrow_mut().pop();
+ self.value_ribs.borrow_mut().pop();
}
fn resolve_type_parameters(&mut self,
- type_parameters: &OptVec<TyParam>) {
+ type_parameters: &OwnedSlice<TyParam>) {
for type_parameter in type_parameters.iter() {
for bound in type_parameter.bounds.iter() {
self.resolve_type_parameter_bound(type_parameter.id, bound);
TraitImplementation);
// Record the current set of trait references.
- let mut new_trait_refs = ~[];
- {
- let def_map = this.def_map.borrow();
- let r = def_map.get().find(&trait_reference.ref_id);
- for &def in r.iter() {
- new_trait_refs.push(def_id_of_def(*def));
- }
+ let mut new_trait_refs = Vec::new();
+ for &def in this.def_map.borrow()
+ .find(&trait_reference.ref_id).iter() {
+ new_trait_refs.push(def_id_of_def(*def));
}
original_trait_refs = Some(replace(
&mut this.current_trait_refs,
fn binding_mode_map(&mut self, pat: @Pat) -> BindingMap {
let mut result = HashMap::new();
pat_bindings(self.def_map, pat, |binding_mode, _id, sp, path| {
- let name = mtwt_resolve(path_to_ident(path));
+ let name = mtwt::resolve(path_to_ident(path));
result.insert(name,
binding_info {span: sp,
binding_mode: binding_mode});
// check that all of the arms in an or-pattern have exactly the
// same set of bindings, with the same binding modes for each.
fn check_consistent_bindings(&mut self, arm: &Arm) {
- if arm.pats.len() == 0 { return; }
- let map_0 = self.binding_mode_map(arm.pats[0]);
+ if arm.pats.len() == 0 {
+ return
+ }
+ let map_0 = self.binding_mode_map(*arm.pats.get(0));
for (i, p) in arm.pats.iter().enumerate() {
let map_i = self.binding_mode_map(*p);
}
fn resolve_arm(&mut self, arm: &Arm) {
- {
- let mut value_ribs = self.value_ribs.borrow_mut();
- value_ribs.get().push(@Rib::new(NormalRibKind));
- }
+ self.value_ribs.borrow_mut().push(@Rib::new(NormalRibKind));
let mut bindings_list = HashMap::new();
for pattern in arm.pats.iter() {
self.check_consistent_bindings(arm);
visit::walk_expr_opt(self, arm.guard, ());
- self.resolve_block(arm.body);
+ self.resolve_expr(arm.body);
- let mut value_ribs = self.value_ribs.borrow_mut();
- value_ribs.get().pop();
+ self.value_ribs.borrow_mut().pop();
}
fn resolve_block(&mut self, block: &Block) {
debug!("(resolving block) entering block");
- {
- let mut value_ribs = self.value_ribs.borrow_mut();
- value_ribs.get().push(@Rib::new(NormalRibKind));
- }
+ self.value_ribs.borrow_mut().push(@Rib::new(NormalRibKind));
// Move down in the graph, if there's an anonymous module rooted here.
let orig_module = self.current_module;
let anonymous_children = self.current_module
.anonymous_children
.borrow();
- match anonymous_children.get().find(&block.id) {
+ match anonymous_children.find(&block.id) {
None => { /* Nothing to do. */ }
Some(&anonymous_module) => {
debug!("(resolving block) found anonymous module, moving \
// Move back up.
self.current_module = orig_module;
- let mut value_ribs = self.value_ribs.borrow_mut();
- value_ribs.get().pop();
+ self.value_ribs.borrow_mut().pop();
debug!("(resolving block) leaving block");
}
TyPath(ref path, ref bounds, path_id) => {
// This is a path in the type namespace. Walk through scopes
- // scopes looking for it.
+ // looking for it.
let mut result_def = None;
// First, check to see whether the name is a primitive type.
// such a value is simply disallowed (since it's rarely
// what you want).
- let ident = path.segments[0].identifier;
- let renamed = mtwt_resolve(ident);
+ let ident = path.segments.get(0).identifier;
+ let renamed = mtwt::resolve(ident);
match self.resolve_bare_identifier_pattern(ident) {
FoundStructOrEnumVariant(def, lp)
Some(ref mut bindings_list)
if !bindings_list.contains_key(&renamed) => {
let this = &mut *self;
- {
- let mut value_ribs =
- this.value_ribs.borrow_mut();
- let last_rib = value_ribs.get()[
- value_ribs.get().len() - 1];
- let mut bindings =
- last_rib.bindings.borrow_mut();
- bindings.get().insert(renamed,
- DlDef(def));
- }
+ let value_ribs = this.value_ribs.borrow();
+ let length = value_ribs.len();
+ let last_rib = value_ribs.get(
+ length - 1);
+ last_rib.bindings.borrow_mut()
+ .insert(renamed, DlDef(def));
bindings_list.insert(renamed, pat_id);
}
Some(ref mut b) => {
None => {
let this = &mut *self;
{
- let mut value_ribs =
- this.value_ribs.borrow_mut();
- let last_rib = value_ribs.get()[
- value_ribs.get().len() - 1];
- let mut bindings =
- last_rib.bindings.borrow_mut();
- bindings.get().insert(renamed,
- DlDef(def));
+ let value_ribs = this.value_ribs.borrow();
+ let length = value_ribs.len();
+ let last_rib = value_ribs.get(
+ length - 1);
+ last_rib.bindings.borrow_mut()
+ .insert(renamed, DlDef(def));
}
}
}
// First, search children.
self.populate_module_if_necessary(containing_module);
- {
- let children = containing_module.children.borrow();
- match children.get().find(&name.name) {
- Some(child_name_bindings) => {
- match child_name_bindings.def_for_namespace(namespace) {
- Some(def) => {
- // Found it. Stop the search here.
- let p = child_name_bindings.defined_in_public_namespace(
- namespace);
- let lp = if p {LastMod(AllPublic)} else {
- LastMod(DependsOn(def_id_of_def(def)))
- };
- return ChildNameDefinition(def, lp);
- }
- None => {}
+ match containing_module.children.borrow().find(&name.name) {
+ Some(child_name_bindings) => {
+ match child_name_bindings.def_for_namespace(namespace) {
+ Some(def) => {
+ // Found it. Stop the search here.
+ let p = child_name_bindings.defined_in_public_namespace(
+ namespace);
+ let lp = if p {LastMod(AllPublic)} else {
+ LastMod(DependsOn(def_id_of_def(def)))
+ };
+ return ChildNameDefinition(def, lp);
}
+ None => {}
}
- None => {}
}
+ None => {}
}
// Next, search import resolutions.
- let import_resolutions = containing_module.import_resolutions
- .borrow();
- match import_resolutions.get().find(&name.name) {
+ match containing_module.import_resolutions.borrow().find(&name.name) {
Some(import_resolution) if import_resolution.is_public.get() => {
match (*import_resolution).target_for_namespace(namespace) {
Some(target) => {
// Finally, search through external children.
if namespace == TypeNS {
- let module_opt = {
- let external_module_children =
- containing_module.external_module_children.borrow();
- external_module_children.get().find_copy(&name.name)
- };
- match module_opt {
+ match containing_module.external_module_children.borrow()
+ .find_copy(&name.name) {
None => {}
Some(module) => {
match module.def_id.get() {
};
match containing_module.kind.get() {
TraitModuleKind | ImplModuleKind => {
- let method_map = self.method_map.borrow();
- match method_map.get().find(&ident.name) {
+ match self.method_map.borrow().find(&ident.name) {
Some(s) => {
match containing_module.def_id.get() {
Some(def_id) if s.contains(&def_id) => {
span: Span)
-> Option<Def> {
// Check the local set of ribs.
- let search_result;
- match namespace {
+ let search_result = match namespace {
ValueNS => {
- let renamed = mtwt_resolve(ident);
- let mut value_ribs = self.value_ribs.borrow_mut();
- search_result = self.search_ribs(value_ribs.get(),
- renamed,
- span);
+ let renamed = mtwt::resolve(ident);
+ self.search_ribs(&mut *self.value_ribs.borrow_mut(),
+ renamed, span)
}
TypeNS => {
let name = ident.name;
- let mut type_ribs = self.type_ribs.borrow_mut();
- search_result = self.search_ribs(type_ribs.get(),
- name,
- span);
+ self.search_ribs(&mut *self.type_ribs.borrow_mut(), name, span)
}
- }
+ };
match search_result {
Some(DlDef(def)) => {
-> Option<~str> {
let this = &mut *self;
- let mut maybes: ~[token::InternedString] = ~[];
- let mut values: ~[uint] = ~[];
+ let mut maybes: Vec<token::InternedString> = Vec::new();
+ let mut values: Vec<uint> = Vec::new();
- let mut j = {
- let value_ribs = this.value_ribs.borrow();
- value_ribs.get().len()
- };
+ let mut j = this.value_ribs.borrow().len();
while j != 0 {
j -= 1;
let value_ribs = this.value_ribs.borrow();
- let bindings = value_ribs.get()[j].bindings.borrow();
- for (&k, _) in bindings.get().iter() {
+ let bindings = value_ribs.get(j).bindings.borrow();
+ for (&k, _) in bindings.iter() {
maybes.push(token::get_name(k));
values.push(uint::MAX);
}
let mut smallest = 0;
for (i, other) in maybes.iter().enumerate() {
- values[i] = name.lev_distance(other.get());
+ *values.get_mut(i) = name.lev_distance(other.get());
- if values[i] <= values[smallest] {
+ if *values.get(i) <= *values.get(smallest) {
smallest = i;
}
}
if values.len() > 0 &&
- values[smallest] != uint::MAX &&
- values[smallest] < name.len() + 2 &&
- values[smallest] <= max_distance &&
- name != maybes[smallest].get() {
+ *values.get(smallest) != uint::MAX &&
+ *values.get(smallest) < name.len() + 2 &&
+ *values.get(smallest) <= max_distance &&
+ name != maybes.get(smallest).get() {
- Some(maybes[smallest].get().to_str())
+ Some(maybes.get(smallest).get().to_str())
} else {
None
ExprLoop(_, Some(label)) => {
self.with_label_rib(|this| {
let def_like = DlDef(DefLabel(expr.id));
+
{
- let mut label_ribs = this.label_ribs.borrow_mut();
- let rib = label_ribs.get()[label_ribs.get().len() -
- 1];
- let mut bindings = rib.bindings.borrow_mut();
- let renamed = mtwt_resolve(label);
- bindings.get().insert(renamed, def_like);
+ let label_ribs = this.label_ribs.borrow();
+ let length = label_ribs.len();
+ let rib = label_ribs.get(length - 1);
+ let renamed = mtwt::resolve(label);
+ rib.bindings.borrow_mut().insert(renamed, def_like);
}
visit::walk_expr(this, expr, ());
ExprBreak(Some(label)) | ExprAgain(Some(label)) => {
let mut label_ribs = self.label_ribs.borrow_mut();
- let renamed = mtwt_resolve(label);
- match self.search_ribs(label_ribs.get(), renamed, expr.span) {
+ let renamed = mtwt::resolve(label);
+ match self.search_ribs(&mut *label_ribs, renamed, expr.span) {
None =>
self.resolve_error(expr.span,
format!("use of undeclared label `{}`",
// the field name so that we can do some nice error reporting
// later on in typeck.
let traits = self.search_for_traits_containing_method(ident);
- self.trait_map.insert(expr.id, @RefCell::new(traits));
+ self.trait_map.insert(expr.id, traits);
}
- ExprMethodCall(_, ident, _, _) => {
+ ExprMethodCall(ident, _, _) => {
debug!("(recording candidate traits for expr) recording \
traits for {}",
expr.id);
let traits = self.search_for_traits_containing_method(ident);
- self.trait_map.insert(expr.id, @RefCell::new(traits));
- }
- ExprBinary(_, BiAdd, _, _) | ExprAssignOp(_, BiAdd, _, _) => {
- let i = self.lang_items.add_trait();
- self.add_fixed_trait_for_expr(expr.id, i);
- }
- ExprBinary(_, BiSub, _, _) | ExprAssignOp(_, BiSub, _, _) => {
- let i = self.lang_items.sub_trait();
- self.add_fixed_trait_for_expr(expr.id, i);
- }
- ExprBinary(_, BiMul, _, _) | ExprAssignOp(_, BiMul, _, _) => {
- let i = self.lang_items.mul_trait();
- self.add_fixed_trait_for_expr(expr.id, i);
- }
- ExprBinary(_, BiDiv, _, _) | ExprAssignOp(_, BiDiv, _, _) => {
- let i = self.lang_items.div_trait();
- self.add_fixed_trait_for_expr(expr.id, i);
- }
- ExprBinary(_, BiRem, _, _) | ExprAssignOp(_, BiRem, _, _) => {
- let i = self.lang_items.rem_trait();
- self.add_fixed_trait_for_expr(expr.id, i);
- }
- ExprBinary(_, BiBitXor, _, _) | ExprAssignOp(_, BiBitXor, _, _) => {
- let i = self.lang_items.bitxor_trait();
- self.add_fixed_trait_for_expr(expr.id, i);
- }
- ExprBinary(_, BiBitAnd, _, _) | ExprAssignOp(_, BiBitAnd, _, _) => {
- let i = self.lang_items.bitand_trait();
- self.add_fixed_trait_for_expr(expr.id, i);
- }
- ExprBinary(_, BiBitOr, _, _) | ExprAssignOp(_, BiBitOr, _, _) => {
- let i = self.lang_items.bitor_trait();
- self.add_fixed_trait_for_expr(expr.id, i);
- }
- ExprBinary(_, BiShl, _, _) | ExprAssignOp(_, BiShl, _, _) => {
- let i = self.lang_items.shl_trait();
- self.add_fixed_trait_for_expr(expr.id, i);
- }
- ExprBinary(_, BiShr, _, _) | ExprAssignOp(_, BiShr, _, _) => {
- let i = self.lang_items.shr_trait();
- self.add_fixed_trait_for_expr(expr.id, i);
- }
- ExprBinary(_, BiLt, _, _) | ExprBinary(_, BiLe, _, _) |
- ExprBinary(_, BiGe, _, _) | ExprBinary(_, BiGt, _, _) => {
- let i = self.lang_items.ord_trait();
- self.add_fixed_trait_for_expr(expr.id, i);
- }
- ExprBinary(_, BiEq, _, _) | ExprBinary(_, BiNe, _, _) => {
- let i = self.lang_items.eq_trait();
- self.add_fixed_trait_for_expr(expr.id, i);
- }
- ExprUnary(_, UnNeg, _) => {
- let i = self.lang_items.neg_trait();
- self.add_fixed_trait_for_expr(expr.id, i);
- }
- ExprUnary(_, UnNot, _) => {
- let i = self.lang_items.not_trait();
- self.add_fixed_trait_for_expr(expr.id, i);
- }
- ExprIndex(..) => {
- let i = self.lang_items.index_trait();
- self.add_fixed_trait_for_expr(expr.id, i);
+ self.trait_map.insert(expr.id, traits);
}
_ => {
// Nothing to do.
}
}
- fn search_for_traits_containing_method(&mut self, name: Ident) -> ~[DefId] {
+ fn search_for_traits_containing_method(&mut self, name: Ident) -> Vec<DefId> {
debug!("(searching for traits containing method) looking for '{}'",
token::get_ident(name));
- let mut found_traits = ~[];
+ let mut found_traits = Vec::new();
let mut search_module = self.current_module;
- let method_map = self.method_map.borrow();
- match method_map.get().find(&name.name) {
+ match self.method_map.borrow().find(&name.name) {
Some(candidate_traits) => loop {
// Look for the current trait.
match self.current_trait_refs {
// Look for trait children.
self.populate_module_if_necessary(search_module);
- let children = search_module.children.borrow();
- for (_, &child_names) in children.get().iter() {
+ for (_, &child_names) in search_module.children.borrow().iter() {
let def = match child_names.def_for_namespace(TypeNS) {
Some(def) => def,
None => continue
// Look for imports.
let import_resolutions = search_module.import_resolutions
.borrow();
- for (_, &import) in import_resolutions.get().iter() {
+ for (_, &import) in import_resolutions.iter() {
let target = match import.target_for_namespace(TypeNS) {
None => continue,
Some(target) => target,
}
fn add_trait_info(&self,
- found_traits: &mut ~[DefId],
+ found_traits: &mut Vec<DefId> ,
trait_def_id: DefId,
name: Ident) {
debug!("(adding trait info) found trait {}:{} for method '{}'",
found_traits.push(trait_def_id);
}
- fn add_fixed_trait_for_expr(&mut self,
- expr_id: NodeId,
- trait_id: Option<DefId>) {
- match trait_id {
- Some(trait_id) => {
- self.trait_map.insert(expr_id, @RefCell::new(~[trait_id]));
- }
- None => {}
- }
- }
-
fn record_def(&mut self, node_id: NodeId, (def, lp): (Def, LastPrivate)) {
debug!("(recording def) recording {:?} for {:?}, last private {:?}",
def, node_id, lp);
assert!(match lp {LastImport{..} => false, _ => true},
"Import should only be used for `use` directives");
self.last_private.insert(node_id, lp);
- let mut def_map = self.def_map.borrow_mut();
- def_map.get().insert_or_update_with(node_id, def, |_, old_value| {
+ self.def_map.borrow_mut().insert_or_update_with(node_id, def, |_, old_value| {
// Resolve appears to "resolve" the same ID multiple
// times, so here is a sanity check it at least comes to
// the same conclusion! - nmatsakis
if vi.span == DUMMY_SP { return }
match vi.node {
- ViewItemExternMod(..) => {} // ignore
+ ViewItemExternCrate(..) => {} // ignore
ViewItemUse(ref path) => {
for p in path.iter() {
match p.node {
// public or private item, we will check the correct thing, dependent on how the import
// is used.
fn finalize_import(&mut self, id: NodeId, span: Span) {
- debug!("finalizing import uses for {}", self.session.codemap.span_to_snippet(span));
+ debug!("finalizing import uses for {}", self.session.codemap().span_to_snippet(span));
if !self.used_imports.contains(&(id, TypeNS)) &&
!self.used_imports.contains(&(id, ValueNS)) {
/// A somewhat inefficient routine to obtain the name of a module.
fn module_to_str(&mut self, module_: @Module) -> ~str {
- let mut idents = ~[];
+ let mut idents = Vec::new();
let mut current_module = module_;
loop {
match current_module.parent_link {
if idents.len() == 0 {
return ~"???";
}
- return self.idents_to_str(idents.move_rev_iter().collect::<~[ast::Ident]>());
+ return self.idents_to_str(idents.move_iter()
+ .rev()
+ .collect::<Vec<ast::Ident>>()
+ .as_slice());
}
#[allow(dead_code)] // useful for debugging
debug!("Children:");
self.populate_module_if_necessary(module_);
- let children = module_.children.borrow();
- for (&name, _) in children.get().iter() {
+ for (&name, _) in module_.children.borrow().iter() {
debug!("* {}", token::get_name(name));
}
debug!("Import resolutions:");
let import_resolutions = module_.import_resolutions.borrow();
- for (&name, import_resolution) in import_resolutions.get().iter() {
+ for (&name, import_resolution) in import_resolutions.iter() {
let value_repr;
match import_resolution.target_for_namespace(ValueNS) {
None => { value_repr = ~""; }
}
/// Entry point to crate resolution.
-pub fn resolve_crate(session: Session,
+pub fn resolve_crate(session: &Session,
lang_items: @LanguageItems,
krate: &Crate)
-> CrateMap {
projects / rust.git / blobdiff