resolve: re-export ambiguity in extern crate as warning

Author: bvanjoi

compiler/rustc_errors/src/lib.rs

@@ -1898,6 +1898,9 @@ pub fn report_ambiguity_error<'a, G: EmissionGuarantee>(
     for help_msg in ambiguity.b1_help_msgs {
         db.help(help_msg);
     }
+    if ambiguity.extern_crate {
+        return;
+    }
     db.span_note(ambiguity.b2_span, ambiguity.b2_note_msg);
     for help_msg in ambiguity.b2_help_msgs {
         db.help(help_msg);

compiler/rustc_lint_defs/src/lib.rs

@@ -476,6 +476,8 @@ impl<HCX> ToStableHashKey<HCX> for LintId {
 
 #[derive(Debug)]
 pub struct AmbiguityErrorDiag {
+    /// Does this ambiguity binding come from a different crate?
+    pub extern_crate: bool,
     pub msg: String,
     pub span: Span,
     pub label_span: Span,

compiler/rustc_metadata/src/rmeta/decoder.rs

@@ -1265,6 +1265,39 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
         })
     }
 
+    fn get_ambiguity_mod_child(self, id: DefIndex, sess: &Session) -> AmbiguityModChild {
+        let ident = self.item_ident(id, sess);
+        let res = Res::Def(self.def_kind(id), self.local_def_id(id));
+        let vis = self.get_visibility(id);
+
+        AmbiguityModChild { ident, res, vis, reexport_chain: Default::default() }
+    }
+
+    fn get_ambiguity_module_children(
+        self,
+        id: DefIndex,
+        sess: &'a Session,
+    ) -> impl Iterator<Item = AmbiguityModChild> + 'a {
+        iter::from_coroutine(move || {
+            if self.root.proc_macro_data.is_none() {
+                if let Some(non_reexports) =
+                    self.root.tables.ambiguity_module_children_non_reexports.get(self, id)
+                {
+                    for child_index in non_reexports.decode(self) {
+                        yield self.get_ambiguity_mod_child(child_index, sess);
+                    }
+                }
+
+                let reexports = self.root.tables.ambiguity_module_children_reexports.get(self, id);
+                if !reexports.is_default() {
+                    for reexport in reexports.decode((self, sess)) {
+                        yield reexport;
+                    }
+                }
+            }
+        })
+    }
+
     fn is_ctfe_mir_available(self, id: DefIndex) -> bool {
         self.root.tables.mir_for_ctfe.get(self, id).is_some()
     }

compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs

@@ -346,6 +346,9 @@ provide! { tcx, def_id, other, cdata,
     module_children => {
         tcx.arena.alloc_from_iter(cdata.get_module_children(def_id.index, tcx.sess))
     }
+    ambiguity_module_children => {
+        tcx.arena.alloc_from_iter(cdata.get_ambiguity_module_children(def_id.index, tcx.sess))
+    }
     defined_lib_features => { cdata.get_lib_features(tcx) }
     stability_implications => {
         cdata.get_stability_implications(tcx).iter().copied().collect()

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -1565,6 +1565,15 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
 
             record_defaulted_array!(self.tables.module_children_reexports[def_id] <-
                 module_children.iter().filter(|child| !child.reexport_chain.is_empty()));
+
+            let ambiguity_module_children = tcx.ambiguity_module_children_local(local_def_id);
+
+            record_array!(self.tables.ambiguity_module_children_non_reexports[def_id] <-
+                ambiguity_module_children.iter().filter(|child| child.reexport_chain.is_empty())
+                    .map(|child| child.res.def_id().index));
+
+            record_defaulted_array!(self.tables.ambiguity_module_children_reexports[def_id] <-
+                ambiguity_module_children.iter().filter(|child| !child.reexport_chain.is_empty()));
         }
     }
 

compiler/rustc_metadata/src/rmeta/mod.rs

@@ -16,7 +16,7 @@ use rustc_hir::definitions::DefKey;
 use rustc_hir::lang_items::LangItem;
 use rustc_index::bit_set::BitSet;
 use rustc_index::IndexVec;
-use rustc_middle::metadata::ModChild;
+use rustc_middle::metadata::{AmbiguityModChild, ModChild};
 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrs;
 use rustc_middle::middle::exported_symbols::{ExportedSymbol, SymbolExportInfo};
 use rustc_middle::middle::resolve_bound_vars::ObjectLifetimeDefault;
