Add instrument to is_fn_trait_compatible

Author: jackh726

compiler/rustc_hir_typeck/src/callee.rs

@@ -19,7 +19,7 @@ use rustc_span::symbol::{Ident, sym};
 use rustc_trait_selection::error_reporting::traits::DefIdOrName;
 use rustc_trait_selection::infer::InferCtxtExt as _;
 use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt as _;
-use tracing::{debug, instrument};
+use tracing::{debug, instrument, trace};
 
 use super::method::MethodCallee;
 use super::method::probe::ProbeScope;
@@ -494,6 +494,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         // have been normalized before.
         let fn_sig = self.instantiate_binder_with_fresh_vars(call_expr.span, infer::FnCall, fn_sig);
         let fn_sig = self.normalize(call_expr.span, fn_sig);
+        trace!(?fn_sig);
 
         self.check_argument_types(
             call_expr.span,
@@ -544,6 +545,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             }
         }
 
+        let fn_sig = self.resolve_vars_if_possible(fn_sig);
+        trace!(?fn_sig);
         fn_sig.output()
     }
 

compiler/rustc_hir_typeck/src/expr.rs

@@ -182,7 +182,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
     /// Check an expr with an expectation type which may be used to eagerly
     /// guide inference when evaluating that expr.
-    #[instrument(skip(self, expr), level = "debug")]
     pub(super) fn check_expr_with_expectation(
         &self,
         expr: &'tcx hir::Expr<'tcx>,
@@ -195,6 +194,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     /// the arguments of a [`ExprKind::Call`] when evaluating its callee that
     /// is an [`ExprKind::Path`]. We use this to refine the spans for certain
     /// well-formedness guarantees for the path expr.
+    #[instrument(skip(self, expr), level = "debug")]
     pub(super) fn check_expr_with_expectation_and_args(
         &self,
         expr: &'tcx hir::Expr<'tcx>,

compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs

@@ -27,7 +27,7 @@ use rustc_span::{DUMMY_SP, Span, sym};
 use rustc_trait_selection::error_reporting::infer::{FailureCode, ObligationCauseExt};
 use rustc_trait_selection::infer::InferCtxtExt;
 use rustc_trait_selection::traits::{self, ObligationCauseCode, ObligationCtxt, SelectionContext};
-use tracing::debug;
+use tracing::{debug, trace};
 use {rustc_ast as ast, rustc_hir as hir};
 
 use crate::Expectation::*;
@@ -314,8 +314,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             // 1. Unify the provided argument with the expected type
             let expectation = Expectation::rvalue_hint(self, expected_input_ty);
 
+            trace!(?expectation);
+
             let checked_ty = self.check_expr_with_expectation(provided_arg, expectation);
 
+            trace!(?checked_ty);
+            let checked_ty = self.resolve_vars_with_obligations(checked_ty);
+            trace!(?checked_ty);
+
             // 2. Coerce to the most detailed type that could be coerced
             //    to, which is `expected_ty` if `rvalue_hint` returns an
             //    `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
@@ -326,6 +332,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             // fulfillment error to be more accurate.
             let coerced_ty = self.resolve_vars_with_obligations(coerced_ty);
 
+            trace!(?coerced_ty);
+
             let coerce_error =
                 self.coerce(provided_arg, checked_ty, coerced_ty, AllowTwoPhase::Yes, None).err();
             if coerce_error.is_some() {
@@ -343,6 +351,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             // If neither check failed, the types are compatible
             match formal_ty_error {
                 Ok(InferOk { obligations, value: () }) => {
+                    trace!(?obligations);
                     self.register_predicates(obligations);
                     Compatibility::Compatible
                 }
@@ -421,6 +430,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             }
         }
 
+        for input in formal_input_tys.iter() {
+            let input = self.resolve_vars_if_possible(*input);
+            trace!(?input);
+        }
+
         if c_variadic && provided_arg_count < minimum_input_count {
             err_code = E0060;
         }

compiler/rustc_type_ir/src/ty_kind.rs

@@ -887,8 +887,10 @@ impl<I: Interner> FnSig<I> {
         self.inputs_and_output.output()
     }
 
+    #[tracing::instrument(skip(self), ret)]
     pub fn is_fn_trait_compatible(self) -> bool {
         let FnSig { safety, abi, c_variadic, .. } = self;
+        tracing::debug!(?c_variadic, ?safety, ?abi);
         !c_variadic && safety.is_safe() && abi.is_rust()
     }
 }