Make resolve more perseverant with indeterminate imports.

When encountering an indeterminate import, still try to
resolve the following imports of the module.

This avoids dead-lock-like situations where 2 modules
are blocked, each waiting for the resolution of the other.

Fixes #18083.

Author: elinorbgr

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<Module>) {

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;

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 <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.
+
+#![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() {}

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 <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.
+
+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() {}

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 <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.
+
+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() {
+}