Store Ident in DefPathData instead of Symbol

This allows us to recover span information when emitting cross crate
errors. A number of test cases benefit from this change, since we were
previously not emitting messages due to invalid spans.

There are four main parts to this commit:

1. Adding `Ident` to `DefPathData`, and updating the affected code. This
mostly consists of mechanical changes.

2. Updating how we determine the disambiguator for a `DefPath`. Since
`DefPathData` now stores a `Span` (inside the `Ident`), we need to
make sure we ignore this span we determining if a path needs to be
disambiguated. This ensure that two paths with the same symbols but
different spans are considered equal (this can occur when a macro is
repeatedly expanded to a definition).

3. Ensuring that we are able to decode `Spans` when decoding the
`DefPathTable`. Since the `DefPathTable` is stored in `CrateMetadata`, we
must decode it before we have a `CrateMetadata` available. Since
decoding a `Span` requires access to several fields from
`CrateMetadata`, this commit adds a new struct `InitialCrateMetadata`,
which implements `Metadata` and stores all of the necessary fields.

4. The specialized metadata encoder/decoder impls for `Ident` are
removed. This causes us to fall back to the default encoder/decoder
implementations for `Ident`, which simply serializes and deserializes
the fields of `Ident`. This is strictly an improvement - we still don't
have any hygiene information, but we now have a non-dummy Span.

This should hopefully allow us to test PR rust-lang#68941, since we will now use
cross-crate spans in more places.

Author: Aaron1011

src/librustc/hir/map/definitions.rs

@@ -13,7 +13,7 @@ use rustc_hir::def_id::{CrateNum, DefId, DefIndex, CRATE_DEF_INDEX, LOCAL_CRATE}
 use rustc_index::vec::IndexVec;
 use rustc_session::CrateDisambiguator;
 use rustc_span::hygiene::ExpnId;
-use rustc_span::symbol::{sym, Symbol};
+use rustc_span::symbol::{sym, Ident, Symbol};
 use rustc_span::Span;
 
 use std::fmt::Write;
