Remove old code for detecting duplicate assoc ty in dyn.

Fixes <#150936>

The last place where `OverlappingAsssocItemConstraints::Forbidden`
was constructed was removed in a previous commit. As a result,
this code path is now unreachable.

Author: theemathas

compiler/rustc_hir_analysis/src/collect/item_bounds.rs

@@ -12,9 +12,7 @@ use tracing::{debug, instrument};
 
 use super::ItemCtxt;
 use super::predicates_of::assert_only_contains_predicates_from;
-use crate::hir_ty_lowering::{
-    HirTyLowerer, ImpliedBoundsContext, OverlappingAsssocItemConstraints, PredicateFilter,
-};
+use crate::hir_ty_lowering::{HirTyLowerer, ImpliedBoundsContext, PredicateFilter};
 
 /// For associated types we include both bounds written on the type
 /// (`type X: Trait`) and predicates from the trait: `where Self::X: Trait`.
@@ -39,14 +37,7 @@ fn associated_type_bounds<'tcx>(
 
         let icx = ItemCtxt::new(tcx, assoc_item_def_id);
         let mut bounds = Vec::new();
-        icx.lowerer().lower_bounds(
-            item_ty,
-            hir_bounds,
-            &mut bounds,
-            ty::List::empty(),
-            filter,
-            OverlappingAsssocItemConstraints::Allowed,
-        );
+        icx.lowerer().lower_bounds(item_ty, hir_bounds, &mut bounds, ty::List::empty(), filter);
 
         match filter {
             PredicateFilter::All
@@ -366,14 +357,7 @@ fn opaque_type_bounds<'tcx>(
     ty::print::with_reduced_queries!({
         let icx = ItemCtxt::new(tcx, opaque_def_id);
         let mut bounds = Vec::new();
-        icx.lowerer().lower_bounds(
-            item_ty,
-            hir_bounds,
-            &mut bounds,
-            ty::List::empty(),
-            filter,
-            OverlappingAsssocItemConstraints::Allowed,
-        );
+        icx.lowerer().lower_bounds(item_ty, hir_bounds, &mut bounds, ty::List::empty(), filter);
         // Implicit bounds are added to opaque types unless a `?Trait` bound is found
         match filter {
             PredicateFilter::All

compiler/rustc_hir_analysis/src/collect/predicates_of.rs

@@ -18,8 +18,7 @@ use crate::collect::ItemCtxt;
 use crate::constrained_generic_params as cgp;
 use crate::delegation::inherit_predicates_for_delegation_item;
 use crate::hir_ty_lowering::{
-    HirTyLowerer, ImpliedBoundsContext, OverlappingAsssocItemConstraints, PredicateFilter,
-    RegionInferReason,
+    HirTyLowerer, ImpliedBoundsContext, PredicateFilter, RegionInferReason,
 };
 
 /// Returns a list of all type predicates (explicit and implicit) for the definition with
@@ -194,7 +193,6 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
             &mut bounds,
             ty::List::empty(),
             PredicateFilter::All,
-            OverlappingAsssocItemConstraints::Allowed,
         );
         icx.lowerer().add_implicit_sizedness_bounds(
             &mut bounds,
@@ -295,7 +293,6 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
                     &mut bounds,
                     bound_vars,
                     PredicateFilter::All,
-                    OverlappingAsssocItemConstraints::Allowed,
                 );
                 predicates.extend(bounds);
             }
@@ -675,14 +672,7 @@ pub(super) fn implied_predicates_with_filter<'tcx>(
 
     let self_param_ty = tcx.types.self_param;
     let mut bounds = Vec::new();
-    icx.lowerer().lower_bounds(
-        self_param_ty,
-        superbounds,
-        &mut bounds,
-        ty::List::empty(),
-        filter,
-        OverlappingAsssocItemConstraints::Allowed,
-    );
+    icx.lowerer().lower_bounds(self_param_ty, superbounds, &mut bounds, ty::List::empty(), filter);
     match filter {
         PredicateFilter::All
         | PredicateFilter::SelfOnly
@@ -1040,7 +1030,6 @@ impl<'tcx> ItemCtxt<'tcx> {
                 &mut bounds,
                 bound_vars,
                 filter,
-                OverlappingAsssocItemConstraints::Allowed,
             );
         }
 
@@ -1126,7 +1115,6 @@ pub(super) fn const_conditions<'tcx>(
                     &mut bounds,
                     bound_vars,
                     PredicateFilter::ConstIfConst,
-                    OverlappingAsssocItemConstraints::Allowed,
                 );
             }
             _ => {}