@@ -397,12 +397,14 @@ define_tables! {
     // That's why the encoded list needs to contain `ModChild` structures describing all the names
     // individually instead of `DefId`s.
     module_children_reexports: Table<DefIndex, LazyArray<ModChild>>,
+    ambiguity_module_children_reexports: Table<DefIndex, LazyArray<AmbiguityModChild>>,
 
 - optional:
     attributes: Table<DefIndex, LazyArray<ast::Attribute>>,
     // For non-reexported names in a module every name is associated with a separate `DefId`,
     // so we can take their names, visibilities etc from other encoded tables.
     module_children_non_reexports: Table<DefIndex, LazyArray<DefIndex>>,
+    ambiguity_module_children_non_reexports: Table<DefIndex, LazyArray<DefIndex>>,
     associated_item_or_field_def_ids: Table<DefIndex, LazyArray<DefIndex>>,
     opt_def_kind: Table<DefIndex, DefKind>,
     visibility: Table<DefIndex, LazyValue<ty::Visibility<DefIndex>>>,

compiler/rustc_middle/src/arena.rs

@@ -131,6 +131,7 @@ macro_rules! arena_types {
             [] closure_kind_origin: (rustc_span::Span, rustc_middle::hir::place::Place<'tcx>),
             [] stripped_cfg_items: rustc_ast::expand::StrippedCfgItem,
             [] mod_child: rustc_middle::metadata::ModChild,
+            [] ambiguity_mod_child: rustc_middle::metadata::AmbiguityModChild,
             [] features: rustc_feature::Features,
         ]);
     )

compiler/rustc_middle/src/metadata.rs

@@ -44,3 +44,12 @@ pub struct ModChild {
     /// Empty if the module child is a proper item.
     pub reexport_chain: SmallVec<[Reexport; 2]>,
 }
+
+/// This is similar to `ModChild`, however, it includes ambiguity error.
+#[derive(Debug, TyEncodable, TyDecodable, HashStable)]
+pub struct AmbiguityModChild {
+    pub ident: Ident,
+    pub res: Res<!>,
+    pub vis: ty::Visibility<DefId>,
+    pub reexport_chain: SmallVec<[Reexport; 2]>,
+}

compiler/rustc_middle/src/query/mod.rs

@@ -9,7 +9,7 @@
 use crate::dep_graph;
 use crate::infer::canonical::{self, Canonical};
 use crate::lint::LintExpectation;
-use crate::metadata::ModChild;
+use crate::metadata::{AmbiguityModChild, ModChild};
 use crate::middle::codegen_fn_attrs::CodegenFnAttrs;
 use crate::middle::debugger_visualizer::DebuggerVisualizerFile;
 use crate::middle::exported_symbols::{ExportedSymbol, SymbolExportInfo};
@@ -1728,6 +1728,10 @@ rustc_queries! {
         desc { |tcx| "collecting child items of module `{}`", tcx.def_path_str(def_id) }
         separate_provide_extern
     }
+    query ambiguity_module_children(def_id: DefId) -> &'tcx [AmbiguityModChild] {
+        desc { |tcx| "collecting ambiguity child items of module `{}`", tcx.def_path_str(def_id) }
+        separate_provide_extern
+    }
     query extern_mod_stmt_cnum(def_id: LocalDefId) -> Option<CrateNum> {
         desc { |tcx| "computing crate imported by `{}`", tcx.def_path_str(def_id) }
     }

compiler/rustc_middle/src/ty/context.rs

@@ -8,7 +8,7 @@ use crate::arena::Arena;
 use crate::dep_graph::{DepGraph, DepKindStruct};
 use crate::infer::canonical::{CanonicalVarInfo, CanonicalVarInfos};
 use crate::lint::struct_lint_level;
-use crate::metadata::ModChild;
+use crate::metadata::{AmbiguityModChild, ModChild};
 use crate::middle::codegen_fn_attrs::CodegenFnAttrs;
 use crate::middle::resolve_bound_vars;
 use crate::middle::stability;
@@ -2172,6 +2172,10 @@ impl<'tcx> TyCtxt<'tcx> {
     pub fn module_children_local(self, def_id: LocalDefId) -> &'tcx [ModChild] {
         self.resolutions(()).module_children.get(&def_id).map_or(&[], |v| &v[..])
     }
+
+    pub fn ambiguity_module_children_local(self, def_id: LocalDefId) -> &'tcx [AmbiguityModChild] {
+        self.resolutions(()).ambiguity_module_children.get(&def_id).map_or(&[], |v| &v[..])
+    }
 }
 
 /// Parameter attributes that can only be determined by examining the body of a function instead