resolve: Fallback to extern crates in absolute paths on 2015 edition

Author: petrochenkov

src/librustc_resolve/build_reduced_graph.rs

@@ -129,8 +129,7 @@ impl<'a> Resolver<'a> {
         // get crate root prepended, but get special treatment during in-scope resolution instead.
         let is_glob = if let ast::UseTreeKind::Glob = use_tree.kind { true } else { false };
         let crate_root = match prefix_iter.peek() {
-            Some(seg) if !seg.ident.is_path_segment_keyword() &&
-                         seg.ident.span.rust_2015() && self.session.rust_2015() => {
+            Some(seg) if !seg.ident.is_path_segment_keyword() && seg.ident.span.rust_2015() => {
                 Some(seg.ident.span.ctxt())
             }
             None if is_glob && use_tree.span.rust_2015() => {

src/librustc_resolve/lib.rs

@@ -1243,7 +1243,7 @@ struct UseError<'a> {
 #[derive(Clone, Copy, PartialEq, Debug)]
 enum AmbiguityKind {
     Import,
-    AbsolutePath,
+    // AbsolutePath,
     BuiltinAttr,
     DeriveHelper,
     LegacyHelperVsPrelude,
@@ -1259,8 +1259,8 @@ impl AmbiguityKind {
         match self {
             AmbiguityKind::Import =>
                 "name vs any other name during import resolution",
-            AmbiguityKind::AbsolutePath =>
-                "name in the crate root vs extern crate during absolute path resolution",
+            // AmbiguityKind::AbsolutePath =>
+                // "name in the crate root vs extern crate during absolute path resolution",
             AmbiguityKind::BuiltinAttr =>
                 "built-in attribute vs any other name",
             AmbiguityKind::DeriveHelper =>
@@ -1513,6 +1513,8 @@ pub struct Resolver<'a> {
     /// FIXME: Refactor things so that these fields are passed through arguments and not resolver.
     /// We are resolving a last import segment during import validation.
     last_import_segment: bool,
+    /// We are resolving a prefix for `use *` or `use ::*` on 2015 edition.
+    root_glob_import: bool,
     /// This binding should be ignored during in-module resolution, so that we don't get
     /// "self-confirming" import resolutions during import validation.
     blacklisted_binding: Option<&'a NameBinding<'a>>,
@@ -1861,6 +1863,7 @@ impl<'a> Resolver<'a> {
             current_self_type: None,
             current_self_item: None,
             last_import_segment: false,
+            root_glob_import: false,
             blacklisted_binding: None,
 
             primitive_type_table: PrimitiveTypeTable::new(),
@@ -3833,19 +3836,17 @@ impl<'a> Resolver<'a> {
                             self.resolve_self(&mut ctxt, self.current_module)));
                         continue;
                     }
-                    if name == keywords::PathRoot.name() && ident.span.rust_2018() {
-                        module = Some(ModuleOrUniformRoot::ExternPrelude);
-                        continue;
-                    }
-                    if name == keywords::PathRoot.name() &&
-                       ident.span.rust_2015() && self.session.rust_2018() {
-                        // `::a::b` from 2015 macro on 2018 global edition
-                        module = Some(ModuleOrUniformRoot::CrateRootAndExternPrelude);
+                    if name == keywords::PathRoot.name() {
+                        module = Some(if ident.span.rust_2018() {
+                            ModuleOrUniformRoot::ExternPrelude
+                        } else if !self.root_glob_import {
+                            ModuleOrUniformRoot::CrateRootAndExternPrelude
+                        } else {
+                            ModuleOrUniformRoot::Module(self.resolve_crate_root(ident))
+                        });
                         continue;
                     }
-                    if name == keywords::PathRoot.name() ||
-                       name == keywords::Crate.name() ||
-                       name == keywords::DollarCrate.name() {
+                    if name == keywords::Crate.name() || name == keywords::DollarCrate.name() {
                         // `::a::b`, `crate::a::b` or `$crate::a::b`
                         module = Some(ModuleOrUniformRoot::Module(
                             self.resolve_crate_root(ident)));

src/librustc_resolve/macros.rs

@@ -709,8 +709,6 @@ impl<'a> Resolver<'a> {
 
                             let ambiguity_error_kind = if is_import {
                                 Some(AmbiguityKind::Import)
-                            } else if is_absolute_path {
-                                Some(AmbiguityKind::AbsolutePath)
                             } else if innermost_def == builtin || def == builtin {
                                 Some(AmbiguityKind::BuiltinAttr)
                             } else if innermost_def == derive_helper || def == derive_helper {
@@ -824,44 +822,7 @@ impl<'a> Resolver<'a> {
         }
 
         // The first found solution was the only one, return it.
-        if let Some((binding, flags)) = innermost_result {
-            // We get to here only if there's no ambiguity, in ambiguous cases an error will
-            // be reported anyway, so there's no reason to report an additional feature error.
-            // The `binding` can actually be introduced by something other than `--extern`,
-            // but its `Def` should coincide with a crate passed with `--extern`
-            // (otherwise there would be ambiguity) and we can skip feature error in this case.
-            'ok: {
-                if !is_import || !rust_2015 {
-                    break 'ok;
-                }
-                if ns == TypeNS && use_prelude && self.extern_prelude_get(ident, true).is_some() {
-                    break 'ok;
-                }
-                let root_ident = Ident::new(keywords::PathRoot.name(), orig_ident.span);
-                let root_module = self.resolve_crate_root(root_ident);
-                if self.resolve_ident_in_module_ext(ModuleOrUniformRoot::Module(root_module),
-                                                    orig_ident, ns, None, false, path_span)
-                                                    .is_ok() {
-                    break 'ok;
-                }
-
-                let msg = "imports can only refer to extern crate names passed with \
-                           `--extern` in macros originating from 2015 edition";
-                let mut err = self.session.struct_span_err(ident.span, msg);
-                let what = self.binding_description(binding, ident,
-                                                    flags.contains(Flags::MISC_FROM_PRELUDE));
-                let note_msg = format!("this import refers to {what}", what = what);
-                let label_span = if binding.span.is_dummy() {
-                    err.note(&note_msg);
-                    ident.span
-                } else {
-                    err.span_note(binding.span, &note_msg);
-                    binding.span
-                };
-                err.span_label(label_span, "not an extern crate passed with `--extern`");
-                err.emit();
-            }
-
+        if let Some((binding, _)) = innermost_result {
             return Ok(binding);
         }
 

src/librustc_resolve/resolve_imports.rs

@@ -765,6 +765,9 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> {
         } else {
             // For better failure detection, pretend that the import will
             // not define any names while resolving its module path.
+            let orig_root_glob_import = mem::replace(
+                &mut self.root_glob_import, directive.is_glob() && directive.module_path.len() == 1
+            );
             let orig_vis = directive.vis.replace(ty::Visibility::Invisible);
             let path_res = self.resolve_path(
                 &directive.module_path,
@@ -775,6 +778,7 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> {
                 directive.crate_lint(),
             );
             directive.vis.set(orig_vis);
+            self.root_glob_import = orig_root_glob_import;
 
             match path_res {
                 PathResult::Module(module) => module,
@@ -850,12 +854,16 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> {
     ) -> Option<(Span, String, Option<String>)> {
         self.current_module = directive.parent_scope.module;
 
+        let orig_root_glob_import = mem::replace(
+            &mut self.root_glob_import, directive.is_glob() && directive.module_path.len() == 1
+        );
         let orig_vis = directive.vis.replace(ty::Visibility::Invisible);
         let prev_ambiguity_errors_len = self.ambiguity_errors.len();
         let path_res = self.resolve_path(&directive.module_path, None, &directive.parent_scope,
                                          true, directive.span, directive.crate_lint());
         let no_ambiguity = self.ambiguity_errors.len() == prev_ambiguity_errors_len;
         directive.vis.set(orig_vis);
+        self.root_glob_import = orig_root_glob_import;
         let module = match path_res {
             PathResult::Module(module) => {
                 // Consistency checks, analogous to `finalize_current_module_macro_resolutions`.

src/test/run-make-fulldeps/extern-prelude/Makefile

@@ -7,5 +7,4 @@ all:
 	$(RUSTC) basic.rs --extern ep_lib=$(TMPDIR)/libep_lib.rlib
 	$(RUSTC) shadow-mod.rs --extern ep_lib=$(TMPDIR)/libep_lib.rlib
 	$(RUSTC) shadow-prelude.rs --extern Vec=$(TMPDIR)/libep_vec.rlib
-	$(RUSTC) relative-only.rs --extern ep_lib=$(TMPDIR)/libep_lib.rlib 2>&1 | $(CGREP) "unresolved import"
-	$(RUSTC) relative-only.rs --extern ep_lib=$(TMPDIR)/libep_lib.rlib 2>&1 | $(CGREP) "failed to resolve"
+	$(RUSTC) relative-only.rs --extern ep_lib=$(TMPDIR)/libep_lib.rlib

src/test/ui/did_you_mean/issue-38054-do-not-show-unresolved-names.stderr

@@ -2,13 +2,13 @@ error[E0432]: unresolved import `Foo`
   --> $DIR/issue-38054-do-not-show-unresolved-names.rs:1:5
    |
 LL | use Foo; //~ ERROR unresolved
-   |     ^^^ no `Foo` in the root
+   |     ^^^ no `Foo` external crate
 
 error[E0432]: unresolved import `Foo1`
   --> $DIR/issue-38054-do-not-show-unresolved-names.rs:3:5
    |
 LL | use Foo1; //~ ERROR unresolved
-   |     ^^^^ no `Foo1` in the root
+   |     ^^^^ no `Foo1` external crate
 
 error: aborting due to 2 previous errors
 

src/test/ui/editions/edition-imports-2018.rs

@@ -1,3 +1,4 @@
+// compile-pass
 // edition:2018
 // aux-build:edition-imports-2015.rs
 
@@ -21,7 +22,7 @@ mod check {
 }
 
 mod check_glob {
-    gen_glob!(); //~ ERROR cannot glob-import all possible crates
+    gen_glob!(); // OK
 }
 
 fn main() {}

src/test/ui/editions/edition-imports-2018.stderr

@@ -1,3 +1,4 @@
+// compile-pass
 // edition:2018
 // compile-flags:--extern edition_imports_2015
 // aux-build:edition-imports-2015.rs
@@ -12,8 +13,7 @@ mod check {
     pub struct Ambiguous {}
 
     fn check() {
-        edition_imports_2015::gen_ambiguous!(); //~ ERROR `Ambiguous` is ambiguous
-                                                //~| ERROR `edition_imports_2015` is ambiguous
+        edition_imports_2015::gen_ambiguous!();
     }
 }