Use Symbol instead of Ident as an assoc_name to prevent ICEs

An ICE happens when certain code is compiled in incremental compilation
mode and there are two `Ident`s that have the same `StableHash` value
but are considered different by `Eq` and `Hash`.

Author: spastorino

compiler/rustc_infer/src/traits/util.rs

@@ -4,7 +4,7 @@ use crate::traits::{Obligation, ObligationCause, PredicateObligation};
 use rustc_data_structures::fx::{FxHashSet, FxIndexSet};
 use rustc_middle::ty::outlives::Component;
 use rustc_middle::ty::{self, ToPredicate, TyCtxt, WithConstness};
-use rustc_span::symbol::Ident;
+use rustc_span::symbol::Symbol;
 
 pub fn anonymize_predicate<'tcx>(
     tcx: TyCtxt<'tcx>,
@@ -296,7 +296,7 @@ pub fn transitive_bounds<'tcx>(
 pub fn transitive_bounds_that_define_assoc_type<'tcx>(
     tcx: TyCtxt<'tcx>,
     bounds: impl Iterator<Item = ty::PolyTraitRef<'tcx>>,
-    assoc_name: Ident,
+    assoc_name: Symbol,
 ) -> FxIndexSet<ty::PolyTraitRef<'tcx>> {
     let mut stack: Vec<_> = bounds.collect();
     let mut trait_refs = FxIndexSet::default();

compiler/rustc_middle/src/query/mod.rs

@@ -451,11 +451,11 @@ rustc_queries! {
             desc { |tcx| "computing the super predicates of `{}`", tcx.def_path_str(key) }
         }
 
-        /// The `Option<Ident>` is the name of an associated type. If it is `None`, then this query
-        /// returns the full set of predicates. If `Some<Ident>`, then the query returns only the
+        /// The `Option<Symbol>` is the name of an associated type. If it is `None`, then this query
+        /// returns the full set of predicates. If `Some<Symbol>`, then the query returns only the
         /// subset of super-predicates that reference traits that define the given associated type.
         /// This is used to avoid cycles in resolving types like `T::Item`.
