short-circuit when proj def ids differ

compiler/rustc_trait_selection/src/solve/trait_goals.rs

@@ -625,15 +625,20 @@ fn consider_builtin_upcast_to_principal(
         // in b_ty's bound. Use this to first determine *which* apply without
         // having any inference side-effects. We process obligations because
         // unification may initially succeed due to deferred projection equality.
-        let projection_may_match = |ecx: &mut Self, source_projection, target_projection| {
-            ecx.probe(|_| CandidateKind::UpcastProbe)
-                .enter(|ecx| -> Result<(), NoSolution> {
-                    ecx.eq(param_env, source_projection, target_projection)?;
-                    let _ = ecx.try_evaluate_added_goals()?;
-                    Ok(())
-                })
-                .is_ok()
-        };
+        let projection_may_match =
+            |ecx: &mut Self,
+             source_projection: ty::PolyExistentialProjection<'tcx>,
+             target_projection: ty::PolyExistentialProjection<'tcx>| {
+                source_projection.item_def_id() == target_projection.item_def_id()
+                    && ecx
+                        .probe(|_| CandidateKind::UpcastProbe)
+                        .enter(|ecx| -> Result<(), NoSolution> {
+                            ecx.eq(param_env, source_projection, target_projection)?;
+                            let _ = ecx.try_evaluate_added_goals()?;
+                            Ok(())
+                        })
+                        .is_ok()
+            };
 
         for bound in b_data {
             match bound.skip_binder() {

compiler/rustc_trait_selection/src/traits/select/confirmation.rs

@@ -920,11 +920,12 @@ fn confirm_trait_upcasting_unsize_candidate(
                         a_data.projection_bounds().filter(|source_projection| {
                             // Eager normalization means that we can just use can_eq
                             // here instead of equating and processing obligations.
-                            self.infcx.can_eq(
-                                obligation.param_env,
-                                *source_projection,
-                                target_projection,
-                            )
+                            source_projection.item_def_id() == target_projection.item_def_id()
+                                && self.infcx.can_eq(
+                                    obligation.param_env,
+                                    *source_projection,
+                                    target_projection,
+                                )
                         });
                     let Some(source_projection) = matching_projections.next() else {
                         return Err(SelectionError::Unimplemented);