Revert "Rollup merge of #157702 - oli-obk:having-fun-with-expansion-info, r=davidtwco,estebank"

This reverts commit 18509d2, reversing
changes made to bf0dfb6.

Author: JonathanBrouwer

compiler/rustc_hir_analysis/src/check/check.rs

@@ -24,7 +24,7 @@ use rustc_middle::ty::{
     TypeVisitable, TypeVisitableExt, Unnormalized, fold_regions,
 };
 use rustc_session::lint::builtin::UNINHABITED_STATIC;
-use rustc_span::{DesugaringKind, sym};
+use rustc_span::sym;
 use rustc_target::spec::{AbiMap, AbiMapping};
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 use rustc_trait_selection::traits;
@@ -2117,9 +2117,7 @@ fn check_type_alias_type_params_are_used<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalD
             // * check for emptiness to detect lone user-written `?Sized` bounds
             // * compare the param span to the pred span to detect lone user-written `Sized` bounds
             let has_explicit_bounds = bounded_params.is_empty()
-                || (*bounded_params).get(&param.index).is_some_and(|&&pred_sp| {
-                    !pred_sp.is_desugaring(DesugaringKind::DefaultBound { def: param.def_id })
-                });
+                || (*bounded_params).get(&param.index).is_some_and(|&&pred_sp| pred_sp != span);
             let const_param_help = !has_explicit_bounds;
 
             let mut diag = tcx.dcx().create_err(diagnostics::UnusedGenericParameter {

compiler/rustc_hir_analysis/src/collect/item_bounds.rs

@@ -58,16 +58,14 @@ fn associated_type_bounds<'tcx>(
                     &mut bounds,
                     item_ty,
                     hir_bounds,
-                    &[],
-                    ImpliedBoundsContext::AssociatedType(assoc_item_def_id),
+                    ImpliedBoundsContext::AssociatedTypeOrImplTrait,
                     span,
                 );
                 icx.lowerer().add_default_traits(
                     &mut bounds,
                     item_ty,
                     hir_bounds,
-                    &[],
-                    ImpliedBoundsContext::AssociatedType(assoc_item_def_id),
+                    ImpliedBoundsContext::AssociatedTypeOrImplTrait,
                     span,
                 );
 
@@ -386,16 +384,14 @@ fn opaque_type_bounds<'tcx>(
                     &mut bounds,
                     item_ty,
                     hir_bounds,
-                    &[],
-                    ImpliedBoundsContext::ImplTrait,
+                    ImpliedBoundsContext::AssociatedTypeOrImplTrait,
                     span,
                 );
                 icx.lowerer().add_default_traits(
                     &mut bounds,
                     item_ty,
                     hir_bounds,
-                    &[],
-                    ImpliedBoundsContext::ImplTrait,
+                    ImpliedBoundsContext::AssociatedTypeOrImplTrait,
                     span,
                 );
             }

compiler/rustc_hir_analysis/src/collect/predicates_of.rs

@@ -200,15 +200,13 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
             &mut bounds,
             tcx.types.self_param,
             self_bounds,
-            &[],
             ImpliedBoundsContext::TraitDef(def_id),
             span,
         );
         icx.lowerer().add_default_traits(
             &mut bounds,
             tcx.types.self_param,
             self_bounds,
-            &[],
             ImpliedBoundsContext::TraitDef(def_id),
             span,
         );
@@ -241,16 +239,14 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
                     &mut bounds,
                     param_ty,
                     &[],
-                    hir_generics.predicates,
-                    ImpliedBoundsContext::TyParam(param.def_id),
+                    ImpliedBoundsContext::TyParam(param.def_id, hir_generics.predicates),
                     param.span,
                 );
                 icx.lowerer().add_default_traits(
                     &mut bounds,
                     param_ty,
                     &[],
-                    hir_generics.predicates,
-                    ImpliedBoundsContext::TyParam(param.def_id),
+                    ImpliedBoundsContext::TyParam(param.def_id, hir_generics.predicates),
                     param.span,
                 );
                 trace!(?bounds);
@@ -696,15 +692,13 @@ pub(super) fn implied_predicates_with_filter<'tcx>(
                 &mut bounds,
                 self_param_ty,
                 superbounds,