-        query super_predicates_that_define_assoc_type(key: (DefId, Option<rustc_span::symbol::Ident>)) -> ty::GenericPredicates<'tcx> {
+        query super_predicates_that_define_assoc_type(key: (DefId, Option<rustc_span::symbol::Symbol>)) -> ty::GenericPredicates<'tcx> {
             desc { |tcx| "computing the super traits of `{}`{}",
                 tcx.def_path_str(key.0),
                 if let Some(assoc_name) = key.1 { format!(" with associated type name `{}`", assoc_name) } else { "".to_string() },
@@ -464,7 +464,7 @@ rustc_queries! {
 
         /// To avoid cycles within the predicates of a single item we compute
         /// per-type-parameter predicates for resolving `T::AssocTy`.
-        query type_param_predicates(key: (DefId, LocalDefId, rustc_span::symbol::Ident)) -> ty::GenericPredicates<'tcx> {
+        query type_param_predicates(key: (DefId, LocalDefId, rustc_span::symbol::Symbol)) -> ty::GenericPredicates<'tcx> {
             desc { |tcx| "computing the bounds for type parameter `{}`", {
                 let id = tcx.hir().local_def_id_to_hir_id(key.1);
                 tcx.hir().ty_param_name(id)

compiler/rustc_middle/src/ty/context.rs

@@ -51,7 +51,7 @@ use rustc_session::config::{BorrowckMode, CrateType, OutputFilenames};
 use rustc_session::lint::{Level, Lint};
 use rustc_session::Session;
 use rustc_span::source_map::MultiSpan;
-use rustc_span::symbol::{kw, sym, Ident, Symbol};
+use rustc_span::symbol::{kw, sym, Symbol};
 use rustc_span::{Span, DUMMY_SP};
 use rustc_target::abi::{Layout, TargetDataLayout, VariantIdx};
 use rustc_target::spec::abi;
@@ -2083,10 +2083,11 @@ impl<'tcx> TyCtxt<'tcx> {
 
     /// Given the def_id of a Trait `trait_def_id` and the name of an associated item `assoc_name`
     /// returns true if the `trait_def_id` defines an associated item of name `assoc_name`.
-    pub fn trait_may_define_assoc_type(self, trait_def_id: DefId, assoc_name: Ident) -> bool {
+    pub fn trait_may_define_assoc_type(self, trait_def_id: DefId, assoc_name: Symbol) -> bool {
         self.super_traits_of(trait_def_id).any(|trait_did| {
             self.associated_items(trait_did)
-                .find_by_name_and_kind(self, assoc_name, ty::AssocKind::Type, trait_did)
+                .find_by_name_and_kind_unhygienic(assoc_name, ty::AssocKind::Type)
+                .next()
                 .is_some()
         })
     }

compiler/rustc_middle/src/ty/mod.rs

@@ -318,6 +318,16 @@ impl<'tcx> AssociatedItems<'tcx> {
             .find(|item| tcx.hygienic_eq(ident, item.ident, parent_def_id))
     }
 
+    /// Returns the associated item with the given name and `AssocKind`, if one exists, ignoring
+    /// hygiene.
+    pub fn find_by_name_and_kind_unhygienic(
+        &self,
+        name: Symbol,
+        kind: AssocKind,
+    ) -> impl '_ + Iterator<Item = &ty::AssocItem> {
+        self.filter_by_name_unhygienic(name).filter(move |item| item.kind == kind)
+    }
+
     /// Returns the associated item with the given name in the given `Namespace`, if one exists.
     pub fn find_by_name_and_namespace(
         &self,

compiler/rustc_middle/src/ty/query/keys.rs

@@ -7,7 +7,7 @@ use crate::ty::subst::{GenericArg, SubstsRef};
 use crate::ty::{self, Ty, TyCtxt};
 use rustc_hir::def_id::{CrateNum, DefId, LocalDefId, LOCAL_CRATE};
 use rustc_query_system::query::DefaultCacheSelector;
-use rustc_span::symbol::{Ident, Symbol};
+use rustc_span::symbol::Symbol;
 use rustc_span::{Span, DUMMY_SP};
 
 /// The `Key` trait controls what types can legally be used as the key
@@ -149,7 +149,7 @@ impl Key for (LocalDefId, DefId) {
     }
 }
 
-impl Key for (DefId, Option<Ident>) {
+impl Key for (DefId, Option<Symbol>) {
     type CacheSelector = DefaultCacheSelector;
 
     fn query_crate(&self) -> CrateNum {
@@ -160,7 +160,7 @@ impl Key for (DefId, Option<Ident>) {
     }
 }
 
-impl Key for (DefId, LocalDefId, Ident) {
+impl Key for (DefId, LocalDefId, Symbol) {
     type CacheSelector = DefaultCacheSelector;
 
     fn query_crate(&self) -> CrateNum {

compiler/rustc_typeck/src/astconv/mod.rs

@@ -65,7 +65,7 @@ pub trait AstConv<'tcx> {
         &self,
         span: Span,
         def_id: DefId,
-        assoc_name: Ident,
+        assoc_name: Symbol,
     ) -> ty::GenericPredicates<'tcx>;
 
     /// Returns the lifetime to use when a lifetime is omitted (and not elided).
@@ -887,7 +887,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
         ast_bounds: &[hir::GenericBound<'_>],
         sized_by_default: SizedByDefault,
         span: Span,
-        assoc_name: Ident,
+        assoc_name: Symbol,
     ) -> Bounds<'tcx> {
         let mut result = Vec::new();
 
@@ -1398,7 +1398,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
         );
 
         let predicates = &self
-            .get_type_parameter_bounds(span, ty_param_def_id.to_def_id(), assoc_name)
+            .get_type_parameter_bounds(span, ty_param_def_id.to_def_id(), assoc_name.name)
             .predicates;
 
         debug!("find_bound_for_assoc_item: predicates={:#?}", predicates);
@@ -1412,7 +1412,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                     predicates.iter().filter_map(|(p, _)| {
                         p.to_opt_poly_trait_ref().map(|trait_ref| trait_ref.value)
                     }),
-                    assoc_name,
+                    assoc_name.name,
                 )
                 .into_iter()
             },

compiler/rustc_typeck/src/check/fn_ctxt/mod.rs

@@ -20,7 +20,7 @@ use rustc_middle::ty::fold::TypeFoldable;
 use rustc_middle::ty::subst::GenericArgKind;
 use rustc_middle::ty::{self, Const, Ty, TyCtxt};
 use rustc_session::Session;
-use rustc_span::symbol::Ident;
+use rustc_span::symbol::Symbol;
 use rustc_span::{self, Span};
 use rustc_trait_selection::traits::{ObligationCause, ObligationCauseCode};
 
@@ -188,7 +188,7 @@ impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> {
         &self,
         _: Span,
         def_id: DefId,
-        _: Ident,
+        _: Symbol,
     ) -> ty::GenericPredicates<'tcx> {
         let tcx = self.tcx;
         let hir_id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local());

compiler/rustc_typeck/src/collect.rs

@@ -316,7 +316,7 @@ impl AstConv<'tcx> for ItemCtxt<'tcx> {
         &self,
         span: Span,
         def_id: DefId,
-        assoc_name: Ident,
+        assoc_name: Symbol,
     ) -> ty::GenericPredicates<'tcx> {
         self.tcx.at(span).type_param_predicates((
             self.item_def_id,
@@ -503,7 +503,7 @@ fn get_new_lifetime_name<'tcx>(
 /// `X: Foo` where `X` is the type parameter `def_id`.
 fn type_param_predicates(
     tcx: TyCtxt<'_>,
-    (item_def_id, def_id, assoc_name): (DefId, LocalDefId, Ident),
+    (item_def_id, def_id, assoc_name): (DefId, LocalDefId, Symbol),
 ) -> ty::GenericPredicates<'_> {
     use rustc_hir::*;
 
@@ -600,7 +600,7 @@ impl ItemCtxt<'tcx> {
         param_id: hir::HirId,
         ty: Ty<'tcx>,
         only_self_bounds: OnlySelfBounds,
-        assoc_name: Option<Ident>,
+        assoc_name: Option<Symbol>,
     ) -> Vec<(ty::Predicate<'tcx>, Span)> {
         let constness = self.default_constness_for_trait_bounds();
         let from_ty_params = ast_generics
@@ -646,7 +646,7 @@ impl ItemCtxt<'tcx> {
         from_ty_params.chain(from_where_clauses).collect()
     }
 
-    fn bound_defines_assoc_item(&self, b: &hir::GenericBound<'_>, assoc_name: Ident) -> bool {
+    fn bound_defines_assoc_item(&self, b: &hir::GenericBound<'_>, assoc_name: Symbol) -> bool {
         debug!("bound_defines_assoc_item(b={:?}, assoc_name={:?})", b, assoc_name);
 
         match b {
@@ -1037,7 +1037,7 @@ fn super_predicates_of(tcx: TyCtxt<'_>, trait_def_id: DefId) -> ty::GenericPredi
 /// the transitive super-predicates are converted.
 fn super_predicates_that_define_assoc_type(
     tcx: TyCtxt<'_>,
-    (trait_def_id, assoc_name): (DefId, Option<Ident>),
+    (trait_def_id, assoc_name): (DefId, Option<Symbol>),
 ) -> ty::GenericPredicates<'_> {
     debug!(
         "super_predicates_that_define_assoc_type(trait_def_id={:?}, assoc_name={:?})",

src/test/ui/associated-type-bounds/traits-assoc-type-macros.rs

@@ -0,0 +1,43 @@
+// check-pass
+// compile-flags:-Cincremental=tmp/traits-assoc-type-macros
+
+// This test case makes sure that we can compile with incremental compilation
+// enabled when there are macros, traits, inheritance and associated types involved.
+
+trait Deserializer {
+    type Error;
+}
+
+trait Deserialize {
+    fn deserialize<D>(_: D) -> D::Error
+    where
+        D: Deserializer;
+}
+
+macro_rules! impl_deserialize {
+    ($name:ident) => {
+        impl Deserialize for $name {
+            fn deserialize<D>(_: D) -> D::Error
+            where
+                D: Deserializer,
+            {
+                loop {}
+            }
+        }
+    };
+}
+
+macro_rules! formats {
+    {
+        $($name:ident,)*
+    } => {
+        $(
+            pub struct $name;
+
+            impl_deserialize!($name);
+        )*
+    }
+}
+formats! { Foo, Bar, }
+
+fn main() {}