Block import resolution only on 'pub' imports

src/librustc_resolve/build_reduced_graph.rs

@@ -926,6 +926,11 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> {
                                                                is_public,
                                                                shadowable));
         self.unresolved_imports += 1;
+
+        if is_public {
+            module_.pub_count.set(module_.pub_count.get() + 1);
+        }
+
         // Bump the reference count on the name. Or, if this is a glob, set
         // the appropriate flag.
 
@@ -959,6 +964,9 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> {
                 // module's exports ahead of time.
 
                 module_.glob_count.set(module_.glob_count.get() + 1);
+                if is_public {
+                    module_.pub_glob_count.set(module_.pub_glob_count.get() + 1);
+                }
             }
         }
     }

src/librustc_resolve/lib.rs

@@ -699,6 +699,12 @@ pub struct Module {
     // The number of unresolved globs that this module exports.
     glob_count: Cell<usize>,
 
+    // The number of unresolved pub imports (both regular and globs) in this module
+    pub_count: Cell<usize>,
+
+    // The number of unresolved pub glob imports in this module
+    pub_glob_count: Cell<usize>,
+
     // The index of the import we're resolving.
     resolved_import_count: Cell<usize>,
 
@@ -726,6 +732,8 @@ impl Module {
             anonymous_children: RefCell::new(NodeMap()),
             import_resolutions: RefCell::new(HashMap::new()),
             glob_count: Cell::new(0),
+            pub_count: Cell::new(0),
+            pub_glob_count: Cell::new(0),
             resolved_import_count: Cell::new(0),
             populated: Cell::new(!external),
         }

src/librustc_resolve/resolve_imports.rs

@@ -409,11 +409,19 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
                 GlobImport => {
                     assert!(module_.glob_count.get() >= 1);
                     module_.glob_count.set(module_.glob_count.get() - 1);
+                    if import_directive.is_public {
+                        assert!(module_.pub_glob_count.get() >= 1);
+                        module_.pub_glob_count.set(module_.pub_glob_count.get() - 1);
+                    }
                 }
                 SingleImport(..) => {
                     // Ignore.
                 }
             }
+            if import_directive.is_public {
+                assert!(module_.pub_count.get() >= 1);
+                module_.pub_count.set(module_.pub_count.get() - 1);
+            }
         }
 
         return resolution_result;
@@ -503,8 +511,8 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
                 // containing module, bail out. We don't know enough to be
                 // able to resolve this import.
 
-                if target_module.glob_count.get() > 0 {
-                    debug!("(resolving single import) unresolved glob; \
+                if target_module.pub_glob_count.get() > 0 {
+                    debug!("(resolving single import) unresolved pub glob; \
                             bailing out");
                     return ResolveResult::Indeterminate;
                 }
@@ -767,16 +775,22 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
 
         // We must bail out if the node has unresolved imports of any kind
         // (including globs).
-        if !(*target_module).all_imports_resolved() {
+        if (*target_module).pub_count.get() > 0 {
             debug!("(resolving glob import) target module has unresolved \
-                    imports; bailing out");
+                    pub imports; bailing out");
             return ResolveResult::Indeterminate;
         }
 
-        assert_eq!(target_module.glob_count.get(), 0);
-
         // Add all resolved imports from the containing module.
         let import_resolutions = target_module.import_resolutions.borrow();
+
+        if module_.import_resolutions.borrow_state() != ::std::cell::BorrowState::Unused {
+            // In this case, target_module == module_
+            // This means we are trying to glob import a module into itself,
+            // and it is a no-go
+            return ResolveResult::Indeterminate;
+        }
+
         for (ident, target_import_resolution) in import_resolutions.iter() {
             debug!("(resolving glob import) writing module resolution \
                     {} into `{}`",

src/test/compile-fail/issue-25396.rs

@@ -11,14 +11,14 @@
 use foo::baz;
 use bar::baz; //~ ERROR a module named `baz` has already been imported
 
-use bar::Quux; //~ ERROR a trait named `Quux` has already been imported
 use foo::Quux;
+use bar::Quux; //~ ERROR a trait named `Quux` has already been imported
 
-use foo::blah; //~ ERROR a type named `blah` has already been imported
-use bar::blah;
+use foo::blah;
+use bar::blah; //~ ERROR a type named `blah` has already been imported
 
-use foo::WOMP; //~ ERROR a value named `WOMP` has already been imported
-use bar::WOMP;
+use foo::WOMP;
+use bar::WOMP; //~ ERROR a value named `WOMP` has already been imported
 
 fn main() {}
 

src/test/run-pass/issue-4865-2.rs

@@ -0,0 +1,27 @@
+// 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 use hello::*;
+
+pub mod say {
+    pub fn hello() { println!("hello"); }
+}
+
+pub mod hello {
+    use say;
+
+    pub fn hello() {
+        say::hello();
+    }
+}
+
+fn main() {
+    hello();
+}

src/test/run-pass/issue-4865-3.rs

@@ -0,0 +1,22 @@
+// 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::*;
+}
+
+pub mod b {
+  use a::*;
+}
+
+use a::*;
+
+fn main() {
+}