-                &[],
                 ImpliedBoundsContext::TraitDef(trait_def_id),
                 item.span,
             );
             icx.lowerer().add_default_traits(
                 &mut bounds,
                 self_param_ty,
                 superbounds,
-                &[],
                 ImpliedBoundsContext::TraitDef(trait_def_id),
                 item.span,
             );
@@ -1000,16 +994,14 @@ impl<'tcx> ItemCtxt<'tcx> {
                             &mut bounds,
                             param_ty,
                             &[],
-                            hir_generics.predicates,
-                            ImpliedBoundsContext::TyParam(param.def_id),
+                            ImpliedBoundsContext::TyParam(param.def_id, hir_generics.predicates),
                             param.span,
                         );
                         self.lowerer().add_default_traits(
                             &mut bounds,
                             param_ty,
                             &[],
-                            hir_generics.predicates,
-                            ImpliedBoundsContext::TyParam(param.def_id),
+                            ImpliedBoundsContext::TyParam(param.def_id, hir_generics.predicates),
                             param.span,
                         );
                     }

compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs

@@ -12,7 +12,7 @@ use rustc_middle::ty::{
     self as ty, IsSuggestable, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitableExt,
     TypeVisitor, Upcast,
 };
-use rustc_span::{DesugaringKind, ErrorGuaranteed, Ident, Span, kw};
+use rustc_span::{ErrorGuaranteed, Ident, Span, kw};
 use rustc_trait_selection::traits;
 use tracing::{debug, instrument};
 
@@ -25,17 +25,17 @@ use crate::hir_ty_lowering::{
 #[derive(Debug, Default)]
 struct CollectedBound {
     /// `Trait`
-    positive: Option<Span>,
+    positive: bool,
     /// `?Trait`
-    maybe: Option<Span>,
+    maybe: bool,
     /// `!Trait`
-    negative: Option<Span>,
+    negative: bool,
 }
 
 impl CollectedBound {
     /// Returns `true` if any of `Trait`, `?Trait` or `!Trait` were encountered.
     fn any(&self) -> bool {
-        self.positive.is_some() || self.maybe.is_some() || self.negative.is_some()
+        self.positive || self.maybe || self.negative
     }
 }
 
@@ -59,8 +59,7 @@ impl CollectedSizednessBounds {
 
 fn search_bounds_for<'tcx>(
     hir_bounds: &'tcx [hir::GenericBound<'tcx>],
-    where_bounds: &'tcx [hir::WherePredicate<'tcx>],
-    context: ImpliedBoundsContext,
+    context: ImpliedBoundsContext<'tcx>,
     mut f: impl FnMut(&'tcx PolyTraitRef<'tcx>),
 ) {
     let mut search_bounds = |hir_bounds: &'tcx [hir::GenericBound<'tcx>]| {
@@ -74,8 +73,8 @@ fn search_bounds_for<'tcx>(
     };
 
     search_bounds(hir_bounds);
