diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/librustc_resolve/resolve_imports.rs | 50 |
1 files changed, 24 insertions, 26 deletions
diff --git a/src/librustc_resolve/resolve_imports.rs b/src/librustc_resolve/resolve_imports.rs index 195333f4acd..e76a93a6db0 100644 --- a/src/librustc_resolve/resolve_imports.rs +++ b/src/librustc_resolve/resolve_imports.rs @@ -65,7 +65,7 @@ pub struct ImportDirective<'a> { pub id: NodeId, parent: Module<'a>, module_path: Vec<Name>, - target_module: Cell<Option<Module<'a>>>, // the resolution of `module_path` + imported_module: Cell<Option<Module<'a>>>, // the resolution of `module_path` subclass: ImportDirectiveSubclass<'a>, span: Span, vis: Cell<ty::Visibility>, @@ -192,8 +192,8 @@ impl<'a> Resolver<'a> { // Check if the globs are determined for directive in module.globs.borrow().iter() { if self.is_accessible(directive.vis.get()) { - if let Some(target_module) = directive.target_module.get() { - let result = self.resolve_name_in_module(target_module, name, ns, true, None); + if let Some(module) = directive.imported_module.get() { + let result = self.resolve_name_in_module(module, name, ns, true, None); if let Indeterminate = result { return Indeterminate; } @@ -220,15 +220,15 @@ impl<'a> Resolver<'a> { match resolution.single_imports { SingleImports::AtLeastOne => return Some(Indeterminate), SingleImports::MaybeOne(directive) if self.is_accessible(directive.vis.get()) => { - let target_module = match directive.target_module.get() { - Some(target_module) => target_module, + let module = match directive.imported_module.get() { + Some(module) => module, None => return Some(Indeterminate), }; let name = match directive.subclass { SingleImport { source, .. } => source, GlobImport { .. } => unreachable!(), }; - match self.resolve_name_in_module(target_module, name, ns, true, None) { + match self.resolve_name_in_module(module, name, ns, true, None) { Failed(_) => {} _ => return Some(Indeterminate), } @@ -250,7 +250,7 @@ impl<'a> Resolver<'a> { let directive = self.arenas.alloc_import_directive(ImportDirective { parent: current_module, module_path: module_path, - target_module: Cell::new(None), + imported_module: Cell::new(None), subclass: subclass, span: span, id: id, @@ -485,10 +485,9 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> { names_to_string(&directive.module_path), module_to_string(self.current_module)); - let module = directive.parent; - self.set_current_module(module); + self.set_current_module(directive.parent); - let target_module = if let Some(module) = directive.target_module.get() { + let module = if let Some(module) = directive.imported_module.get() { module } else { let vis = directive.vis.get(); @@ -506,7 +505,7 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> { } }; - directive.target_module.set(Some(target_module)); + directive.imported_module.set(Some(module)); let (source, target, value_result, type_result) = match directive.subclass { SingleImport { source, target, ref value_result, ref type_result } => (source, target, value_result, type_result), @@ -520,7 +519,7 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> { for &(ns, result) in &[(ValueNS, value_result), (TypeNS, type_result)] { if let Err(false) = result.get() { result.set({ - match self.resolve_name_in_module(target_module, source, ns, false, None) { + match self.resolve_name_in_module(module, source, ns, false, None) { Success(binding) => Ok(binding), Indeterminate => Err(false), Failed(_) => Err(true), @@ -533,7 +532,7 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> { match result.get() { Err(false) => indeterminate = true, Err(true) => { - self.update_resolution(module, target, ns, |_, resolution| { + self.update_resolution(directive.parent, target, ns, |_, resolution| { resolution.single_imports.directive_failed() }); } @@ -549,10 +548,10 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> { } Ok(binding) => { let imported_binding = self.import(binding, directive); - let conflict = self.try_define(module, target, ns, imported_binding); + let conflict = self.try_define(directive.parent, target, ns, imported_binding); if let Err(old_binding) = conflict { let binding = &self.import(binding, directive); - self.report_conflict(module, target, ns, binding, old_binding); + self.report_conflict(directive.parent, target, ns, binding, old_binding); } } } @@ -666,38 +665,37 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> { } fn resolve_glob_import(&mut self, directive: &'b ImportDirective<'b>) { - let target_module = directive.target_module.get().unwrap(); - self.populate_module_if_necessary(target_module); + let module = directive.imported_module.get().unwrap(); + self.populate_module_if_necessary(module); - if let Some(Def::Trait(_)) = target_module.def { + if let Some(Def::Trait(_)) = module.def { self.session.span_err(directive.span, "items in traits are not importable."); } - let module = directive.parent; - if target_module.def_id() == module.def_id() { + if module.def_id() == directive.parent.def_id() { return; } else if let GlobImport { is_prelude: true } = directive.subclass { - self.prelude = Some(target_module); + self.prelude = Some(module); return; } - // Add to target_module's glob_importers - target_module.glob_importers.borrow_mut().push(directive); + // Add to module's glob_importers + module.glob_importers.borrow_mut().push(directive); // Ensure that `resolutions` isn't borrowed during `try_define`, // since it might get updated via a glob cycle. - let bindings = target_module.resolutions.borrow().iter().filter_map(|(name, resolution)| { + let bindings = module.resolutions.borrow().iter().filter_map(|(name, resolution)| { resolution.borrow().binding().map(|binding| (*name, binding)) }).collect::<Vec<_>>(); for ((name, ns), binding) in bindings { if binding.is_importable() && binding.is_pseudo_public() { let imported_binding = self.import(binding, directive); - let _ = self.try_define(module, name, ns, imported_binding); + let _ = self.try_define(directive.parent, name, ns, imported_binding); } } // Record the destination of this import - if let Some(did) = target_module.def_id() { + if let Some(did) = module.def_id() { let resolution = PathResolution::new(Def::Mod(did)); self.def_map.insert(directive.id, resolution); } |