item_like_imports: Allow glob imports to be shadowed by items and single imports.

src/librustc_resolve/resolve_imports.rs

@@ -690,6 +690,7 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> {
             };
 
             // Report conflicts
+            if !self.new_import_semantics {
                 for duplicate_glob in resolution.duplicate_globs.iter() {
                     // FIXME #31337: We currently allow items to shadow glob-imported re-exports.
                     if !binding.is_import() {
@@ -700,6 +701,11 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> {
 
                     self.report_conflict(module, name, ns, duplicate_glob, binding);
                 }
+            } else if binding.is_glob_import() {
+                for duplicate_glob in resolution.duplicate_globs.iter() {
+                    self.report_conflict(module, name, ns, duplicate_glob, binding);
+                }
+            }
 
             if binding.vis == ty::Visibility::Public &&
                (binding.is_import() || binding.is_extern_crate()) {

src/test/run-pass/imports.rs

@@ -21,4 +21,46 @@ mod a {
     }
 }
 
+mod foo { pub fn f() {} }
+mod bar { pub fn f() {} }
+
+pub fn f() -> bool { true }
+
+// Items and explicit imports shadow globs.
+fn g() {
+    use foo::*;
+    use bar::*;
+    fn f() -> bool { true }
+    let _: bool = f();
+}
+
+fn h() {
+    use foo::*;
+    use bar::*;
+    use f;
+    let _: bool = f();
+}
+
+// Here, there appears to be shadowing but isn't because of namespaces.
+mod b {
+    use foo::*; // This imports `f` in the value namespace.
+    use super::b as f; // This imports `f` only in the type namespace,
+    fn test() { self::f(); } // so the glob isn't shadowed.
+}
+
+// Here, there is shadowing in one namespace, but not the other.
+mod c {
+    mod test {
+        pub fn f() {}
+        pub mod f {}
+    }
+    use self::test::*; // This glob-imports `f` in both namespaces.
+    mod f { pub fn f() {} } // This shadows the glob only in the value namespace.
+
+    fn test() {
+        self::f(); // Check that the glob-imported value isn't shadowed.
+        self::f::f(); // Check that the glob-imported module is shadowed.
+    }
+}
+
 fn main() {}