Incompletely prefer opaque type bounds when self type bottoms out in infer

Author: compiler-errors

compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs

@@ -6,9 +6,10 @@ use derive_where::derive_where;
 use rustc_type_ir::inherent::*;
 use rustc_type_ir::lang_items::TraitSolverLangItem;
 use rustc_type_ir::{
-    self as ty, Interner, TypeFoldable, TypeVisitableExt as _, TypingMode, Upcast as _, elaborate,
+    self as ty, Interner, TypeFoldable, TypeFolder, TypeSuperFoldable, TypeVisitableExt as _,
+    TypingMode, Upcast as _, elaborate,
 };
-use tracing::{debug, instrument};
+use tracing::instrument;
 
 use super::has_only_region_constraints;
 use super::trait_goals::TraitGoalProvenVia;
@@ -316,8 +317,7 @@ where
         };
 
         if normalized_self_ty.is_ty_var() {
-            debug!("self type has been normalized to infer");
-            return self.forced_ambiguity(MaybeCause::Ambiguity).into_iter().collect();
+            return self.try_assemble_bounds_via_registered_opaque(goal, normalized_self_ty);
         }
 
         let goal: Goal<I, G> =
@@ -828,6 +828,60 @@ where
         }
     }
 
+    fn try_assemble_bounds_via_registered_opaque<G: GoalKind<D>>(
+        &mut self,
+        goal: Goal<I, G>,
+        self_ty: I::Ty,
+    ) -> Vec<Candidate<I>> {
+        //println!("for goal {goal:#?} and {self_ty:?}, we found an alias: {:#?}", self.find_sup_as_registered_opaque(self_ty));
+
+        let Some(alias_ty) = self.find_sup_as_registered_opaque(self_ty) else {
+            return self.forced_ambiguity(MaybeCause::Ambiguity).into_iter().collect();
+        };
+
+        let mut candidates = vec![];
+        for item_bound in
+            self.cx().item_self_bounds(alias_ty.def_id).iter_instantiated(self.cx(), alias_ty.args)
+        {
+            // TODO: comment
+            let assumption =
+                item_bound.fold_with(&mut ReplaceOpaque { cx: self.cx(), alias_ty, self_ty });
+            candidates.extend(G::probe_and_match_goal_against_assumption(
+                self,
+                CandidateSource::AliasBound,
+                goal,
+                assumption,
+                |ecx| ecx.evaluate_added_goals_and_make_canonical_response(Certainty::AMBIGUOUS),
+            ));
+        }
+
+        struct ReplaceOpaque<I: Interner> {
+            cx: I,
+            alias_ty: ty::AliasTy<I>,
+            self_ty: I::Ty,
+        }
+        impl<I: Interner> TypeFolder<I> for ReplaceOpaque<I> {
+            fn cx(&self) -> I {
+                self.cx
+            }
+            fn fold_ty(&mut self, ty: I::Ty) -> I::Ty {
+                if let ty::Alias(ty::Opaque, alias_ty) = ty.kind() {
+                    if alias_ty == self.alias_ty {
+                        return self.self_ty;
+                    }
+                }
+                ty.super_fold_with(self)
+            }
+        }
+
+        // TODO:
+        if candidates.is_empty() {
+            candidates.extend(self.forced_ambiguity(MaybeCause::Ambiguity));
+        }
+
+        candidates
+    }
+
     /// Assemble and merge candidates for goals which are related to an underlying trait
     /// goal. Right now, this is normalizes-to and host effect goals.
     ///

compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs

@@ -1114,6 +1114,26 @@ where
     ) -> Result<Certainty, NoSolution> {
         self.delegate.is_transmutable(dst, src, assume)
     }
+
+    pub(crate) fn find_sup_as_registered_opaque(&self, self_ty: I::Ty) -> Option<ty::AliasTy<I>> {
+        self.delegate
+            .clone_opaque_types_lookup_table()
+            .into_iter()
+            .chain(self.delegate.clone_duplicate_opaque_types())
+            .find(|(_, hidden_ty)| {
+                if let ty::Infer(ty::TyVar(self_vid)) = self_ty.kind() {
+                    if let ty::Infer(ty::TyVar(hidden_vid)) = hidden_ty.kind() {
+                        if self.delegate.sub_root_ty_var(self_vid)
+                            == self.delegate.sub_root_ty_var(hidden_vid)
+                        {
+                            return true;
+                        }
+                    }
+                }
+                false
+            })
+            .map(|(key, _)| ty::AliasTy::new_from_args(self.cx(), key.def_id.into(), key.args))
+    }
 }
 
 /// Eagerly replace aliases with inference variables, emitting `AliasRelate`