Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Resolve: Fix an ICE introduced by import resolution error recovery #31212

Merged
merged 3 commits into from
Jan 29, 2016
Merged

Resolve: Fix an ICE introduced by import resolution error recovery #31212

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
6ba35ce
Resolve: Fix an ICE that occurs when an identifier refers to an indet…
jseyfried Jan 26, 2016
1fcde2b
Add test for #31212
jseyfried Jan 26, 2016
d2d2144
Refactor away NameSearchType
jseyfried Jan 26, 2016
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
84 changes: 14 additions & 70 deletions src/librustc_resolve/lib.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -44,7 +44,6 @@ use self::RibKind::*;
use self::UseLexicalScopeFlag::*;
use self::ModulePrefixResult::*;
use self::AssocItemResolveResult::*;
use self::NameSearchType::*;
use self::BareIdentifierPatternResolution::*;
use self::ParentLink::*;
use self::FallbackChecks::*;
Expand Down Expand Up @@ -784,16 +783,6 @@ enum AssocItemResolveResult {
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),
Expand Down Expand Up @@ -1370,7 +1359,6 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
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>)
Expand All @@ -1396,11 +1384,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
// 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);
Expand Down Expand Up @@ -1477,8 +1461,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
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);
Expand Down Expand Up @@ -1559,7 +1542,6 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
module_path,
start_index,
span,
name_search_type,
last_private)
}

Expand Down Expand Up @@ -1658,11 +1640,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
}

// 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));
}
Expand Down Expand Up @@ -1787,7 +1765,6 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
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 `{}`",
Expand All @@ -1811,14 +1788,6 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
}
}

// Next, check the module's imports if necessary.

// If this is a search of all imports, we should be done with glob
// resolution at this point.
if name_search_type == PathSearch {
assert_eq!(module_.glob_count.get(), 0);
}

// Check the list of resolved imports.
let children = module_.import_resolutions.borrow();
match children.get(&name) {
Expand Down Expand Up @@ -2935,9 +2904,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
}
}

Indeterminate => {
panic!("unexpected indeterminate result");
}
Indeterminate => return BareIdentifierPatternUnresolved,
Failed(err) => {
match err {
Some((span, msg)) => {
Expand Down Expand Up @@ -3177,11 +3144,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
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),
Expand All @@ -3195,19 +3158,15 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
resolve_error(self, span, ResolutionError::FailedToResolve(&*msg));
return None;
}
Indeterminate => panic!("indeterminate unexpected"),
Indeterminate => return None,
Success((resulting_module, resulting_last_private)) => {
containing_module = resulting_module;
last_private = resulting_last_private;
}
}

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))
Expand Down Expand Up @@ -3242,7 +3201,6 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
&module_path[..],
0,
span,
PathSearch,
LastMod(AllPublic)) {
Failed(err) => {
let (span, msg) = match err {
Expand All @@ -3258,9 +3216,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
return None;
}

Indeterminate => {
panic!("indeterminate unexpected");
}
Indeterminate => return None,

Success((resulting_module, resulting_last_private)) => {
containing_module = resulting_module;
Expand All @@ -3269,11 +3225,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
}

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)))
Expand Down Expand Up @@ -3315,7 +3267,6 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
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));
Expand Down Expand Up @@ -3355,9 +3306,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
}
}
}
Indeterminate => {
panic!("unexpected indeterminate result");
}
Indeterminate => None,
Failed(err) => {
debug!("(resolving item path by identifier in lexical scope) failed to resolve {}",
name);
Expand Down Expand Up @@ -3413,11 +3362,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
}
}
} 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,
}
Expand Down Expand Up @@ -3663,10 +3608,9 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
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);
},
Expand Down
4 changes: 1 addition & 3 deletions src/librustc_resolve/resolve_imports.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -16,7 +16,6 @@ use Namespace::{self, TypeNS, ValueNS};
use {NameBindings, NameBinding};
use NamespaceResult::{BoundResult, UnboundResult, UnknownResult};
use NamespaceResult;
use NameSearchType;
use ResolveResult;
use Resolver;
use UseLexicalScopeFlag;
Expand Down Expand Up @@ -321,8 +320,7 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
match self.resolver.resolve_module_path(module_,
&module_path[..],
UseLexicalScopeFlag::DontUseLexicalScope,
import_directive.span,
NameSearchType::ImportSearch) {
import_directive.span) {
ResolveResult::Failed(err) => {
resolution_result = ResolveResult::Failed(err);
None
Expand Down
20 changes: 20 additions & 0 deletions src/test/compile-fail/issue-31212.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,20 @@
// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

// This checks that a path that cannot be resolved because of an indeterminate import
// does not trigger an ICE.

mod foo {
pub use self::*; //~ ERROR unresolved
}

fn main() {
foo::f(); //~ ERROR unresolved
}