-    if let ImpliedBoundsContext::TyParam(self_ty) = context {
-        for clause in where_bounds {
+    if let ImpliedBoundsContext::TyParam(self_ty, where_clause) = context {
+        for clause in where_clause {
             if let hir::WherePredicateKind::BoundPredicate(pred) = clause.kind
                 && pred.is_param_bound(self_ty.to_def_id())
             {
@@ -87,20 +86,19 @@ fn search_bounds_for<'tcx>(
 
 fn collect_bounds<'a, 'tcx>(
     hir_bounds: &'a [hir::GenericBound<'tcx>],
-    where_bounds: &'tcx [hir::WherePredicate<'tcx>],
-    context: ImpliedBoundsContext,
+    context: ImpliedBoundsContext<'tcx>,
     target_did: DefId,
 ) -> CollectedBound {
     let mut collect_into = CollectedBound::default();
-    search_bounds_for(hir_bounds, where_bounds, context, |ptr| {
+    search_bounds_for(hir_bounds, context, |ptr| {
         if !matches!(ptr.trait_ref.path.res, Res::Def(DefKind::Trait, did) if did == target_did) {
             return;
         }
 
         match ptr.modifiers.polarity {
-            hir::BoundPolarity::Maybe(_) => collect_into.maybe = Some(ptr.span),
-            hir::BoundPolarity::Negative(_) => collect_into.negative = Some(ptr.span),
-            hir::BoundPolarity::Positive => collect_into.positive = Some(ptr.span),
+            hir::BoundPolarity::Maybe(_) => collect_into.maybe = true,
+            hir::BoundPolarity::Negative(_) => collect_into.negative = true,
+            hir::BoundPolarity::Positive => collect_into.positive = true,
         }
     });
     collect_into
@@ -109,18 +107,17 @@ fn collect_bounds<'a, 'tcx>(
 fn collect_sizedness_bounds<'tcx>(
     tcx: TyCtxt<'tcx>,
     hir_bounds: &'tcx [hir::GenericBound<'tcx>],
-    where_bounds: &'tcx [hir::WherePredicate<'tcx>],
-    context: ImpliedBoundsContext,
+    context: ImpliedBoundsContext<'tcx>,
     span: Span,
 ) -> CollectedSizednessBounds {
     let sized_did = tcx.require_lang_item(hir::LangItem::Sized, span);
-    let sized = collect_bounds(hir_bounds, where_bounds, context, sized_did);
+    let sized = collect_bounds(hir_bounds, context, sized_did);
 
     let meta_sized_did = tcx.require_lang_item(hir::LangItem::MetaSized, span);
-    let meta_sized = collect_bounds(hir_bounds, where_bounds, context, meta_sized_did);
+    let meta_sized = collect_bounds(hir_bounds, context, meta_sized_did);
 
     let pointee_sized_did = tcx.require_lang_item(hir::LangItem::PointeeSized, span);
-    let pointee_sized = collect_bounds(hir_bounds, where_bounds, context, pointee_sized_did);
+    let pointee_sized = collect_bounds(hir_bounds, context, pointee_sized_did);
 
     CollectedSizednessBounds { sized, meta_sized, pointee_sized }
 }
@@ -153,8 +150,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         bounds: &mut Vec<(ty::Clause<'tcx>, Span)>,
         self_ty: Ty<'tcx>,
         hir_bounds: &'tcx [hir::GenericBound<'tcx>],
-        where_bounds: &'tcx [hir::WherePredicate<'tcx>],
-        context: ImpliedBoundsContext,
+        context: ImpliedBoundsContext<'tcx>,
         span: Span,
     ) {
         let tcx = self.tcx();
@@ -181,48 +177,28 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                     return;
                 }
             }
-            ImpliedBoundsContext::TyParam(..)
-            | ImpliedBoundsContext::AssociatedType(..)
-            | ImpliedBoundsContext::TraitObject
-            | ImpliedBoundsContext::TraitAscription
-            | ImpliedBoundsContext::ImplTrait => {}
+            ImpliedBoundsContext::TyParam(..) | ImpliedBoundsContext::AssociatedTypeOrImplTrait => {
+            }
         }
