use self::UseLexicalScopeFlag::*;
use self::ModulePrefixResult::*;
use self::AssocItemResolveResult::*;
-use self::NameSearchType::*;
use self::BareIdentifierPatternResolution::*;
use self::ParentLink::*;
use self::FallbackChecks::*;
ResolveAttempt(Option<PathResolution>),
}
-#[derive(Copy, Clone, PartialEq)]
-enum NameSearchType {
- /// We're doing a name search in order to resolve a `use` directive.
- ImportSearch,
-
- /// We're doing a name search in order to resolve a path type, a path
- /// expression, or a path pattern.
- PathSearch,
-}
-
#[derive(Copy, Clone)]
enum BareIdentifierPatternResolution {
FoundStructOrEnumVariant(Def, LastPrivate),
module_path: &[Name],
index: usize,
span: Span,
- name_search_type: NameSearchType,
lp: LastPrivate)
-> ResolveResult<(Module<'a>, LastPrivate)> {
fn search_parent_externals<'a>(needle: Name, module: Module<'a>)
// modules as we go.
while index < module_path_len {
let name = module_path[index];
- match self.resolve_name_in_module(search_module,
- name,
- TypeNS,
- name_search_type,
- false) {
+ match self.resolve_name_in_module(search_module, name, TypeNS, false) {
Failed(None) => {
let segment_name = name.as_str();
let module_name = module_to_string(search_module);
module_: Module<'a>,
module_path: &[Name],
use_lexical_scope: UseLexicalScopeFlag,
- span: Span,
- name_search_type: NameSearchType)
+ span: Span)
-> ResolveResult<(Module<'a>, LastPrivate)> {
let module_path_len = module_path.len();
assert!(module_path_len > 0);
module_path,
start_index,
span,
- name_search_type,
last_private)
}
}
// Resolve the name in the parent module.
- match self.resolve_name_in_module(search_module,
- name,
- namespace,
- PathSearch,
- true) {
+ match self.resolve_name_in_module(search_module, name, namespace, true) {
Failed(Some((span, msg))) => {
resolve_error(self, span, ResolutionError::FailedToResolve(&*msg));
}
module_: Module<'a>,
name: Name,
namespace: Namespace,
- name_search_type: NameSearchType,
allow_private_imports: bool)
-> ResolveResult<(Target<'a>, bool)> {
debug!("(resolving name in module) resolving `{}` in `{}`",
let containing_module;
let last_private;
let current_module = self.current_module;
- match self.resolve_module_path(current_module,
- &module_path[..],
- UseLexicalScope,
- span,
- PathSearch) {
+ match self.resolve_module_path(current_module, &module_path, UseLexicalScope, span) {
Failed(err) => {
let (span, msg) = match err {
Some((span, msg)) => (span, msg),
}
let name = segments.last().unwrap().identifier.name;
- let def = match self.resolve_name_in_module(containing_module,
- name,
- namespace,
- NameSearchType::PathSearch,
- false) {
+ let def = match self.resolve_name_in_module(containing_module, name, namespace, false) {
Success((Target { binding, .. }, _)) => {
let (def, lp) = binding.def_and_lp();
(def, last_private.or(lp))
&module_path[..],
0,
span,
- PathSearch,
LastMod(AllPublic)) {
Failed(err) => {
let (span, msg) = match err {
}
let name = segments.last().unwrap().identifier.name;
- match self.resolve_name_in_module(containing_module,
- name,
- namespace,
- NameSearchType::PathSearch,
- false) {
+ match self.resolve_name_in_module(containing_module, name, namespace, false) {
Success((Target { binding, .. }, _)) => {
let (def, lp) = binding.def_and_lp();
Some((def, last_private.or(lp)))
if let Success((target, _)) = self.resolve_name_in_module(module,
ident.unhygienic_name,
namespace,
- PathSearch,
true) {
if let Some(def) = target.binding.def() {
return Some(LocalDef::from_def(def));
}
}
} else {
- match this.resolve_module_path(root,
- &name_path[..],
- UseLexicalScope,
- span,
- PathSearch) {
+ match this.resolve_module_path(root, &name_path, UseLexicalScope, span) {
Success((module, _)) => Some(module),
_ => None,
}
let current_module = self.current_module;
match self.resolve_module_path(current_module,
- &name_path[..],
- UseLexicalScope,
- expr.span,
- PathSearch) {
+ &name_path[..],
+ UseLexicalScope,
+ expr.span) {
Success(_) => {
context = UnresolvedNameContext::PathIsMod(expr.id);
},