diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 5d10b0d9a57b8..5fc2c82d73b3b 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -1546,9 +1546,22 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } // We're out of luck. - debug!("(resolving name in module) failed to resolve `{}`", - &token::get_name(name)); - return Failed(None); + return match name_search_type { + ImportSearch => { + // In this case, it is possible that we simply chocked on a not-yet-resolved import + // (mostly due to globs), thus we do not want to conclude too early that the + // resolve is failed. The main resolve_import loop will stop us anyway if it is + // indeed unresolved. + debug!("(resolving name in module) failed to resolve `{}` for now, bailing out.", + &token::get_name(name)); + Indeterminate + }, + PathSearch => { + debug!("(resolving name in module) failed to resolve `{}`", + &token::get_name(name)); + Failed(None) + } + }; } fn report_unresolved_imports(&mut self, module_: Rc) { diff --git a/src/librustc_resolve/resolve_imports.rs b/src/librustc_resolve/resolve_imports.rs index e77e7116b9fea..d0d51c14881be 100644 --- a/src/librustc_resolve/resolve_imports.rs +++ b/src/librustc_resolve/resolve_imports.rs @@ -260,14 +260,15 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { return; } - let imports = module.imports.borrow(); + let mut imports = module.imports.borrow_mut(); let import_count = imports.len(); - while module.resolved_import_count.get() < import_count { + let mut indeterminate_imports = Vec::new(); + while module.resolved_import_count.get() + indeterminate_imports.len() < import_count { let import_index = module.resolved_import_count.get(); - let import_directive = &(*imports)[import_index]; match self.resolve_import_for_module(module.clone(), - import_directive) { + &imports[import_index]) { ResolveResult::Failed(err) => { + let import_directive = &imports[import_index]; let (span, help) = match err { Some((span, msg)) => (span, format!(". {}", msg)), None => (import_directive.span, String::new()) @@ -279,13 +280,17 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { help); self.resolver.resolve_error(span, &msg[..]); } - ResolveResult::Indeterminate => break, // Bail out. We'll come around next time. + ResolveResult::Indeterminate => { + indeterminate_imports.push(imports.swap_remove(import_index)); + continue; + }, ResolveResult::Success(()) => () // Good. Continue. } - module.resolved_import_count .set(module.resolved_import_count.get() + 1); } + // put back all the unresolved imports, for next pass + imports.extend(indeterminate_imports); } /// Attempts to resolve the given import. The return value indicates @@ -654,10 +659,12 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> { target); if value_result.is_unbound() && type_result.is_unbound() { - let msg = format!("There is no `{}` in `{}`", - token::get_name(source), - module_to_string(&target_module)); - return ResolveResult::Failed(Some((directive.span, msg))); + // Due to chained imports, it is possible that this import is simply not yet + // resolved, so we settle with Indeterminate. + // The main loop of the algorithm will break anyway is a pass does not resolve + // anything more. + debug!("(resolving single import) unresolved for now, bailing out"); + return ResolveResult::Indeterminate; } let value_used_public = value_used_reexport || value_used_public; let type_used_public = type_used_reexport || type_used_public; diff --git a/src/test/run-pass/import-glob-1.rs b/src/test/run-pass/import-glob-1.rs new file mode 100644 index 0000000000000..9dc570fbe5186 --- /dev/null +++ b/src/test/run-pass/import-glob-1.rs @@ -0,0 +1,32 @@ +// Copyright 2012-2014 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#![allow(unused_imports, dead_code)] + +mod bar { + pub use self::middle::*; + + mod middle { + pub use self::baz::Baz; + + mod baz { + pub enum Baz { + Baz1, + Baz2 + } + } + } +} + +mod foo { + use bar::Baz::{Baz1, Baz2}; +} + +fn main() {} diff --git a/src/test/run-pass/issue18083.rs b/src/test/run-pass/issue18083.rs new file mode 100644 index 0000000000000..2fbcfdca8e298 --- /dev/null +++ b/src/test/run-pass/issue18083.rs @@ -0,0 +1,29 @@ +// Copyright 2015 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +mod a { + use b::{B}; + pub use self::inner::A; + + mod inner { + pub struct A; + } +} + +mod b { + use a::{A}; + pub use self::inner::B; + + mod inner { + pub struct B; + } +} + +fn main() {} \ No newline at end of file diff --git a/src/test/run-pass/issue4865-1.rs b/src/test/run-pass/issue4865-1.rs new file mode 100644 index 0000000000000..16749d758d873 --- /dev/null +++ b/src/test/run-pass/issue4865-1.rs @@ -0,0 +1,36 @@ +// Copyright 2015 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +pub mod a { + use b::fn_b; + use c::*; + + pub fn fn_a(){ + } +} + +pub mod b { + use a::fn_a; + use c::*; + + pub fn fn_b(){ + } +} + +pub mod c{ + pub fn fn_c(){ + } +} + +use a::fn_a; +use b::fn_b; + +fn main() { +} \ No newline at end of file