Ensure we give spans for obligations everywhere

Author: ChayimFriedman2

crates/hir-ty/src/autoderef.rs

@@ -40,7 +40,7 @@ pub fn autoderef<'db>(
     let interner = DbInterner::new_with(db, env.krate);
     let infcx = interner.infer_ctxt().build(TypingMode::PostAnalysis);
     let (ty, _) = infcx.instantiate_canonical(Span::Dummy, &ty);
-    let autoderef = Autoderef::new(&infcx, env.param_env, ty);
+    let autoderef = Autoderef::new(&infcx, env.param_env, ty, Span::Dummy);
     let mut v = Vec::new();
     for (ty, _steps) in autoderef {
         // `ty` may contain unresolved inference variables. Since there's no chance they would be
@@ -155,6 +155,7 @@ pub(crate) struct GeneralAutoderef<'db, Ctx, Steps = Vec<(Ty<'db>, AutoderefKind
     // Configurations:
     include_raw_pointers: bool,
     use_receiver_trait: bool,
+    span: Span,
 }
 
 pub(crate) type Autoderef<'a, 'db, Steps = Vec<(Ty<'db>, AutoderefKind)>> =
@@ -200,7 +201,7 @@ where
                 // autoderef expect this type to have been structurally normalized.
                 if let TyKind::Alias(..) = ty.kind() {
                     let (normalized_ty, obligations) =
-                        structurally_normalize_ty(self.infcx(), self.param_env(), ty)?;
+                        structurally_normalize_ty(self.infcx(), self.param_env(), ty, self.span)?;
                     self.state.obligations.extend(obligations);
                     (AutoderefKind::Builtin, normalized_ty)
                 } else {
@@ -232,8 +233,9 @@ impl<'a, 'db> Autoderef<'a, 'db> {
         infcx: &'a InferCtxt<'db>,
         param_env: ParamEnv<'db>,
         base_ty: Ty<'db>,
+        span: Span,
     ) -> Self {
-        Self::new_impl(DefaultAutoderefCtx { infcx, param_env }, base_ty)
+        Self::new_impl(DefaultAutoderefCtx { infcx, param_env }, base_ty, span)
     }
 }
 
@@ -242,8 +244,9 @@ impl<'a, 'b, 'db> InferenceContextAutoderef<'a, 'b, 'db> {
     pub(crate) fn new_from_inference_context(
         ctx: &'a mut InferenceContext<'b, 'db>,
         base_ty: Ty<'db>,
+        span: Span,
     ) -> Self {
-        Self::new_impl(InferenceContextAutoderefCtx(ctx), base_ty)
+        Self::new_impl(InferenceContextAutoderefCtx(ctx), base_ty, span)
     }
 
     #[inline]
@@ -258,8 +261,9 @@ impl<'a, 'db> Autoderef<'a, 'db, usize> {
         infcx: &'a InferCtxt<'db>,
         param_env: ParamEnv<'db>,
         base_ty: Ty<'db>,
+        span: Span,
     ) -> Self {
-        Self::new_impl(DefaultAutoderefCtx { infcx, param_env }, base_ty)
+        Self::new_impl(DefaultAutoderefCtx { infcx, param_env }, base_ty, span)
     }
 }
 
@@ -269,7 +273,7 @@ where
     Steps: TrackAutoderefSteps<'db>,
 {
     #[inline]
-    fn new_impl(ctx: Ctx, base_ty: Ty<'db>) -> Self {
+    fn new_impl(ctx: Ctx, base_ty: Ty<'db>, span: Span) -> Self {
         GeneralAutoderef {
             state: AutoderefSnapshot {
                 steps: Steps::default(),
@@ -282,6 +286,7 @@ where
             traits: None,
             include_raw_pointers: false,
             use_receiver_trait: false,
+            span,
         }
     }
 
@@ -338,7 +343,7 @@ where
 
         let trait_ref = TraitRef::new(interner, trait_.into(), [ty]);
         let obligation =
-            Obligation::new(interner, ObligationCause::new(), self.param_env(), trait_ref);
+            Obligation::new(interner, ObligationCause::new(self.span), self.param_env(), trait_ref);
         // We detect whether the self type implements `Deref` before trying to
         // structurally normalize. We use `predicate_may_hold_opaque_types_jank`
         // to support not-yet-defined opaque types. It will succeed for `impl Deref`
@@ -352,6 +357,7 @@ where
             self.infcx(),
             self.param_env(),
             Ty::new_projection(interner, trait_target.into(), [ty]),
+            self.span,
         )?;
         debug!("overloaded_deref_ty({:?}) = ({:?}, {:?})", ty, normalized_ty, obligations);
         self.state.obligations.extend(obligations);
@@ -403,9 +409,11 @@ fn structurally_normalize_ty<'db>(
     infcx: &InferCtxt<'db>,
     param_env: ParamEnv<'db>,
     ty: Ty<'db>,
+    span: Span,
 ) -> Option<(Ty<'db>, PredicateObligations<'db>)> {
     let mut ocx = ObligationCtxt::new(infcx);
-    let Ok(normalized_ty) = ocx.structurally_normalize_ty(&ObligationCause::misc(), param_env, ty)
+    let Ok(normalized_ty) =
+        ocx.structurally_normalize_ty(&ObligationCause::new(span), param_env, ty)
     else {
         // We shouldn't have errors here in the old solver, except for
         // evaluate/fulfill mismatches, but that's not a reason for an ICE.

crates/hir-ty/src/display.rs

@@ -738,7 +738,7 @@ fn render_const_scalar<'db>(
 ) -> Result {
     let param_env = ParamEnv::empty();
     let infcx = f.interner.infer_ctxt().build(TypingMode::PostAnalysis);
-    let ty = infcx.at(&ObligationCause::new(), param_env).deeply_normalize(ty).unwrap_or(ty);
+    let ty = infcx.at(&ObligationCause::dummy(), param_env).deeply_normalize(ty).unwrap_or(ty);
     render_const_scalar_inner(f, b, memory_map, ty, param_env)
 }
 
@@ -1023,7 +1023,7 @@ fn render_const_scalar_from_valtree<'db>(
 ) -> Result {
     let param_env = ParamEnv::empty();
     let infcx = f.interner.infer_ctxt().build(TypingMode::PostAnalysis);
-    let ty = infcx.at(&ObligationCause::new(), param_env).deeply_normalize(ty).unwrap_or(ty);
+    let ty = infcx.at(&ObligationCause::dummy(), param_env).deeply_normalize(ty).unwrap_or(ty);
     render_const_scalar_from_valtree_inner(f, ty, valtree, param_env)
 }
 

crates/hir-ty/src/infer.rs

@@ -1926,7 +1926,7 @@ impl<'body, 'db> InferenceContext<'body, 'db> {
     }
 
     pub(crate) fn structurally_resolve_type(&mut self, node: ExprOrPatId, ty: Ty<'db>) -> Ty<'db> {
-        let result = self.table.try_structurally_resolve_type(ty);
+        let result = self.table.try_structurally_resolve_type(node.into(), ty);
         if result.is_ty_var() { self.type_must_be_known_at_this_point(node, ty) } else { result }
     }
 
@@ -1936,14 +1936,18 @@ impl<'body, 'db> InferenceContext<'body, 'db> {
         expected: Ty<'db>,
         actual: Ty<'db>,
     ) -> Result<(), ()> {
-        let result = self.demand_eqtype_fixme_no_diag(expected, actual);
+        let result = self
+            .table
+            .at(&ObligationCause::new(id))
+            .eq(expected, actual)
+            .map(|infer_ok| self.table.register_infer_ok(infer_ok));
         if result.is_err() {
             self.result
                 .type_mismatches
                 .get_or_insert_default()
                 .insert(id, TypeMismatch { expected: expected.store(), actual: actual.store() });
         }
-        result
+        result.map_err(drop)
     }
 
     fn demand_eqtype_fixme_no_diag(
@@ -1953,7 +1957,7 @@ impl<'body, 'db> InferenceContext<'body, 'db> {
     ) -> Result<(), ()> {
         let result = self
             .table
-            .at(&ObligationCause::new())
+            .at(&ObligationCause::dummy())
             .eq(expected, actual)
             .map(|infer_ok| self.table.register_infer_ok(infer_ok));
         result.map_err(drop)
@@ -1967,7 +1971,7 @@ impl<'body, 'db> InferenceContext<'body, 'db> {
     ) -> Result<(), ()> {
         let result = self
             .table
-            .at(&ObligationCause::new())
+            .at(&ObligationCause::new(id))
             .sup(expected, actual)
             .map(|infer_ok| self.table.register_infer_ok(infer_ok));
         if result.is_err() {
@@ -2008,11 +2012,11 @@ impl<'body, 'db> InferenceContext<'body, 'db> {
         self.types.types.error
     }
 
-    pub(crate) fn require_type_is_sized(&mut self, ty: Ty<'db>) {
+    pub(crate) fn require_type_is_sized(&mut self, ty: Ty<'db>, span: Span) {
         if !ty.references_non_lt_error()
             && let Some(sized_trait) = self.lang_items.Sized
         {
-            self.table.register_bound(ty, sized_trait, ObligationCause::new());
+            self.table.register_bound(ty, sized_trait, ObligationCause::new(span));
         }
     }
 
@@ -2077,7 +2081,7 @@ impl<'body, 'db> InferenceContext<'body, 'db> {
                         args,
                     ),
                 );
-                ty = self.table.try_structurally_resolve_type(alias);
+                ty = self.table.try_structurally_resolve_type(node.into(), alias);
                 segments = segments.skip(1);
             }
 
@@ -2177,7 +2181,7 @@ impl<'body, 'db> InferenceContext<'body, 'db> {
                         never!("resolver should always resolve lang item paths");
                         return (self.err_ty(), None);
                     };
-                    return self.resolve_variant_on_alias(ty, None, mod_path);
+                    return self.resolve_variant_on_alias(node, ty, None, mod_path);
                 };
 
                 let mut remaining_segments = path.segments().skip(remaining_idx);
@@ -2290,7 +2294,7 @@ impl<'body, 'db> InferenceContext<'body, 'db> {
                 let ty = self.db.ty(it.into()).instantiate(interner, args);
                 let ty = self.insert_type_vars(ty, Span::Dummy);
 
-                self.resolve_variant_on_alias(ty, unresolved, mod_path)
+                self.resolve_variant_on_alias(node, ty, unresolved, mod_path)
             }
             TypeNs::AdtSelfType(_) => {
                 // FIXME this could happen in array size expressions, once we're checking them
@@ -2322,12 +2326,13 @@ impl<'body, 'db> InferenceContext<'body, 'db> {
 
     fn resolve_variant_on_alias(
         &mut self,
+        node: ExprOrPatId,
         ty: Ty<'db>,
         unresolved: Option<usize>,
         path: &ModPath,
     ) -> (Ty<'db>, Option<VariantId>) {
         let remaining = unresolved.map(|it| path.segments()[it..].len()).filter(|it| it > &0);
-        let ty = self.table.try_structurally_resolve_type(ty);
+        let ty = self.table.try_structurally_resolve_type(node.into(), ty);
         match remaining {
             None => {
                 let variant = ty.as_adt().and_then(|(adt_id, _)| match adt_id {
@@ -2540,10 +2545,14 @@ impl<'db> Expectation<'db> {
     /// an expected type. Otherwise, we might write parts of the type
     /// when checking the 'then' block which are incompatible with the
     /// 'else' branch.
-    fn adjust_for_branches(&self, table: &mut unify::InferenceTable<'db>) -> Expectation<'db> {
+    fn adjust_for_branches(
+        &self,
+        table: &mut unify::InferenceTable<'db>,
+        span: Span,
+    ) -> Expectation<'db> {
         match *self {
             Expectation::HasType(ety) => {
-                let ety = table.try_structurally_resolve_type(ety);
+                let ety = table.try_structurally_resolve_type(span, ety);
                 if ety.is_ty_var() { Expectation::None } else { Expectation::HasType(ety) }
             }
             Expectation::RValueLikeUnsized(ety) => Expectation::RValueLikeUnsized(ety),

crates/hir-ty/src/infer/autoderef.rs

@@ -5,7 +5,7 @@ use std::iter;
 use rustc_ast_ir::Mutability;
 
 use crate::{
-    Adjust, Adjustment, OverloadedDeref,
+    Adjust, Adjustment, OverloadedDeref, Span,
     autoderef::{Autoderef, AutoderefCtx, AutoderefKind, GeneralAutoderef},
     infer::unify::InferenceTable,
     next_solver::{
@@ -15,12 +15,16 @@ use crate::{
 };
 
 impl<'db> InferenceTable<'db> {
-    pub(crate) fn autoderef(&self, base_ty: Ty<'db>) -> Autoderef<'_, 'db, usize> {
-        Autoderef::new(&self.infer_ctxt, self.param_env, base_ty)
+    pub(crate) fn autoderef(&self, base_ty: Ty<'db>, span: Span) -> Autoderef<'_, 'db, usize> {
+        Autoderef::new(&self.infer_ctxt, self.param_env, base_ty, span)
     }
 
-    pub(crate) fn autoderef_with_tracking(&self, base_ty: Ty<'db>) -> Autoderef<'_, 'db> {
-        Autoderef::new_with_tracking(&self.infer_ctxt, self.param_env, base_ty)
+    pub(crate) fn autoderef_with_tracking(
+        &self,
+        base_ty: Ty<'db>,
+        span: Span,
+    ) -> Autoderef<'_, 'db> {
+        Autoderef::new_with_tracking(&self.infer_ctxt, self.param_env, base_ty, span)
     }
 }
 

crates/hir-ty/src/infer/callee.rs

@@ -45,9 +45,11 @@ impl<'db> InferenceContext<'_, 'db> {
     ) -> Ty<'db> {
         let original_callee_ty = self.infer_expr_no_expect(callee_expr, ExprIsRead::Yes);
 
-        let expr_ty = self.table.try_structurally_resolve_type(original_callee_ty);
+        let expr_ty =
+            self.table.try_structurally_resolve_type(callee_expr.into(), original_callee_ty);
 
-        let mut autoderef = GeneralAutoderef::new_from_inference_context(self, expr_ty);
+        let mut autoderef =
+            GeneralAutoderef::new_from_inference_context(self, expr_ty, callee_expr.into());
         let mut result = None;
         let mut error_reported = false;
         while result.is_none() && autoderef.next().is_some() {
@@ -97,7 +99,7 @@ impl<'db> InferenceContext<'_, 'db> {
         };
 
         // we must check that return type of called functions is WF:
-        self.table.register_wf_obligation(output.into(), ObligationCause::new());
+        self.table.register_wf_obligation(output.into(), ObligationCause::new(call_expr));
 
         output
     }
@@ -110,7 +112,8 @@ impl<'db> InferenceContext<'_, 'db> {
         error_reported: &mut bool,
     ) -> Option<CallStep<'db>> {
         let final_ty = autoderef.final_ty();
-        let adjusted_ty = autoderef.ctx().table.try_structurally_resolve_type(final_ty);
+        let adjusted_ty =
+            autoderef.ctx().table.try_structurally_resolve_type(callee_expr.into(), final_ty);
 
         // If the callee is a function pointer or a closure, then we're all set.
         match adjusted_ty.kind() {
@@ -244,8 +247,8 @@ impl<'db> InferenceContext<'_, 'db> {
         // is implemented, and use this information for diagnostic.
         autoderef
             .ctx()
-            .try_overloaded_call_traits(adjusted_ty, Some(arg_exprs))
-            .or_else(|| autoderef.ctx().try_overloaded_call_traits(adjusted_ty, None))
+            .try_overloaded_call_traits(call_expr, adjusted_ty, Some(arg_exprs))
+            .or_else(|| autoderef.ctx().try_overloaded_call_traits(call_expr, adjusted_ty, None))
             .map(|(autoref, method)| {
                 let adjustments = autoderef.adjust_steps_as_infer_ok();
                 let mut adjustments = autoderef.ctx().table.register_infer_ok(adjustments);
@@ -257,6 +260,7 @@ impl<'db> InferenceContext<'_, 'db> {
 
     fn try_overloaded_call_traits(
         &mut self,
+        call_expr: ExprId,
         adjusted_ty: Ty<'db>,
         opt_arg_exprs: Option<&[ExprId]>,
     ) -> Option<(Option<Adjustment>, MethodCallee<'db>)> {
@@ -312,7 +316,7 @@ impl<'db> InferenceContext<'_, 'db> {
             // one which may apply. So if we treat opaques as inference variables
             // `Box<impl FnOnce()>: Fn` is considered ambiguous and chosen.
             if let Some(ok) = self.table.lookup_method_for_operator(
-                ObligationCause::new(),
+                ObligationCause::new(call_expr),
                 method_name,
                 trait_def_id,
                 adjusted_ty,
@@ -470,8 +474,9 @@ impl<'db> InferenceContext<'_, 'db> {
             && let Some(ty) = fn_sig.inputs().last().copied()
             && let Some(tuple_trait) = self.lang_items.Tuple
         {
-            self.table.register_bound(ty, tuple_trait, ObligationCause::new());
-            self.require_type_is_sized(ty);
+            let span = arg_exprs.last().copied().unwrap_or(call_expr);
+            self.table.register_bound(ty, tuple_trait, ObligationCause::new(span));
+            self.require_type_is_sized(ty, span.into());
         }
 
         fn_sig.output()
@@ -544,7 +549,7 @@ impl<'a, 'db> DeferredCallResolution<'db> {
         assert!(ctx.infcx().closure_kind(self.closure_ty).is_some());
 
         // We may now know enough to figure out fn vs fnmut etc.
-        match ctx.try_overloaded_call_traits(self.closure_ty, None) {
+        match ctx.try_overloaded_call_traits(self.call_expr, self.closure_ty, None) {
             Some((autoref, method_callee)) => {
                 // One problem is that when we get here, we are going
                 // to have a newly instantiated function signature