From 25b40841a5555dafe7f68189a725b6251ce1f992 Mon Sep 17 00:00:00 2001 From: Jonathan S Date: Mon, 29 Sep 2014 18:06:13 -0500 Subject: [PATCH] Removed some unnecessary RefCells from resolve --- src/librustc/metadata/encoder.rs | 2 +- src/librustc/middle/privacy.rs | 7 +- src/librustc/middle/resolve.rs | 157 +++++++++++++------------------ 3 files changed, 70 insertions(+), 96 deletions(-) diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index d27a0d27c7b..111d372004b 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -537,7 +537,7 @@ fn encode_reexports(ecx: &EncodeContext, id: NodeId, path: PathElems) { debug!("(encoding info for module) encoding reexports for {}", id); - match ecx.reexports2.borrow().find(&id) { + match ecx.reexports2.find(&id) { Some(ref exports) => { debug!("(encoding info for module) found reexports for {}", id); for exp in exports.iter() { diff --git a/src/librustc/middle/privacy.rs b/src/librustc/middle/privacy.rs index bf16f772775..e97010cc0c7 100644 --- a/src/librustc/middle/privacy.rs +++ b/src/librustc/middle/privacy.rs @@ -1,4 +1,4 @@ -// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT +// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // @@ -347,9 +347,8 @@ fn visit_mod(&mut self, m: &ast::Mod, _sp: Span, id: ast::NodeId) { // This code is here instead of in visit_item so that the // crate module gets processed as well. if self.prev_exported { - let exp_map2 = self.exp_map2.borrow(); - assert!(exp_map2.contains_key(&id), "wut {:?}", id); - for export in exp_map2.get(&id).iter() { + assert!(self.exp_map2.contains_key(&id), "wut {:?}", id); + for export in self.exp_map2.get(&id).iter() { if is_local(export.def_id) { self.reexports.insert(export.def_id.node); } diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs index 5f0750d2653..1f19cf1aef5 100644 --- a/src/librustc/middle/resolve.rs +++ b/src/librustc/middle/resolve.rs @@ -81,7 +81,7 @@ struct binding_info { // This is the replacement export map. It maps a module to all of the exports // within. -pub type ExportMap2 = RefCell >>; +pub type ExportMap2 = NodeMap>; pub struct Export2 { pub name: String, // The name of the target. @@ -360,14 +360,14 @@ enum DuplicateCheckingMode { /// One local scope. struct Rib { - bindings: RefCell>, + bindings: HashMap, kind: RibKind, } impl Rib { fn new(kind: RibKind) -> Rib { Rib { - bindings: RefCell::new(HashMap::new()), + bindings: HashMap::new(), kind: kind } } @@ -856,7 +856,7 @@ struct Resolver<'a> { graph_root: NameBindings, - trait_item_map: RefCell>, + trait_item_map: FnvHashMap<(Name, DefId), TraitItemKind>, structs: FnvHashMap>, @@ -868,13 +868,13 @@ struct Resolver<'a> { // The current set of local scopes, for values. // FIXME #4948: Reuse ribs to avoid allocation. - value_ribs: RefCell>, + value_ribs: Vec, // The current set of local scopes, for types. - type_ribs: RefCell>, + type_ribs: Vec, // The current set of local scopes, for labels. - label_ribs: RefCell>, + label_ribs: Vec, // The trait that the current context can refer to. current_trait_ref: Option<(DefId, TraitRef)>, @@ -893,7 +893,7 @@ struct Resolver<'a> { def_map: DefMap, freevars: RefCell, freevars_seen: RefCell>, - capture_mode_map: RefCell, + capture_mode_map: CaptureModeMap, export_map2: ExportMap2, trait_map: TraitMap, external_exports: ExternalExports, @@ -980,15 +980,15 @@ fn new(session: &'a Session, crate_span: Span) -> Resolver<'a> { graph_root: graph_root, - trait_item_map: RefCell::new(FnvHashMap::new()), + trait_item_map: FnvHashMap::new(), structs: FnvHashMap::new(), unresolved_imports: 0, current_module: current_module, - value_ribs: RefCell::new(Vec::new()), - type_ribs: RefCell::new(Vec::new()), - label_ribs: RefCell::new(Vec::new()), + value_ribs: Vec::new(), + type_ribs: Vec::new(), + label_ribs: Vec::new(), current_trait_ref: None, current_self_type: None, @@ -1001,8 +1001,8 @@ fn new(session: &'a Session, crate_span: Span) -> Resolver<'a> { def_map: RefCell::new(NodeMap::new()), freevars: RefCell::new(NodeMap::new()), freevars_seen: RefCell::new(NodeMap::new()), - capture_mode_map: RefCell::new(NodeMap::new()), - export_map2: RefCell::new(NodeMap::new()), + capture_mode_map: NodeMap::new(), + export_map2: NodeMap::new(), trait_map: NodeMap::new(), used_imports: HashSet::new(), used_crates: HashSet::new(), @@ -1516,9 +1516,7 @@ fn build_reduced_graph_for_item(&mut self, } }; - self.trait_item_map - .borrow_mut() - .insert((ident.name, def_id), kind); + self.trait_item_map.insert((ident.name, def_id), kind); } name_bindings.define_type(DefTrait(def_id), sp, is_public); @@ -1850,10 +1848,7 @@ fn handle_external_def(&mut self, adding trait item '{}'", token::get_ident(trait_item_name)); - self.trait_item_map - .borrow_mut() - .insert((trait_item_name.name, def_id), - trait_item_kind); + self.trait_item_map.insert((trait_item_name.name, def_id), trait_item_kind); if is_exported { self.external_exports @@ -3758,7 +3753,7 @@ fn record_exports_for_module(&mut self, module_: &Module) { self.add_exports_for_module(&mut exports2, module_); match module_.def_id.get() { Some(def_id) => { - self.export_map2.borrow_mut().insert(def_id.node, exports2); + self.export_map2.insert(def_id.node, exports2); debug!("(computing exports) writing exports for {} (some)", def_id.node); } @@ -4015,7 +4010,7 @@ fn search_ribs(&self, // FIXME #4950: Try caching? for (i, rib) in ribs.iter().enumerate().rev() { - match rib.bindings.borrow().find_copy(&name) { + match rib.bindings.find_copy(&name) { Some(def_like) => { return self.upvarify(ribs.slice_from(i + 1), def_like, span); } @@ -4091,13 +4086,12 @@ fn resolve_item(&mut self, item: &Item) { ItemTrait(ref generics, ref unbound, ref bounds, ref methods) => { // Create a new rib for the self type. - let self_type_rib = Rib::new(ItemRibKind); + let mut self_type_rib = Rib::new(ItemRibKind); // plain insert (no renaming, types are not currently hygienic....) let name = self.type_self_name; - self_type_rib.bindings.borrow_mut() - .insert(name, DlDef(DefSelfTy(item.id))); - self.type_ribs.borrow_mut().push(self_type_rib); + self_type_rib.bindings.insert(name, DlDef(DefSelfTy(item.id))); + self.type_ribs.push(self_type_rib); // Create a new rib for the trait-wide type parameters. self.with_type_parameter_rib(HasTypeParameters(generics, @@ -4166,7 +4160,7 @@ fn resolve_item(&mut self, item: &Item) { } }); - self.type_ribs.borrow_mut().pop(); + self.type_ribs.pop(); } ItemStruct(ref struct_def, ref generics) => { @@ -4234,7 +4228,7 @@ fn with_type_parameter_rib(&mut self, HasTypeParameters(generics, space, node_id, rib_kind) => { - let function_type_rib = Rib::new(rib_kind); + let mut function_type_rib = Rib::new(rib_kind); for (index, type_parameter) in generics.ty_params.iter().enumerate() { let ident = type_parameter.ident; @@ -4248,10 +4242,9 @@ fn with_type_parameter_rib(&mut self, self.record_def(type_parameter.id, (DefTyParamBinder(node_id), LastMod(AllPublic))); // plain insert (no renaming) - function_type_rib.bindings.borrow_mut() - .insert(ident.name, def_like); + function_type_rib.bindings.insert(ident.name, def_like); } - self.type_ribs.borrow_mut().push(function_type_rib); + self.type_ribs.push(function_type_rib); } NoTypeParameters => { @@ -4262,23 +4255,23 @@ fn with_type_parameter_rib(&mut self, f(self); match type_parameters { - HasTypeParameters(..) => { self.type_ribs.borrow_mut().pop(); } + HasTypeParameters(..) => { self.type_ribs.pop(); } NoTypeParameters => { } } } fn with_label_rib(&mut self, f: |&mut Resolver|) { - self.label_ribs.borrow_mut().push(Rib::new(NormalRibKind)); + self.label_ribs.push(Rib::new(NormalRibKind)); f(self); - self.label_ribs.borrow_mut().pop(); + self.label_ribs.pop(); } fn with_constant_rib(&mut self, f: |&mut Resolver|) { - self.value_ribs.borrow_mut().push(Rib::new(ConstantItemRibKind)); - self.type_ribs.borrow_mut().push(Rib::new(ConstantItemRibKind)); + self.value_ribs.push(Rib::new(ConstantItemRibKind)); + self.type_ribs.push(Rib::new(ConstantItemRibKind)); f(self); - self.type_ribs.borrow_mut().pop(); - self.value_ribs.borrow_mut().pop(); + self.type_ribs.pop(); + self.value_ribs.pop(); } fn resolve_function(&mut self, @@ -4288,11 +4281,11 @@ fn resolve_function(&mut self, block: &Block) { // Create a value rib for the function. let function_value_rib = Rib::new(rib_kind); - self.value_ribs.borrow_mut().push(function_value_rib); + self.value_ribs.push(function_value_rib); // Create a label rib for the function. let function_label_rib = Rib::new(rib_kind); - self.label_ribs.borrow_mut().push(function_label_rib); + self.label_ribs.push(function_label_rib); // If this function has type parameters, add them now. self.with_type_parameter_rib(type_parameters, |this| { @@ -4334,8 +4327,8 @@ fn resolve_function(&mut self, debug!("(resolving function) leaving function"); }); - self.label_ribs.borrow_mut().pop(); - self.value_ribs.borrow_mut().pop(); + self.label_ribs.pop(); + self.value_ribs.pop(); } fn resolve_type_parameters(&mut self, @@ -4678,7 +4671,7 @@ fn check_trait_item(&self, ident: Ident, span: Span) { for &(did, ref trait_ref) in self.current_trait_ref.iter() { let method_name = ident.name; - if self.trait_item_map.borrow().find(&(method_name, did)).is_none() { + if self.trait_item_map.find(&(method_name, did)).is_none() { let path_str = self.path_idents_to_string(&trait_ref.path); self.resolve_error(span, format!("method `{}` is not a member of trait `{}`", @@ -4778,7 +4771,7 @@ fn check_consistent_bindings(&mut self, arm: &Arm) { } fn resolve_arm(&mut self, arm: &Arm) { - self.value_ribs.borrow_mut().push(Rib::new(NormalRibKind)); + self.value_ribs.push(Rib::new(NormalRibKind)); let mut bindings_list = HashMap::new(); for pattern in arm.pats.iter() { @@ -4792,12 +4785,12 @@ fn resolve_arm(&mut self, arm: &Arm) { visit::walk_expr_opt(self, &arm.guard); self.resolve_expr(&*arm.body); - self.value_ribs.borrow_mut().pop(); + self.value_ribs.pop(); } fn resolve_block(&mut self, block: &Block) { debug!("(resolving block) entering block"); - self.value_ribs.borrow_mut().push(Rib::new(NormalRibKind)); + self.value_ribs.push(Rib::new(NormalRibKind)); // Move down in the graph, if there's an anonymous module rooted here. let orig_module = self.current_module.clone(); @@ -4816,7 +4809,7 @@ fn resolve_block(&mut self, block: &Block) { // Move back up. self.current_module = orig_module; - self.value_ribs.borrow_mut().pop(); + self.value_ribs.pop(); debug!("(resolving block) leaving block"); } @@ -5059,12 +5052,8 @@ struct or enum variant", if !bindings_list.contains_key(&renamed) { let this = &mut *self; - 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)); + let last_rib = this.value_ribs.last_mut().unwrap(); + last_rib.bindings.insert(renamed, DlDef(def)); bindings_list.insert(renamed, pat_id); } else if bindings_list.find(&renamed) == Some(&pat_id) { @@ -5414,7 +5403,7 @@ fn resolve_module_relative_path(&mut self, TraitModuleKind | ImplModuleKind => { match containing_module.def_id.get() { Some(def_id) => { - match self.trait_item_map.borrow().find(&(ident.name, def_id)) { + match self.trait_item_map.find(&(ident.name, def_id)) { Some(&StaticMethodTraitItemKind) => (), Some(&TypeTraitItemKind) => (), None => (), @@ -5506,12 +5495,12 @@ fn resolve_identifier_in_local_ribs(&mut self, let search_result = match namespace { ValueNS => { let renamed = mtwt::resolve(ident); - self.search_ribs(self.value_ribs.borrow().as_slice(), + self.search_ribs(self.value_ribs.as_slice(), renamed, span) } TypeNS => { let name = ident.name; - self.search_ribs(self.type_ribs.borrow().as_slice(), name, span) + self.search_ribs(self.type_ribs.as_slice(), name, span) } }; @@ -5686,12 +5675,11 @@ fn get_module(this: &mut Resolver, span: Span, ident_path: &[ast::Ident]) } // Look for a method in the current trait. - let trait_item_map = self.trait_item_map.borrow(); match self.current_trait_ref { Some((did, ref trait_ref)) => { let path_str = self.path_idents_to_string(&trait_ref.path); - match trait_item_map.find(&(name, did)) { + match self.trait_item_map.find(&(name, did)) { Some(&StaticMethodTraitItemKind) => return StaticTraitMethod(path_str), Some(_) => return TraitItem, None => {} @@ -5710,12 +5698,8 @@ fn find_best_match_for_name(&mut self, name: &str, max_distance: uint) let mut maybes: Vec = Vec::new(); let mut values: Vec = Vec::new(); - 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.iter() { + for rib in this.value_ribs.iter().rev() { + for (&k, _) in rib.bindings.iter() { maybes.push(token::get_name(k)); values.push(uint::MAX); } @@ -5805,7 +5789,7 @@ fn resolve_expr(&mut self, expr: &Expr) { } _ => { let mut method_scope = false; - self.value_ribs.borrow().iter().rev().all(|rib| { + self.value_ribs.iter().rev().all(|rib| { let res = match *rib { Rib { bindings: _, kind: MethodRibKind(_, _) } => true, Rib { bindings: _, kind: ItemRibKind } => false, @@ -5864,20 +5848,20 @@ fn resolve_expr(&mut self, expr: &Expr) { ExprFnBlock(_, ref fn_decl, ref block) => { // NOTE(stage0): After snapshot, change to: // - //self.capture_mode_map.borrow_mut().insert(expr.id, capture_clause); - self.capture_mode_map.borrow_mut().insert(expr.id, ast::CaptureByRef); + //self.capture_mode_map.insert(expr.id, capture_clause); + self.capture_mode_map.insert(expr.id, ast::CaptureByRef); self.resolve_function(ClosureRibKind(expr.id, ast::DUMMY_NODE_ID), Some(&**fn_decl), NoTypeParameters, &**block); } ExprProc(ref fn_decl, ref block) => { - self.capture_mode_map.borrow_mut().insert(expr.id, ast::CaptureByValue); + self.capture_mode_map.insert(expr.id, ast::CaptureByValue); self.resolve_function(ClosureRibKind(expr.id, block.id), Some(&**fn_decl), NoTypeParameters, &**block); } ExprUnboxedFn(capture_clause, _, ref fn_decl, ref block) => { - self.capture_mode_map.borrow_mut().insert(expr.id, capture_clause); + self.capture_mode_map.insert(expr.id, capture_clause); self.resolve_function(ClosureRibKind(expr.id, block.id), Some(&**fn_decl), NoTypeParameters, &**block); @@ -5906,11 +5890,9 @@ fn resolve_expr(&mut self, expr: &Expr) { let def_like = DlDef(DefLabel(expr.id)); { - let label_ribs = this.label_ribs.borrow(); - let length = label_ribs.len(); - let rib = label_ribs.get(length - 1); + let rib = this.label_ribs.last_mut().unwrap(); let renamed = mtwt::resolve(label); - rib.bindings.borrow_mut().insert(renamed, def_like); + rib.bindings.insert(renamed, def_like); } visit::walk_expr(this, expr); @@ -5920,7 +5902,7 @@ fn resolve_expr(&mut self, expr: &Expr) { ExprForLoop(ref pattern, ref head, ref body, optional_label) => { self.resolve_expr(&**head); - self.value_ribs.borrow_mut().push(Rib::new(NormalRibKind)); + self.value_ribs.push(Rib::new(NormalRibKind)); self.resolve_pattern(&**pattern, LocalIrrefutableMode, @@ -5930,17 +5912,13 @@ fn resolve_expr(&mut self, expr: &Expr) { None => {} Some(label) => { self.label_ribs - .borrow_mut() .push(Rib::new(NormalRibKind)); let def_like = DlDef(DefLabel(expr.id)); { - let label_ribs = self.label_ribs.borrow(); - let length = label_ribs.len(); - let rib = label_ribs.get(length - 1); + let rib = self.label_ribs.last_mut().unwrap(); let renamed = mtwt::resolve(label); - rib.bindings.borrow_mut().insert(renamed, - def_like); + rib.bindings.insert(renamed, def_like); } } } @@ -5948,15 +5926,15 @@ fn resolve_expr(&mut self, expr: &Expr) { self.resolve_block(&**body); if optional_label.is_some() { - drop(self.label_ribs.borrow_mut().pop()) + drop(self.label_ribs.pop()) } - self.value_ribs.borrow_mut().pop(); + self.value_ribs.pop(); } ExprBreak(Some(label)) | ExprAgain(Some(label)) => { let renamed = mtwt::resolve(label); - match self.search_ribs(self.label_ribs.borrow().as_slice(), + match self.search_ribs(self.label_ribs.as_slice(), renamed, expr.span) { None => { self.resolve_error( @@ -6025,9 +6003,7 @@ fn add_trait_info(found_traits: &mut Vec, // Look for the current trait. match self.current_trait_ref { Some((trait_def_id, _)) => { - let trait_item_map = self.trait_item_map.borrow(); - - if trait_item_map.contains_key(&(name, trait_def_id)) { + if self.trait_item_map.contains_key(&(name, trait_def_id)) { add_trait_info(&mut found_traits, trait_def_id, name); } } @@ -6038,7 +6014,6 @@ fn add_trait_info(found_traits: &mut Vec, self.populate_module_if_necessary(&search_module); { - let trait_item_map = self.trait_item_map.borrow(); for (_, child_names) in search_module.children.borrow().iter() { let def = match child_names.def_for_namespace(TypeNS) { Some(def) => def, @@ -6048,7 +6023,7 @@ fn add_trait_info(found_traits: &mut Vec, DefTrait(trait_def_id) => trait_def_id, _ => continue, }; - if trait_item_map.contains_key(&(name, trait_def_id)) { + if self.trait_item_map.contains_key(&(name, trait_def_id)) { add_trait_info(&mut found_traits, trait_def_id, name); } } @@ -6064,7 +6039,7 @@ fn add_trait_info(found_traits: &mut Vec, Some(DefTrait(trait_def_id)) => trait_def_id, Some(..) | None => continue, }; - if self.trait_item_map.borrow().contains_key(&(name, did)) { + if self.trait_item_map.contains_key(&(name, did)) { add_trait_info(&mut found_traits, did, name); self.used_imports.insert((import.type_id, TypeNS)); match target.target_module.def_id.get() { @@ -6329,7 +6304,7 @@ pub fn resolve_crate(session: &Session, CrateMap { def_map: resolver.def_map, freevars: resolver.freevars, - capture_mode_map: resolver.capture_mode_map, + capture_mode_map: RefCell::new(resolver.capture_mode_map), exp_map2: resolver.export_map2, trait_map: resolver.trait_map, external_exports: resolver.external_exports, -- 2.44.0