-        let collected = collect_sizedness_bounds(tcx, hir_bounds, where_bounds, context, span);
-        if let Some(span) = collected.sized.maybe.or(collected.sized.negative)
-            && collected.sized.positive.is_none()
+
+        let collected = collect_sizedness_bounds(tcx, hir_bounds, context, span);
+        if (collected.sized.maybe || collected.sized.negative)
+            && !collected.sized.positive
             && !collected.meta_sized.any()
             && !collected.pointee_sized.any()
         {
             // `?Sized` is equivalent to `MetaSized` (but only add the bound if there aren't any
             // other explicit ones) - this can happen for trait aliases as well as bounds.
             add_trait_bound(tcx, bounds, self_ty, meta_sized_did, span);
         } else if !collected.any() {
-            let span = match context {
-                ImpliedBoundsContext::TraitDef(def)
-                | ImpliedBoundsContext::TyParam(def)
-                | ImpliedBoundsContext::AssociatedType(def) => {
-                    self.tcx().with_stable_hashing_context(|hcx| {
-                        span.mark_with_reason(
-                            None,
-                            DesugaringKind::DefaultBound { def: def.into() },
-                            span.edition(),
-                            hcx,
-                        )
-                    })
-                }
-                _ => span,
-            };
             match context {
                 ImpliedBoundsContext::TraitDef(..) => {
                     // If there are no explicit sizedness bounds on a trait then add a default
                     // `MetaSized` supertrait.
                     add_trait_bound(tcx, bounds, self_ty, meta_sized_did, span);
                 }
                 ImpliedBoundsContext::TyParam(..)
-                | ImpliedBoundsContext::AssociatedType(..)
-                | ImpliedBoundsContext::TraitObject
-                | ImpliedBoundsContext::TraitAscription
-                | ImpliedBoundsContext::ImplTrait => {
+                | ImpliedBoundsContext::AssociatedTypeOrImplTrait => {
                     // If there are no explicit sizedness bounds on a parameter then add a default
                     // `Sized` bound.
                     let sized_did = tcx.require_lang_item(hir::LangItem::Sized, span);
@@ -237,20 +213,11 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         bounds: &mut Vec<(ty::Clause<'tcx>, Span)>,
         self_ty: Ty<'tcx>,
         hir_bounds: &[hir::GenericBound<'tcx>],
-        where_bounds: &'tcx [hir::WherePredicate<'tcx>],
-        context: ImpliedBoundsContext,
+        context: ImpliedBoundsContext<'tcx>,
         span: Span,
     ) {
         self.tcx().default_traits().iter().for_each(|default_trait| {
-            self.add_default_trait(
-                *default_trait,
-                bounds,
-                self_ty,
-                hir_bounds,
-                where_bounds,
-                context,
-                span,
-            );
+            self.add_default_trait(*default_trait, bounds, self_ty, hir_bounds, context, span);
         });
     }
 
@@ -263,8 +230,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         bounds: &mut Vec<(ty::Clause<'tcx>, Span)>,
         self_ty: Ty<'tcx>,
         hir_bounds: &[hir::GenericBound<'tcx>],
-        where_bounds: &'tcx [hir::WherePredicate<'tcx>],
-        context: ImpliedBoundsContext,
+        context: ImpliedBoundsContext<'tcx>,
         span: Span,
     ) {
         let tcx = self.tcx();
@@ -278,7 +244,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         }
 
         if let Some(trait_did) = tcx.lang_items().get(trait_)
-            && self.should_add_default_traits(trait_did, hir_bounds, where_bounds, context)
+            && self.should_add_default_traits(trait_did, hir_bounds, context)
         {
             add_trait_bound(tcx, bounds, self_ty, trait_did, span);
         }
@@ -289,10 +255,9 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         &self,
         trait_def_id: DefId,
         hir_bounds: &'a [hir::GenericBound<'tcx>],
-        where_bounds: &'tcx [hir::WherePredicate<'tcx>],
-        context: ImpliedBoundsContext,
+        context: ImpliedBoundsContext<'tcx>,
     ) -> bool {
-        let collected = collect_bounds(hir_bounds, where_bounds, context, trait_def_id);
+        let collected = collect_bounds(hir_bounds, context, trait_def_id);
         !find_attr!(self.tcx(), crate, RustcNoImplicitBounds) && !collected.any()
     }
 

compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_trait.rs

@@ -83,8 +83,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 .iter()
                 .map(|&trait_ref| hir::GenericBound::Trait(trait_ref))
                 .collect::<Vec<_>>(),
-            &[],
-            ImpliedBoundsContext::TraitObject,
+            ImpliedBoundsContext::AssociatedTypeOrImplTrait,
             span,
         );
 

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -59,17 +59,14 @@ use crate::{NoVariantNamed, check_c_variadic_abi};
 /// The context in which an implied bound is being added to a item being lowered (i.e. a sizedness
 /// trait or a default trait)
 #[derive(Clone, Copy)]
-pub(crate) enum ImpliedBoundsContext {
+pub(crate) enum ImpliedBoundsContext<'tcx> {
     /// An implied bound is added to a trait definition (i.e. a new supertrait), used when adding
     /// a default `MetaSized` supertrait
     TraitDef(LocalDefId),
     /// An implied bound is added to a type parameter
-    TyParam(LocalDefId),
-    /// Associated type bounds
-    AssociatedType(LocalDefId),
-    ImplTrait,
-    TraitObject,
-    TraitAscription,
+    TyParam(LocalDefId, &'tcx [hir::WherePredicate<'tcx>]),
+    /// An implied bound being added in any other context
+    AssociatedTypeOrImplTrait,
 }
 
 /// A path segment that is semantically allowed to have generic arguments.
@@ -3133,8 +3130,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                     &mut bounds,
                     self_ty,
                     hir_bounds,
-                    &[],
-                    ImpliedBoundsContext::TraitAscription,
+                    ImpliedBoundsContext::AssociatedTypeOrImplTrait,
                     hir_ty.span,
                 );
                 self.register_trait_ascription_bounds(bounds, hir_ty.hir_id, hir_ty.span);