@@ -90,6 +90,11 @@ pub struct Definitions {
     parent_modules_of_macro_defs: FxHashMap<ExpnId, DefId>,
     /// Item with a given `DefIndex` was defined during macro expansion with ID `ExpnId`.
     expansions_that_defined: FxHashMap<DefIndex, ExpnId>,
+    // Keeps track of the current disambiguator for a given (DefIndex, DefPathData)
+    // Note that we replace any `Spans` (e.g. in `Ident`) with `DUMMY_SP` before
+    // inserting a `DefPathData`. This ensures that we create a new disambiguator
+    // for definitions that have the same name, but different spans (e.g. definitions
+    // created by a macro invocation).
     next_disambiguator: FxHashMap<(DefIndex, DefPathData), u32>,
     def_index_to_span: FxHashMap<DefIndex, Span>,
     /// When collecting definitions from an AST fragment produced by a macro invocation `ExpnId`
@@ -206,7 +211,7 @@ impl DefPath {
         let mut s = String::with_capacity(self.data.len() * 16);
 
         for component in &self.data {
-            write!(s, "::{}[{}]", component.data.as_symbol(), component.disambiguator).unwrap();
+            write!(s, "::{}[{}]", component.data.as_ident(), component.disambiguator).unwrap();
         }
 
         s
@@ -225,9 +230,9 @@ impl DefPath {
 
         for component in &self.data {
             if component.disambiguator == 0 {
-                write!(s, "::{}", component.data.as_symbol()).unwrap();
+                write!(s, "::{}", component.data.as_ident()).unwrap();
             } else {
-                write!(s, "{}[{}]", component.data.as_symbol(), component.disambiguator).unwrap();
+                write!(s, "{}[{}]", component.data.as_ident(), component.disambiguator).unwrap();
             }
         }
 
@@ -245,9 +250,9 @@ impl DefPath {
             opt_delimiter.map(|d| s.push(d));
             opt_delimiter = Some('-');
             if component.disambiguator == 0 {
-                write!(s, "{}", component.data.as_symbol()).unwrap();
+                write!(s, "{}", component.data.as_ident()).unwrap();
             } else {
-                write!(s, "{}[{}]", component.data.as_symbol(), component.disambiguator).unwrap();
+                write!(s, "{}[{}]", component.data.as_ident(), component.disambiguator).unwrap();
             }
         }
         s
@@ -267,13 +272,13 @@ pub enum DefPathData {
     /// An impl.
     Impl,
     /// Something in the type namespace.
-    TypeNs(Symbol),
+    TypeNs(Ident),
     /// Something in the value namespace.
-    ValueNs(Symbol),
+    ValueNs(Ident),
     /// Something in the macro namespace.
-    MacroNs(Symbol),
+    MacroNs(Ident),
     /// Something in the lifetime namespace.
-    LifetimeNs(Symbol),
+    LifetimeNs(Ident),
     /// A closure expression.
     ClosureExpr,
 
@@ -432,7 +437,10 @@ impl Definitions {
 
         // Find the next free disambiguator for this key.
         let disambiguator = {
-            let next_disamb = self.next_disambiguator.entry((parent, data)).or_insert(0);
+            // Replace any span with `DUMMY_SP` - two definitions which differ
+            // only in their spans still need to be disambiguated.
+            let data_dummy_span = data.with_dummy_span();
+            let next_disamb = self.next_disambiguator.entry((parent, data_dummy_span)).or_insert(0);
             let disambiguator = *next_disamb;
             *next_disamb = next_disamb.checked_add(1).expect("disambiguator overflow");
             disambiguator
@@ -522,7 +530,20 @@ impl Definitions {
 }
 
 impl DefPathData {
-    pub fn get_opt_name(&self) -> Option<Symbol> {
+    /// Replaces any `Spans` contains in this `DefPathData` with `DUMMY_SP`.
+    /// Useful when using a `DefPathData` as a cache key.
+    pub fn with_dummy_span(&self) -> DefPathData {
+        use self::DefPathData::*;
+        match *self {
+            TypeNs(name) => TypeNs(Ident::with_dummy_span(name.name)),
+            ValueNs(name) => ValueNs(Ident::with_dummy_span(name.name)),
+            MacroNs(name) => MacroNs(Ident::with_dummy_span(name.name)),
+            LifetimeNs(name) => LifetimeNs(Ident::with_dummy_span(name.name)),
+            _ => *self,
+        }
+    }
+
+    pub fn get_opt_name(&self) -> Option<Ident> {
         use self::DefPathData::*;
         match *self {
             TypeNs(name) | ValueNs(name) | MacroNs(name) | LifetimeNs(name) => Some(name),
@@ -531,22 +552,22 @@ impl DefPathData {
         }
     }
 
-    pub fn as_symbol(&self) -> Symbol {
+    pub fn as_ident(&self) -> Ident {
         use self::DefPathData::*;
         match *self {
             TypeNs(name) | ValueNs(name) | MacroNs(name) | LifetimeNs(name) => name,
             // Note that this does not show up in user print-outs.
-            CrateRoot => sym::double_braced_crate,
-            Impl => sym::double_braced_impl,
-            Misc => sym::double_braced_misc,
-            ClosureExpr => sym::double_braced_closure,
-            Ctor => sym::double_braced_constructor,
-            AnonConst => sym::double_braced_constant,
-            ImplTrait => sym::double_braced_opaque,
+            CrateRoot => Ident::with_dummy_span(sym::double_braced_crate),
+            Impl => Ident::with_dummy_span(sym::double_braced_impl),
+            Misc => Ident::with_dummy_span(sym::double_braced_misc),
+            ClosureExpr => Ident::with_dummy_span(sym::double_braced_closure),
+            Ctor => Ident::with_dummy_span(sym::double_braced_constructor),
+            AnonConst => Ident::with_dummy_span(sym::double_braced_constant),
+            ImplTrait => Ident::with_dummy_span(sym::double_braced_opaque),
         }
     }
 
     pub fn to_string(&self) -> String {
-        self.as_symbol().to_string()
+        self.as_ident().to_string()
     }
 }

src/librustc/ty/mod.rs

@@ -2996,9 +2996,16 @@ impl<'tcx> TyCtxt<'tcx> {
                 hir_map::DefPathData::Ctor => {
                     self.item_name(DefId { krate: id.krate, index: def_key.parent.unwrap() })
                 }
-                _ => def_key.disambiguated_data.data.get_opt_name().unwrap_or_else(|| {
-                    bug!("item_name: no name for {:?}", self.def_path(id));
-                }),
+                _ => {
+                    def_key
+                        .disambiguated_data
+                        .data
+                        .get_opt_name()
+                        .unwrap_or_else(|| {
+                            bug!("item_name: no name for {:?}", self.def_path(id));
+                        })
+                        .name
+                }
             }
         }
     }

src/librustc/ty/print/obsolete.rs

@@ -186,9 +186,9 @@ impl DefPathBasedNames<'tcx> {
         // foo::bar::ItemName::
         for part in self.tcx.def_path(def_id).data {
             if self.omit_disambiguators {
-                write!(output, "{}::", part.data.as_symbol()).unwrap();
+                write!(output, "{}::", part.data.as_ident()).unwrap();
             } else {
-                write!(output, "{}[{}]::", part.data.as_symbol(), part.disambiguator).unwrap();
+                write!(output, "{}[{}]::", part.data.as_ident(), part.disambiguator).unwrap();
             }
         }
 

src/librustc/ty/print/pretty.rs

@@ -13,7 +13,7 @@ use rustc_apfloat::ieee::{Double, Single};
 use rustc_apfloat::Float;
 use rustc_ast::ast;
 use rustc_attr::{SignedInt, UnsignedInt};
-use rustc_span::symbol::{kw, Symbol};
+use rustc_span::symbol::{kw, Ident, Symbol};
 use rustc_target::spec::abi::Abi;
 
 use std::cell::Cell;
@@ -402,12 +402,14 @@ pub trait PrettyPrinter<'tcx>:
                     .find(|child| child.res.def_id() == def_id)
                     .map(|child| child.ident.name);
                 if let Some(reexport) = reexport {
-                    *name = reexport;
+                    *name = Ident::with_dummy_span(reexport);
                 }
             }
             // Re-exported `extern crate` (#43189).
             DefPathData::CrateRoot => {
-                data = DefPathData::TypeNs(self.tcx().original_crate_name(def_id.krate));
+                data = DefPathData::TypeNs(Ident::with_dummy_span(
+                    self.tcx().original_crate_name(def_id.krate),
+                ));
             }
             _ => {}
         }
@@ -1401,7 +1403,7 @@ impl<F: fmt::Write> Printer<'tcx> for FmtPrinter<'_, 'tcx, F> {
 
         // FIXME(eddyb) `name` should never be empty, but it
         // currently is for `extern { ... }` "foreign modules".
-        let name = disambiguated_data.data.as_symbol().as_str();
+        let name = disambiguated_data.data.to_string();
         if !name.is_empty() {
             if !self.empty_path {
                 write!(self, "::")?;

src/librustc/ty/query/profiling_support.rs

@@ -60,12 +60,12 @@ impl<'p, 'c, 'tcx> QueryKeyStringBuilder<'p, 'c, 'tcx> {
 
         match def_key.disambiguated_data.data {
             DefPathData::CrateRoot => {
-                name = self.tcx.original_crate_name(def_id.krate).as_str();
+                name = self.tcx.original_crate_name(def_id.krate).as_str().to_string();
                 dis = "";
                 end_index = 3;
             }
             other => {
-                name = other.as_symbol().as_str();
+                name = other.to_string();
                 if def_key.disambiguated_data.disambiguator == 0 {
                     dis = "";
                     end_index = 3;

src/librustc_ast_lowering/lib.rs

@@ -764,17 +764,21 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         // Get the name we'll use to make the def-path. Note
         // that collisions are ok here and this shouldn't
         // really show up for end-user.
-        let (str_name, kind) = match hir_name {
-            ParamName::Plain(ident) => (ident.name, hir::LifetimeParamKind::InBand),
-            ParamName::Fresh(_) => (kw::UnderscoreLifetime, hir::LifetimeParamKind::Elided),
-            ParamName::Error => (kw::UnderscoreLifetime, hir::LifetimeParamKind::Error),
+        let (name, kind) = match hir_name {
+            ParamName::Plain(ident) => (ident, hir::LifetimeParamKind::InBand),
+            ParamName::Fresh(_) => {
+                (Ident::with_dummy_span(kw::UnderscoreLifetime), hir::LifetimeParamKind::Elided)
+            }
+            ParamName::Error => {
+                (Ident::with_dummy_span(kw::UnderscoreLifetime), hir::LifetimeParamKind::Error)
+            }
         };
 
         // Add a definition for the in-band lifetime def.
         self.resolver.definitions().create_def_with_parent(
             parent_index,
             node_id,
-            DefPathData::LifetimeNs(str_name),
+            DefPathData::LifetimeNs(name),
             ExpnId::root(),
             span,
         );
@@ -1560,7 +1564,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     self.context.resolver.definitions().create_def_with_parent(
                         self.parent,
                         def_node_id,
-                        DefPathData::LifetimeNs(name.ident().name),
+                        DefPathData::LifetimeNs(name.ident()),
                         ExpnId::root(),
                         lifetime.span,
                     );

src/librustc_codegen_llvm/debuginfo/namespace.rs

@@ -29,7 +29,7 @@ pub fn item_namespace(cx: &CodegenCx<'ll, '_>, def_id: DefId) -> &'ll DIScope {
 
     let namespace_name = match def_key.disambiguated_data.data {
         DefPathData::CrateRoot => cx.tcx.crate_name(def_id.krate),
-        data => data.as_symbol(),
+        data => data.as_ident().name,
     };
     let namespace_name = namespace_name.as_str();
 

src/librustc_codegen_ssa/debuginfo/type_names.rs

@@ -217,7 +217,7 @@ pub fn push_debuginfo_type_name<'tcx>(
             output.push_str(&tcx.crate_name(def_id.krate).as_str());
             for path_element in tcx.def_path(def_id).data {
                 output.push_str("::");
-                output.push_str(&path_element.data.as_symbol().as_str());
+                output.push_str(&path_element.data.to_string());
             }
         } else {
             output.push_str(&tcx.item_name(def_id).as_str());

src/librustc_codegen_utils/symbol_names/legacy.rs

@@ -315,7 +315,7 @@ impl Printer<'tcx> for SymbolPrinter<'tcx> {
             self.path.finalize_pending_component();
         }
 
-        self.write_str(&disambiguated_data.data.as_symbol().as_str())?;
+        self.write_str(&disambiguated_data.data.to_string())?;
         Ok(self)
     }
     fn path_generic_args(

src/librustc_infer/infer/error_reporting/mod.rs

@@ -631,7 +631,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
                 disambiguated_data: &DisambiguatedDefPathData,
             ) -> Result<Self::Path, Self::Error> {
                 let mut path = print_prefix(self)?;
-                path.push(disambiguated_data.data.as_symbol().to_string());
+                path.push(disambiguated_data.data.to_string());
                 Ok(path)
             }
             fn path_generic_args(