bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Add field parent to ImportDirective.

Browse source
This commit is contained in:
Jeffrey Seyfried 2016-08-17 00:42:14 +00:00
parent d107d22590
commit c64cd86be8
2 changed files with 11 additions and 14 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/librustc_resolve/lib.rs
View file

@ -756,7 +756,7 @@ pub struct ModuleS<'a> {
no_implicit_prelude: Cell<bool>, no_implicit_prelude: Cell<bool>,
glob_importers: RefCell<Vec<(Module<'a>, &'a ImportDirective<'a>)>>, glob_importers: RefCell<Vec<&'a ImportDirective<'a>>>,
globs: RefCell<Vec<&'a ImportDirective<'a>>>, globs: RefCell<Vec<&'a ImportDirective<'a>>>,
// Used to memoize the traits in this module for faster searches through all traits in scope. // Used to memoize the traits in this module for faster searches through all traits in scope.

23
src/librustc_resolve/resolve_imports.rs
View file

@ -63,6 +63,7 @@ impl ImportDirectiveSubclass {
#[derive(Debug,Clone)] #[derive(Debug,Clone)]
pub struct ImportDirective<'a> { pub struct ImportDirective<'a> {
pub id: NodeId, pub id: NodeId,
parent: Module<'a>,
module_path: Vec<Name>, module_path: Vec<Name>,
target_module: Cell<Option<Module<'a>>>, // the resolution of `module_path` target_module: Cell<Option<Module<'a>>>, // the resolution of `module_path`
subclass: ImportDirectiveSubclass, subclass: ImportDirectiveSubclass,
@ -223,6 +224,7 @@ impl<'a> Resolver<'a> {
id: NodeId, id: NodeId,
vis: ty::Visibility) { vis: ty::Visibility) {
let directive = self.arenas.alloc_import_directive(ImportDirective { let directive = self.arenas.alloc_import_directive(ImportDirective {
parent: self.current_module,
module_path: module_path, module_path: module_path,
target_module: Cell::new(None), target_module: Cell::new(None),
subclass: subclass, subclass: subclass,
@ -306,9 +308,9 @@ impl<'a> Resolver<'a> {
// Define `new_binding` in `module`s glob importers. // Define `new_binding` in `module`s glob importers.
if new_binding.is_importable() && new_binding.is_pseudo_public() { if new_binding.is_importable() && new_binding.is_pseudo_public() {
for &(importer, directive) in module.glob_importers.borrow_mut().iter() { for directive in module.glob_importers.borrow_mut().iter() {
let imported_binding = self.import(new_binding, directive); let imported_binding = self.import(new_binding, directive);
let _ = self.try_define(importer, name, ns, imported_binding); let _ = self.try_define(directive.parent, name, ns, imported_binding);
} }
} }
@ -317,8 +319,6 @@ impl<'a> Resolver<'a> {
} }
struct ImportResolvingError<'a> { struct ImportResolvingError<'a> {
/// Module where the error happened
source_module: Module<'a>,
import_directive: &'a ImportDirective<'a>, import_directive: &'a ImportDirective<'a>,
span: Span, span: Span,
help: String, help: String,
@ -402,9 +402,7 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> {
// Define a "dummy" resolution containing a Def::Err as a placeholder for a // Define a "dummy" resolution containing a Def::Err as a placeholder for a
// failed resolution // failed resolution
fn import_dummy_binding(&mut self, fn import_dummy_binding(&mut self, directive: &'b ImportDirective<'b>) {
source_module: Module<'b>,
directive: &'b ImportDirective<'b>) {
if let SingleImport { target, .. } = directive.subclass { if let SingleImport { target, .. } = directive.subclass {
let dummy_binding = self.arenas.alloc_name_binding(NameBinding { let dummy_binding = self.arenas.alloc_name_binding(NameBinding {
kind: NameBindingKind::Def(Def::Err), kind: NameBindingKind::Def(Def::Err),
@ -413,8 +411,8 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> {
}); });
let dummy_binding = self.import(dummy_binding, directive); let dummy_binding = self.import(dummy_binding, directive);
let _ = self.try_define(source_module, target, ValueNS, dummy_binding.clone()); let _ = self.try_define(directive.parent, target, ValueNS, dummy_binding.clone());
let _ = self.try_define(source_module, target, TypeNS, dummy_binding); let _ = self.try_define(directive.parent, target, TypeNS, dummy_binding);
} }
} }
@ -423,7 +421,7 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> {
fn import_resolving_error(&mut self, e: ImportResolvingError<'b>) { fn import_resolving_error(&mut self, e: ImportResolvingError<'b>) {
// If the error is a single failed import then create a "fake" import // If the error is a single failed import then create a "fake" import
// resolution for it so that later resolve stages won't complain. // resolution for it so that later resolve stages won't complain.
self.import_dummy_binding(e.source_module, e.import_directive); self.import_dummy_binding(e.import_directive);
let path = import_path_to_string(&e.import_directive.module_path, let path = import_path_to_string(&e.import_directive.module_path,
&e.import_directive.subclass); &e.import_directive.subclass);
resolve_error(self.resolver, resolve_error(self.resolver,
@ -445,7 +443,6 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> {
None => (import_directive.span, String::new()), None => (import_directive.span, String::new()),
}; };
errors.push(ImportResolvingError { errors.push(ImportResolvingError {
source_module: self.current_module,
import_directive: import_directive, import_directive: import_directive,
span: span, span: span,
help: help, help: help,
@ -511,7 +508,7 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> {
.emit(); .emit();
// Do not import this illegal binding. Import a dummy binding and pretend // Do not import this illegal binding. Import a dummy binding and pretend
// everything is fine // everything is fine
self.import_dummy_binding(module, directive); self.import_dummy_binding(directive);
return Success(()); return Success(());
} }
Success(binding) if !self.is_accessible(binding.vis) => {} Success(binding) if !self.is_accessible(binding.vis) => {}
@ -635,7 +632,7 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> {
} }
// Add to target_module's glob_importers // Add to target_module's glob_importers
target_module.glob_importers.borrow_mut().push((module, directive)); target_module.glob_importers.borrow_mut().push(directive);
// Ensure that `resolutions` isn't borrowed during `try_define`, // Ensure that `resolutions` isn't borrowed during `try_define`,
// since it might get updated via a glob cycle. // since it might get updated via a glob cycle.