[WIP] resolve: Split extern prelude into two scopes

One for `--extern` options and another for `extern crate` items

Author: petrochenkov

compiler/rustc_resolve/messages.ftl

@@ -251,9 +251,6 @@ resolve_macro_cannot_use_as_derive =
 resolve_macro_defined_later =
     a macro with the same name exists, but it appears later
 
-resolve_macro_expanded_extern_crate_cannot_shadow_extern_arguments =
-    macro-expanded `extern crate` items cannot shadow names passed with `--extern`
-
 resolve_macro_expected_found =
     expected {$expected}, found {$found} `{$macro_path}`
     .label = not {$article} {$expected}

compiler/rustc_resolve/src/build_reduced_graph.rs

@@ -36,9 +36,8 @@ use crate::def_collector::collect_definitions;
 use crate::imports::{ImportData, ImportKind};
 use crate::macros::{MacroRulesBinding, MacroRulesScope, MacroRulesScopeRef};
 use crate::{
-    BindingKey, ExternPreludeEntry, Finalize, MacroData, Module, ModuleKind, ModuleOrUniformRoot,
-    NameBinding, ParentScope, PathResult, ResolutionError, Resolver, Segment, Used,
-    VisResolutionError, errors,
+    BindingKey, Finalize, MacroData, Module, ModuleKind, ModuleOrUniformRoot, NameBinding,
+    ParentScope, PathResult, ResolutionError, Resolver, Segment, Used, VisResolutionError, errors,
 };
 
 type Res = def::Res<NodeId>;
@@ -968,38 +967,12 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
         }
         self.r.potentially_unused_imports.push(import);
         let imported_binding = self.r.import(binding, import);
-        if parent == self.r.graph_root {
+        if ident.name != kw::Underscore && parent == self.r.graph_root {
             let ident = ident.normalize_to_macros_2_0();
-            if let Some(entry) = self.r.extern_prelude.get(&ident)
-                && expansion != LocalExpnId::ROOT
-                && orig_name.is_some()
-                && !entry.is_import()
-            {
-                self.r.dcx().emit_err(
-                    errors::MacroExpandedExternCrateCannotShadowExternArguments { span: item.span },
-                );
-                // `return` is intended to discard this binding because it's an
-                // unregistered ambiguity error which would result in a panic
-                // caused by inconsistency `path_res`
-                // more details: https://github.com/rust-lang/rust/pull/111761
-                return;
-            }
-            let entry = self
-                .r
-                .extern_prelude
-                .entry(ident)
-                .or_insert(ExternPreludeEntry { binding: None, introduced_by_item: true });
-            if orig_name.is_some() {
-                entry.introduced_by_item = true;
-            }
-            // Binding from `extern crate` item in source code can replace
-            // a binding from `--extern` on command line here.
-            if !entry.is_import() {
-                entry.binding = Some(imported_binding)
-            } else if ident.name != kw::Underscore {
+            if self.r.extern_prelude_item.insert(ident, imported_binding).is_some() {
                 self.r.dcx().span_delayed_bug(
                     item.span,
-                    format!("it had been define the external module '{ident}' multiple times"),
+                    format!("extern crate '{ident}' already in extern prelude"),
                 );
             }
         }

compiler/rustc_resolve/src/check_unused.rs

@@ -200,14 +200,14 @@ impl<'a, 'ra, 'tcx> UnusedImportCheckVisitor<'a, 'ra, 'tcx> {
 
             // If the extern crate isn't in the extern prelude,
             // there is no way it can be written as a `use`.
-            if self
-                .r
-                .extern_prelude
-                .get(&extern_crate.ident)
-                .is_none_or(|entry| entry.introduced_by_item)
-            {
-                continue;
-            }
+            // if self
+            //     .r
+            //     .extern_prelude
+            //     .get(&extern_crate.ident)
+            //     .is_none_or(|entry| entry.introduced_by_item)
+            // {
+            //     continue;
+            // }
 
             let module = self
                 .r

compiler/rustc_resolve/src/diagnostics.rs

@@ -322,8 +322,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         // Check if the target of the use for both bindings is the same.
         let duplicate = new_binding.res().opt_def_id() == old_binding.res().opt_def_id();
         let has_dummy_span = new_binding.span.is_dummy() || old_binding.span.is_dummy();
-        let from_item =
-            self.extern_prelude.get(&ident).is_none_or(|entry| entry.introduced_by_item);
+        // let from_item = self.extern_prelud.get(&ident).is_none_or(|entry| entry.introduced_by_item);
+        let from_item = false;
         // Only suggest removing an import if both bindings are to the same def, if both spans
         // aren't dummy spans. Further, if both bindings are imports, then the ident must have
         // been introduced by an item.
@@ -1097,8 +1097,14 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         );
                     }
                 }