@@ -1149,7 +1137,6 @@ pub(super) fn const_conditions<'tcx>(
             &mut bounds,
             ty::List::empty(),
             PredicateFilter::ConstIfConst,
-            OverlappingAsssocItemConstraints::Allowed,
         );
     }
 

compiler/rustc_hir_analysis/src/errors.rs

@@ -430,18 +430,6 @@ pub(crate) struct ParenthesizedFnTraitExpansion {
     pub expanded_type: String,
 }
 
-#[derive(Diagnostic)]
-#[diag("the value of the associated type `{$item_name}` in trait `{$def_path}` is already specified", code = E0719)]
-pub(crate) struct ValueOfAssociatedStructAlreadySpecified {
-    #[primary_span]
-    #[label("re-bound here")]
-    pub span: Span,
-    #[label("`{$item_name}` bound here first")]
-    pub prev_span: Span,
-    pub item_name: Ident,
-    pub def_path: String,
-}
-
 #[derive(Diagnostic)]
 #[diag("unconstrained opaque type")]
 #[note("`{$name}` must be used in combination with a concrete type within the same {$what}")]

compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs

@@ -19,8 +19,8 @@ use tracing::{debug, instrument};
 
 use crate::errors;
 use crate::hir_ty_lowering::{
-    AssocItemQSelf, GenericsArgsErrExtend, HirTyLowerer, ImpliedBoundsContext,
-    OverlappingAsssocItemConstraints, PredicateFilter, RegionInferReason,
+    AssocItemQSelf, GenericsArgsErrExtend, HirTyLowerer, ImpliedBoundsContext, PredicateFilter,
+    RegionInferReason,
 };
 
 #[derive(Debug, Default)]
