OpenE2K/rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Refactor resolve_import_for_module

Browse Source
This commit is contained in:
Jeffrey Seyfried 2016-01-16 11:41:19 +00:00
parent 0c40621759
commit 964b72b3e0
2 changed files with 32 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/librustc_resolve/lib.rs
View File

@ -662,10 +662,11 @@ enum ResolveResult<T> {
}
impl<T> ResolveResult<T> {
fn success(&self) -> bool {
match *self {
Success(_) => true,
_ => false,
fn and_then<U, F: FnOnce(T) -> ResolveResult<U>>(self, f: F) -> ResolveResult<U> {
match self {
Failed(msg) => Failed(msg),
Indeterminate => Indeterminate,
Success(t) => f(t),
}
}
}
@ -1335,8 +1336,9 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
use_lexical_scope: UseLexicalScopeFlag,
span: Span)
-> ResolveResult<(Module<'a>, LastPrivate)> {
let module_path_len = module_path.len();
assert!(module_path_len > 0);
if module_path.len() == 0 {
return Success((self.graph_root, LastMod(AllPublic))) // Use the crate root
}
debug!("(resolving module path for import) processing `{}` rooted at `{}`",
names_to_string(module_path),

95
src/librustc_resolve/resolve_imports.rs
View File

@ -332,92 +332,45 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
module_: Module<'b>,
import_directive: &ImportDirective)
-> ResolveResult<()> {
let mut resolution_result = ResolveResult::Failed(None);
let module_path = &import_directive.module_path;
debug!("(resolving import for module) resolving import `{}::...` in `{}`",
names_to_string(&module_path[..]),
names_to_string(&import_directive.module_path),
module_to_string(&*module_));
// First, resolve the module path for the directive, if necessary.
let container = if module_path.is_empty() {
// Use the crate root.
Some((self.resolver.graph_root, LastMod(AllPublic)))
} else {
match self.resolver.resolve_module_path(module_,
&module_path[..],
UseLexicalScopeFlag::DontUseLexicalScope,
import_directive.span) {
ResolveResult::Failed(err) => {
resolution_result = ResolveResult::Failed(err);
None
}
ResolveResult::Indeterminate => {
resolution_result = ResolveResult::Indeterminate;
None
}
ResolveResult::Success(container) => Some(container),
}
};
match container {
None => {}
Some((containing_module, lp)) => {
self.resolver
.resolve_module_path(module_,
&import_directive.module_path,
UseLexicalScopeFlag::DontUseLexicalScope,
import_directive.span)
.and_then(|(containing_module, lp)| {
// We found the module that the target is contained
// within. Attempt to resolve the import within it.
match import_directive.subclass {
SingleImport(target, source) => {
resolution_result = self.resolve_single_import(&module_,
containing_module,
target,
source,
import_directive,
lp);
}
GlobImport => {
resolution_result = self.resolve_glob_import(&module_,
containing_module,
import_directive,
lp);
}
if let SingleImport(target, source) = import_directive.subclass {
self.resolve_single_import(&module_,
containing_module,
target,
source,
import_directive,
lp)
} else {
self.resolve_glob_import(&module_, containing_module, import_directive, lp)
}
}
}
// Decrement the count of unresolved imports.
match resolution_result {
ResolveResult::Success(()) => {
})
.and_then(|()| {
// Decrement the count of unresolved imports.
assert!(self.resolver.unresolved_imports >= 1);
self.resolver.unresolved_imports -= 1;
}
_ => {
// Nothing to do here; just return the error.
}
}
// Decrement the count of unresolved globs if necessary. But only if
// the resolution result is a success -- other cases will
// be handled by the main loop.
if resolution_result.success() {
match import_directive.subclass {
GlobImport => {
if let GlobImport = import_directive.subclass {
module_.dec_glob_count();
if import_directive.is_public {
module_.dec_pub_glob_count();
}
}
SingleImport(..) => {
// Ignore.
if import_directive.is_public {
module_.dec_pub_count();
}
}
if import_directive.is_public {
module_.dec_pub_count();
}
}
return resolution_result;
Success(())
})
}
/// Resolves the name in the namespace of the module because it is being imported by