Some tracing to builtin fn candidates

Author: jackh726

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

@@ -429,7 +429,9 @@ where
         } else if cx.trait_is_alias(trait_def_id) {
             G::consider_trait_alias_candidate(self, goal)
         } else {
-            match cx.as_lang_item(trait_def_id) {
+            let lang_item = cx.as_lang_item(trait_def_id);
+            tracing::trace!(?lang_item);
+            match lang_item {
                 Some(TraitSolverLangItem::Sized) => G::consider_builtin_sized_candidate(self, goal),
                 Some(TraitSolverLangItem::Copy | TraitSolverLangItem::Clone) => {
                     G::consider_builtin_copy_clone_candidate(self, goal)

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

@@ -260,6 +260,7 @@ where
 }
 
 // Returns a binder of the tupled inputs types and output type from a builtin callable type.
+#[tracing::instrument(level = "trace", skip(cx), ret)]
 pub(in crate::solve) fn extract_tupled_inputs_and_output_from_callable<
     Ir: RustIr<Interner = I>,
     I: Interner,

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

@@ -156,6 +156,7 @@ where
         self.trait_def_id(cx)
     }
 
+    #[instrument(level = "trace", skip(ecx, then))]
     fn probe_and_match_goal_against_assumption(
         ecx: &mut EvalCtxt<'_, D>,
         source: CandidateSource<I>,
@@ -164,17 +165,20 @@ where
         then: impl FnOnce(&mut EvalCtxt<'_, D>) -> QueryResult<I>,
     ) -> Result<Candidate<I>, NoSolution> {
         if let Some(projection_pred) = assumption.as_projection_clause() {
+            tracing::trace!("assumption is projection clause");
             if projection_pred.projection_def_id() == goal.predicate.clone().def_id() {
                 let cx = ecx.cx();
                 if !DeepRejectCtxt::relate_rigid_rigid(cx.interner()).args_may_unify(
                     goal.predicate.alias.args.clone(),
                     projection_pred.clone().skip_binder().projection_term.args,
                 ) {
+                    tracing::trace!("args will not unify");
                     return Err(NoSolution);
                 }
                 ecx.probe_trait_candidate(source).enter(|ecx| {
                     let assumption_projection_pred =
                         ecx.instantiate_binder_with_infer(projection_pred);
+                    tracing::trace!(?assumption_projection_pred);
                     ecx.eq(
                         goal.param_env.clone(),
                         goal.predicate.alias.clone(),
@@ -334,6 +338,8 @@ where
                 kind => panic!("expected projection, found {kind:?}"),
             };
 
+            tracing::trace!(?term);
+
             ecx.instantiate_normalizes_to_term(goal, term.instantiate(cx.interner(), target_args));
             ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
         })
@@ -384,6 +390,7 @@ where
         panic!("`FnPtr` does not have an associated type: {:?}", goal);
     }
 
+    #[tracing::instrument(level = "trace", skip(ecx), ret)]
     fn consider_builtin_fn_trait_candidates(
         ecx: &mut EvalCtxt<'_, D>,
         goal: Goal<I, Self>,
@@ -418,6 +425,8 @@ where
             })
             .upcast(cx.interner());
 
+        tracing::trace!(?pred);
+
         Self::probe_and_consider_implied_clause(
             ecx,
             CandidateSource::BuiltinImpl(BuiltinImplSource::Misc),

compiler/rustc_next_trait_solver/src/solve/trait_goals.rs

@@ -129,6 +129,7 @@ where
             .enter(|ecx| ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes))
     }
 
+    #[instrument(level = "trace", skip(ecx, then))]
     fn probe_and_match_goal_against_assumption(
         ecx: &mut EvalCtxt<'_, D>,
         source: CandidateSource<I>,
@@ -137,13 +138,16 @@ where
         then: impl FnOnce(&mut EvalCtxt<'_, D>) -> QueryResult<I>,
     ) -> Result<Candidate<I>, NoSolution> {
         if let Some(trait_clause) = assumption.as_trait_clause() {
+            trace!("assumption is trait_clause");
             if trait_clause.clone().def_id() == goal.predicate.clone().def_id()
                 && trait_clause.clone().polarity() == goal.predicate.polarity
             {
+                trace!("trait and polarity match");
                 if !DeepRejectCtxt::relate_rigid_rigid(ecx.cx().interner()).args_may_unify(
                     goal.predicate.trait_ref.args.clone(),
                     trait_clause.clone().skip_binder().trait_ref.args,
                 ) {
+                    trace!("args may not unify");
                     return Err(NoSolution);
                 }
 
@@ -306,6 +310,7 @@ where
             )? {
                 Some(a) => a,
                 None => {
+                    trace!("Unable to extract inputs and output");
                     return ecx.forced_ambiguity(MaybeCause::Ambiguity);
                 }
             };
@@ -324,6 +329,7 @@ where
                 ])
             })
             .upcast(cx.interner());
+        trace!(?pred);
         Self::probe_and_consider_implied_clause(
             ecx,
             CandidateSource::BuiltinImpl(BuiltinImplSource::Misc),

compiler/rustc_type_ir/src/fast_reject.rs

@@ -236,6 +236,7 @@ impl<I: Interner, const INSTANTIATE_LHS_WITH_INFER: bool, const INSTANTIATE_RHS_
         })
     }
 
+    #[tracing::instrument(level = "trace", skip(self), ret)]
     pub fn types_may_unify(self, lhs: I::Ty, rhs: I::Ty) -> bool {
         match rhs.clone().kind() {
             // Start by checking whether the `rhs` type may unify with

compiler/rustc_type_ir/src/lang_items.rs

@@ -1,5 +1,6 @@
 /// Lang items used by the new trait solver. This can be mapped to whatever internal
 /// representation of `LangItem`s used in the underlying compiler implementation.
+#[derive(Debug, PartialEq)]
 pub enum TraitSolverLangItem {
     // tidy-alphabetical-start
     AsyncDestruct,