From e84323e9b8a1175bf8b6e22754e24a54a77f9e71 Mon Sep 17 00:00:00 2001 From: Seo Sanghyeon Date: Thu, 21 Mar 2013 16:26:38 +0900 Subject: [PATCH 1/2] Switch Module.children from oldmap --- src/librustc/middle/resolve.rs | 48 +++++++++++++++++----------------- 1 file changed, 24 insertions(+), 24 deletions(-) diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs index 6561da0862ae5..6df86d21cb7c4 100644 --- a/src/librustc/middle/resolve.rs +++ b/src/librustc/middle/resolve.rs @@ -77,6 +77,7 @@ use syntax::opt_vec::OptVec; use core::option::{Some, get, is_some, is_none}; use core::str::{connect, split_str}; +use core::hashmap::linear::LinearMap; use std::oldmap::HashMap; // Definition mapping @@ -456,7 +457,7 @@ pub struct Module { def_id: Option, kind: ModuleKind, - children: @HashMap, + children: @mut LinearMap, imports: @mut ~[@ImportDirective], // The anonymous children of this node. Anonymous children are pseudo- @@ -494,7 +495,7 @@ pub fn Module(parent_link: ParentLink, parent_link: parent_link, def_id: def_id, kind: kind, - children: @HashMap(), + children: @mut LinearMap::new(), imports: @mut ~[], anonymous_children: @HashMap(), import_resolutions: @HashMap(), @@ -1024,7 +1025,7 @@ pub impl Resolver { *self.session.str_of(name))); } } - return (child, new_parent); + return (*child, new_parent); } } } @@ -1614,7 +1615,7 @@ pub impl Resolver { let name_bindings = parent_module.children.get( &ident); resolution.type_target = - Some(Target(parent_module, name_bindings)); + Some(Target(parent_module, *name_bindings)); } } @@ -2165,13 +2166,13 @@ pub impl Resolver { // Continue. } Some(child_name_bindings) => { - if (*child_name_bindings).defined_in_namespace(ValueNS) { + if child_name_bindings.defined_in_namespace(ValueNS) { value_result = BoundResult(containing_module, - child_name_bindings); + *child_name_bindings); } - if (*child_name_bindings).defined_in_namespace(TypeNS) { + if child_name_bindings.defined_in_namespace(TypeNS) { type_result = BoundResult(containing_module, - child_name_bindings); + *child_name_bindings); } } } @@ -2352,9 +2353,9 @@ pub impl Resolver { // Continue. } Some(child_name_bindings) => { - if (*child_name_bindings).defined_in_namespace(TypeNS) { + if child_name_bindings.defined_in_namespace(TypeNS) { module_result = BoundResult(containing_module, - child_name_bindings); + *child_name_bindings); } } } @@ -2534,16 +2535,16 @@ pub impl Resolver { } // Add all children from the containing module. - for containing_module.children.each |&ident, &name_bindings| { + for containing_module.children.each |&(ident, name_bindings)| { let mut dest_import_resolution; - match module_.import_resolutions.find(&ident) { + match module_.import_resolutions.find(ident) { None => { // Create a new import resolution from this child. dest_import_resolution = @mut ImportResolution(privacy, span, state); module_.import_resolutions.insert - (ident, dest_import_resolution); + (*ident, dest_import_resolution); } Some(existing_import_resolution) => { dest_import_resolution = existing_import_resolution; @@ -2552,21 +2553,21 @@ pub impl Resolver { debug!("(resolving glob import) writing resolution `%s` in `%s` \ to `%s`, privacy=%?", - *self.session.str_of(ident), + *self.session.str_of(*ident), self.module_to_str(containing_module), self.module_to_str(module_), copy dest_import_resolution.privacy); // Merge the child item into the import resolution. - if (*name_bindings).defined_in_public_namespace(ValueNS) { + if name_bindings.defined_in_public_namespace(ValueNS) { debug!("(resolving glob import) ... for value target"); dest_import_resolution.value_target = - Some(Target(containing_module, name_bindings)); + Some(Target(containing_module, *name_bindings)); } - if (*name_bindings).defined_in_public_namespace(TypeNS) { + if name_bindings.defined_in_public_namespace(TypeNS) { debug!("(resolving glob import) ... for type target"); dest_import_resolution.type_target = - Some(Target(containing_module, name_bindings)); + Some(Target(containing_module, *name_bindings)); } } @@ -2760,8 +2761,8 @@ pub impl Resolver { match module_.children.find(&name) { Some(name_bindings) - if (*name_bindings).defined_in_namespace(namespace) => { - return Success(Target(module_, name_bindings)); + if name_bindings.defined_in_namespace(namespace) => { + return Success(Target(module_, *name_bindings)); } Some(_) | None => { /* Not found; continue. */ } } @@ -3005,10 +3006,9 @@ pub impl Resolver { // First, check the direct children of the module. match module_.children.find(&name) { Some(name_bindings) - if (*name_bindings).defined_in_namespace(namespace) => { - + if name_bindings.defined_in_namespace(namespace) => { debug!("(resolving name in module) found node as child"); - return Success(Target(module_, name_bindings)); + return Success(Target(module_, *name_bindings)); } Some(_) | None => { // Continue. @@ -3190,7 +3190,7 @@ pub impl Resolver { fn add_exports_for_module(@mut self, exports2: &mut ~[Export2], module_: @mut Module) { - for module_.children.each |ident, namebindings| { + for module_.children.each |&(ident, namebindings)| { debug!("(computing exports) maybe export '%s'", *self.session.str_of(*ident)); self.add_exports_of_namebindings(&mut *exports2, From f68f2282c10aa7bb8452906ecf98d13c716d5586 Mon Sep 17 00:00:00 2001 From: Seo Sanghyeon Date: Thu, 21 Mar 2013 17:10:57 +0900 Subject: [PATCH 2/2] Switch Module.import_resolutions from oldmap --- src/librustc/middle/resolve.rs | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs index 6df86d21cb7c4..84ebfa3eecc4c 100644 --- a/src/librustc/middle/resolve.rs +++ b/src/librustc/middle/resolve.rs @@ -478,7 +478,7 @@ pub struct Module { anonymous_children: @HashMap, // The status of resolving each import in this module. - import_resolutions: @HashMap, + import_resolutions: @mut LinearMap, // The number of unresolved globs that this module exports. glob_count: uint, @@ -498,7 +498,7 @@ pub fn Module(parent_link: ParentLink, children: @mut LinearMap::new(), imports: @mut ~[], anonymous_children: @HashMap(), - import_resolutions: @HashMap(), + import_resolutions: @mut LinearMap::new(), glob_count: 0, resolved_import_count: 0 } @@ -2242,11 +2242,11 @@ pub impl Resolver { // The name is an import which has been fully // resolved. We can, therefore, just follow it. if value_result.is_unknown() { - value_result = get_binding(import_resolution, + value_result = get_binding(*import_resolution, ValueNS); } if type_result.is_unknown() { - type_result = get_binding(import_resolution, + type_result = get_binding(*import_resolution, TypeNS); } } @@ -2484,7 +2484,7 @@ pub impl Resolver { // Add all resolved imports from the containing module. for containing_module.import_resolutions.each - |&ident, &target_import_resolution| { + |&(ident, target_import_resolution)| { debug!("(resolving glob import) writing module resolution \ %? into `%s`", @@ -2492,7 +2492,7 @@ pub impl Resolver { self.module_to_str(module_)); // Here we merge two import resolutions. - match module_.import_resolutions.find(&ident) { + match module_.import_resolutions.find(ident) { None if target_import_resolution.privacy == Public => { // Simple: just copy the old import resolution. let new_import_resolution = @@ -2505,7 +2505,7 @@ pub impl Resolver { copy target_import_resolution.type_target; module_.import_resolutions.insert - (ident, new_import_resolution); + (*ident, new_import_resolution); } None => { /* continue ... */ } Some(dest_import_resolution) => { @@ -2547,7 +2547,7 @@ pub impl Resolver { (*ident, dest_import_resolution); } Some(existing_import_resolution) => { - dest_import_resolution = existing_import_resolution; + dest_import_resolution = *existing_import_resolution; } } @@ -3205,7 +3205,7 @@ pub impl Resolver { false); } - for module_.import_resolutions.each |ident, importresolution| { + for module_.import_resolutions.each |&(ident, importresolution)| { if importresolution.privacy != Public { debug!("(computing exports) not reexporting private `%s`", *self.session.str_of(*ident)); @@ -5308,9 +5308,9 @@ pub impl Resolver { } debug!("Import resolutions:"); - for module_.import_resolutions.each |&name, &import_resolution| { + for module_.import_resolutions.each |&(name, import_resolution)| { let mut value_repr; - match (*import_resolution).target_for_namespace(ValueNS) { + match import_resolution.target_for_namespace(ValueNS) { None => { value_repr = ~""; } Some(_) => { value_repr = ~" value:?"; @@ -5319,7 +5319,7 @@ pub impl Resolver { } let mut type_repr; - match (*import_resolution).target_for_namespace(TypeNS) { + match import_resolution.target_for_namespace(TypeNS) { None => { type_repr = ~""; } Some(_) => { type_repr = ~" type:?"; @@ -5327,7 +5327,7 @@ pub impl Resolver { } } - debug!("* %s:%s%s", *self.session.str_of(name), + debug!("* %s:%s%s", *self.session.str_of(*name), value_repr, type_repr); } }