-                Scope::ExternPrelude => {
-                    suggestions.extend(this.extern_prelude.iter().filter_map(|(ident, _)| {
+                Scope::ExternPreludeItem => {
+                    suggestions.extend(this.extern_prelude_item.iter().filter_map(|(ident, _)| {
+                        let res = Res::Def(DefKind::Mod, CRATE_DEF_ID.to_def_id());
+                        filter_fn(res).then_some(TypoSuggestion::typo_from_ident(*ident, res))
+                    }));
+                }
+                Scope::ExternPreludeCmd => {
+                    suggestions.extend(this.extern_prelude_cmd.iter().filter_map(|(ident, _)| {
                         let res = Res::Def(DefKind::Mod, CRATE_DEF_ID.to_def_id());
                         filter_fn(res).then_some(TypoSuggestion::typo_from_ident(*ident, res))
                     }));
@@ -1411,7 +1417,14 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         );
 
         if lookup_ident.span.at_least_rust_2018() {
-            for ident in self.extern_prelude.clone().into_keys() {
+            // let mut zlaks = Vec::new();
+            // for (ident, binding) in &self.extern_prelude_item {
+            //     zlaks.push(ident, binding.res().def_id());
+            // }
+            for ident in self.extern_prelude_item.clone().into_keys() {
+                if true {
+                    continue;
+                }
                 if ident.span.from_expansion() {
                     // Idents are adjusted to the root context before being
                     // resolved in the extern prelude, so reporting this to the
@@ -2150,9 +2163,10 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         current_module: Module<'ra>,
     ) -> Option<Symbol> {
         let mut candidates = self
-            .extern_prelude
+            .extern_prelude_item
             .keys()
             .map(|ident| ident.name)
+            .chain(self.extern_prelude_cmd.keys().map(|ident| ident.name))
             .chain(
                 self.local_module_map
                     .iter()
@@ -2611,8 +2625,12 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         // Sort extern crate names in *reverse* order to get
         // 1) some consistent ordering for emitted diagnostics, and
         // 2) `std` suggestions before `core` suggestions.
-        let mut extern_crate_names =
-            self.extern_prelude.keys().map(|ident| ident.name).collect::<Vec<_>>();
+        let mut extern_crate_names = self
+            .extern_prelude_item
+            .keys()
+            .chain(self.extern_prelude_cmd.keys())
+            .map(|ident| ident.name)
+            .collect::<Vec<_>>();
         extern_crate_names.sort_by(|a, b| b.as_str().cmp(a.as_str()));
 
         for name in extern_crate_names.into_iter() {

compiler/rustc_resolve/src/errors.rs

@@ -862,13 +862,6 @@ pub(crate) struct UnnamedCrateRootImport {
     pub(crate) span: Span,
 }
 
-#[derive(Diagnostic)]
-#[diag(resolve_macro_expanded_extern_crate_cannot_shadow_extern_arguments)]
-pub(crate) struct MacroExpandedExternCrateCannotShadowExternArguments {
-    #[primary_span]
-    pub(crate) span: Span,
-}
-
 #[derive(Diagnostic)]
 #[diag(resolve_elided_anonymous_lifetime_report_error, code = E0637)]
 pub(crate) struct ElidedAnonymousLifetimeReportError {

compiler/rustc_resolve/src/ident.rs

@@ -138,7 +138,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 Scope::Module(..) => true,
                 Scope::MacroUsePrelude => use_prelude || rust_2015,
                 Scope::BuiltinAttrs => true,
-                Scope::ExternPrelude => use_prelude || module_and_extern_prelude,
+                Scope::ExternPreludeCmd | Scope::ExternPreludeItem => {
+                    use_prelude || module_and_extern_prelude
+                }
                 Scope::ToolPrelude => use_prelude,
                 Scope::StdLibPrelude => use_prelude || ns == MacroNS,
                 Scope::BuiltinTypes => true,
@@ -177,7 +179,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 Scope::Module(..) if module_and_extern_prelude => match ns {
                     TypeNS => {
                         ctxt.adjust(ExpnId::root());
-                        Scope::ExternPrelude
+                        Scope::ExternPreludeItem
                     }
                     ValueNS | MacroNS => break,
                 },
@@ -194,7 +196,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         None => {
                             ctxt.adjust(ExpnId::root());
                             match ns {
-                                TypeNS => Scope::ExternPrelude,
+                                TypeNS => Scope::ExternPreludeItem,
                                 ValueNS => Scope::StdLibPrelude,
                                 MacroNS => Scope::MacroUsePrelude,
                             }
@@ -203,8 +205,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 }
                 Scope::MacroUsePrelude => Scope::StdLibPrelude,
                 Scope::BuiltinAttrs => break, // nowhere else to search
-                Scope::ExternPrelude if module_and_extern_prelude => break,
-                Scope::ExternPrelude => Scope::ToolPrelude,
+                Scope::ExternPreludeItem => Scope::ExternPreludeCmd,
+                Scope::ExternPreludeCmd if module_and_extern_prelude => break,
+                Scope::ExternPreludeCmd => Scope::ToolPrelude,
                 Scope::ToolPrelude => Scope::StdLibPrelude,
                 Scope::StdLibPrelude => match ns {
                     TypeNS => Scope::BuiltinTypes,
@@ -555,14 +558,20 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         Some(binding) => Ok((*binding, Flags::empty())),
                         None => Err(Determinacy::Determined),
                     },
-                    Scope::ExternPrelude => {
-                        match this.extern_prelude_get(ident, finalize.is_some()) {
+                    Scope::ExternPreludeItem => {
+                        match this.extern_prelude_get_item(ident, finalize.is_some()) {
                             Some(binding) => Ok((binding, Flags::empty())),
                             None => Err(Determinacy::determined(
                                 this.graph_root.unexpanded_invocations.borrow().is_empty(),
                             )),
                         }
                     }
+                    Scope::ExternPreludeCmd => {
+                        match this.extern_prelude_get_cmd(ident, finalize.is_some()) {
+                            Some(binding) => Ok((binding, Flags::empty())),
+                            None => Err(Determinacy::Determined),
+                        }
+                    }
                     Scope::ToolPrelude => match this.registered_tool_bindings.get(&ident) {
                         Some(binding) => Ok((*binding, Flags::empty())),
                         None => Err(Determinacy::Determined),
@@ -812,11 +821,16 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 assert_eq!(shadowing, Shadowing::Unrestricted);
                 return if ns != TypeNS {
                     Err((Determined, Weak::No))
-                } else if let Some(binding) = self.extern_prelude_get(ident, finalize.is_some()) {
+                } else if let Some(binding) =
+                    self.extern_prelude_get_item(ident, finalize.is_some())
+                {
                     Ok(binding)
                 } else if !self.graph_root.unexpanded_invocations.borrow().is_empty() {
                     // Macro-expanded `extern crate` items can add names to extern prelude.
                     Err((Undetermined, Weak::No))
+                } else if let Some(binding) = self.extern_prelude_get_cmd(ident, finalize.is_some())
+                {
+                    Ok(binding)
                 } else {
                     Err((Determined, Weak::No))
                 };

compiler/rustc_resolve/src/late/diagnostics.rs

@@ -2477,20 +2477,17 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
                     } else {
                         // Items from the prelude
                         if !module.no_implicit_prelude {
-                            let extern_prelude = self.r.extern_prelude.clone();
-                            names.extend(extern_prelude.iter().flat_map(|(ident, _)| {
+                            names.extend(
                                 self.r
-                                    .cstore_mut()
-                                    .maybe_process_path_extern(self.r.tcx, ident.name)
-                                    .and_then(|crate_id| {
-                                        let crate_mod =
-                                            Res::Def(DefKind::Mod, crate_id.as_def_id());
-
-                                        filter_fn(crate_mod).then(|| {
-                                            TypoSuggestion::typo_from_ident(*ident, crate_mod)
-                                        })
-                                    })
-                            }));
+                                    .extern_prelude_item
+                                    .keys()
+                                    .chain(self.r.extern_prelude_cmd.keys())
+                                    .flat_map(|ident| {
+                                        let res = Res::Def(DefKind::Mod, CRATE_DEF_ID.to_def_id());
+                                        filter_fn(res)
+                                            .then(|| TypoSuggestion::typo_from_ident(*ident, res))
+                                    }),
+                            );
 
                             if let Some(prelude) = self.r.prelude {
                                 self.r.add_module_candidates(prelude, &mut names, &filter_fn, None);