@@ -363,7 +363,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         bounds: &mut Vec<(ty::Clause<'tcx>, Span)>,
         bound_vars: &'tcx ty::List<ty::BoundVariableKind<'tcx>>,
         predicate_filter: PredicateFilter,
-        overlapping_assoc_constraints: OverlappingAsssocItemConstraints,
     ) where
         'tcx: 'hir,
     {
@@ -388,7 +387,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                         param_ty,
                         bounds,
                         predicate_filter,
-                        overlapping_assoc_constraints,
                     );
                 }
                 hir::GenericBound::Outlives(lifetime) => {
@@ -422,14 +420,13 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
     /// the `trait_ref` here will be `for<'a> T: Iterator`.
     /// The `constraint` data however is from *inside* the binder
     /// (e.g., `&'a u32`) and hence may reference bound regions.
-    #[instrument(level = "debug", skip(self, bounds, duplicates, path_span))]
+    #[instrument(level = "debug", skip(self, bounds, path_span))]
     pub(super) fn lower_assoc_item_constraint(
         &self,
         hir_ref_id: hir::HirId,
         trait_ref: ty::PolyTraitRef<'tcx>,
         constraint: &hir::AssocItemConstraint<'tcx>,
         bounds: &mut Vec<(ty::Clause<'tcx>, Span)>,
-        duplicates: Option<&mut FxIndexMap<DefId, Span>>,
         path_span: Span,
         predicate_filter: PredicateFilter,
     ) -> Result<(), ErrorGuaranteed> {
@@ -485,20 +482,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             )
             .expect("failed to find associated item");
 
-        if let Some(duplicates) = duplicates {
-            duplicates
-                .entry(assoc_item.def_id)
-                .and_modify(|prev_span| {
-                    self.dcx().emit_err(errors::ValueOfAssociatedStructAlreadySpecified {
-                        span: constraint.span,
-                        prev_span: *prev_span,
-                        item_name: constraint.ident,
-                        def_path: tcx.def_path_str(assoc_item.container_id(tcx)),
-                    });
-                })
-                .or_insert(constraint.span);
-        }
-
         let projection_term = if let ty::AssocTag::Fn = assoc_tag {
             let bound_vars = tcx.late_bound_vars(constraint.hir_id);
             ty::Binder::bind_with_vars(
@@ -646,7 +629,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                             bounds,
                             projection_ty.bound_vars(),
                             predicate_filter,
-                            OverlappingAsssocItemConstraints::Allowed,
                         );
                     }
                     PredicateFilter::SelfOnly

compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_trait.rs

@@ -28,8 +28,7 @@ use tracing::{debug, instrument};
 use super::HirTyLowerer;
 use crate::errors::DynTraitAssocItemBindingMentionsSelf;
 use crate::hir_ty_lowering::{
-    GenericArgCountMismatch, ImpliedBoundsContext, OverlappingAsssocItemConstraints,
-    PredicateFilter, RegionInferReason,
+    GenericArgCountMismatch, ImpliedBoundsContext, PredicateFilter, RegionInferReason,
 };
 
 impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
@@ -72,7 +71,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 dummy_self,
                 &mut user_written_bounds,
                 PredicateFilter::SelfOnly,
-                OverlappingAsssocItemConstraints::Allowed,
             );
             if let Err(GenericArgCountMismatch { invalid_args, .. }) = result.correct {
                 potential_assoc_items.extend(invalid_args);

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -23,7 +23,7 @@ use std::{assert_matches, slice};
 
 use rustc_abi::FIRST_VARIANT;
 use rustc_ast::LitKind;
-use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet};
+use rustc_data_structures::fx::{FxHashSet, FxIndexSet};
 use rustc_errors::codes::*;
 use rustc_errors::{
     Applicability, Diag, DiagCtxtHandle, ErrorGuaranteed, FatalError, StashKey,
@@ -331,15 +331,6 @@ pub(crate) enum GenericArgPosition {
     Value(IsMethodCall),
 }
 
-/// Whether to allow duplicate associated iten constraints in a trait ref, e.g.
-/// `Trait<Assoc = Ty, Assoc = Ty>`. This is forbidden in `dyn Trait<...>`
-/// but allowed everywhere else.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub(crate) enum OverlappingAsssocItemConstraints {
-    Allowed,
-    Forbidden,
-}
-
 /// A marker denoting that the generic arguments that were
 /// provided did not match the respective generic parameters.
 #[derive(Clone, Debug)]
@@ -958,7 +949,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         self_ty: Ty<'tcx>,
         bounds: &mut Vec<(ty::Clause<'tcx>, Span)>,
         predicate_filter: PredicateFilter,
-        overlapping_assoc_item_constraints: OverlappingAsssocItemConstraints,
     ) -> GenericArgCountResult {
         let tcx = self.tcx();
 
@@ -1137,10 +1127,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             }
         }
 
-        let mut dup_constraints = (overlapping_assoc_item_constraints
-            == OverlappingAsssocItemConstraints::Forbidden)
-            .then_some(FxIndexMap::default());
-
         for constraint in constraints {
             // Don't register any associated item constraints for negative bounds,
             // since we should have emitted an error for them earlier, and they
@@ -1159,7 +1145,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 poly_trait_ref,
                 constraint,
                 bounds,
-                dup_constraints.as_mut(),
                 constraint.span,
                 predicate_filter,
             );
@@ -3057,7 +3042,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                     &mut bounds,
                     ty::List::empty(),
                     PredicateFilter::All,
-                    OverlappingAsssocItemConstraints::Allowed,
                 );
                 self.add_implicit_sizedness_bounds(
                     &mut bounds,