Fix struct_tail_raw argument order and ObligationCause usage

compiler/rustc_borrowck/src/type_check/canonical.rs

@@ -208,11 +208,8 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                             .unwrap_or_else(|_| bug!("struct tail should have been computable, since we computed it in HIR"))
                         };
 
-                        let tail = tcx.struct_tail_raw(
-                            ty,
-                            structurally_normalize,
-                            || {},
-                        );
+                        let tail = tcx.struct_tail_raw(ty, structurally_normalize, || {}, ObligationCause::dummy());
+
 
                         Ok(tail)
                     },
@@ -222,7 +219,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
             .unwrap_or_else(|guar| Ty::new_error(tcx, guar))
         } else {
             let mut normalize = |ty| self.normalize(ty, location);
-            let tail = tcx.struct_tail_raw(ty, &mut normalize, || {});
+            let tail = tcx.struct_tail_raw(ty, &mut normalize, || {}, ObligationCause::dummy());
             normalize(tail)
         }
     }

compiler/rustc_const_eval/src/const_eval/valtrees.rs

@@ -11,6 +11,7 @@ use super::eval_queries::{mk_eval_cx_to_read_const_val, op_to_const};
 use super::machine::CompileTimeInterpCx;
 use super::{VALTREE_MAX_NODES, ValTreeCreationError, ValTreeCreationResult};
 use crate::const_eval::CanAccessMutGlobal;
+use rustc_infer::traits::ObligationCause;
 use crate::errors::MaxNumNodesInConstErr;
 use crate::interpret::{
     ImmTy, Immediate, InternKind, MPlaceTy, MemPlaceMeta, MemoryKind, PlaceTy, Projectable, Scalar,
@@ -203,7 +204,9 @@ fn reconstruct_place_meta<'tcx>(
             last_valtree = *branches.last().unwrap();
             debug!(?branches, ?last_valtree);
         },
+        ObligationCause::dummy()
     );
+
     // Sanity-check that we got a tail we support.
     match tail.kind() {
         ty::Slice(..) | ty::Str => {}

compiler/rustc_hir_analysis/src/check/check.rs

@@ -34,6 +34,8 @@ use tracing::{debug, instrument};
 use ty::TypingMode;
 use {rustc_attr_parsing as attr, rustc_hir as hir};
 
+use crate::traits::ObligationCause;
+
 use super::compare_impl_item::check_type_bounds;
 use super::*;
 
@@ -969,6 +971,7 @@ fn check_impl_items_against_trait<'tcx>(
                 })
             },
             || (),
+            ObligationCause::dummy()
         )
         .kind()
     {

compiler/rustc_hir_typeck/src/expectation.rs

@@ -4,6 +4,8 @@ use rustc_span::Span;
 use super::Expectation::*;
 use super::FnCtxt;
 
+use rustc_infer::traits::ObligationCause;
+
 /// When type-checking an expression, we propagate downward
 /// whatever type hint we are able in the form of an `Expectation`.
 #[derive(Copy, Clone, Debug)]
@@ -75,7 +77,8 @@ impl<'a, 'tcx> Expectation<'tcx> {
     /// for examples of where this comes up,.
     pub(super) fn rvalue_hint(fcx: &FnCtxt<'a, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
         // FIXME: This is not right, even in the old solver...
-        match fcx.tcx.struct_tail_raw(ty, |ty| ty, || {}).kind() {
+        match fcx.tcx.struct_tail_raw(ty, |ty| ty, || {}, ObligationCause::dummy()).kind()
+        {
             ty::Slice(_) | ty::Str | ty::Dynamic(..) => ExpectRvalueLikeUnsized(ty),
             _ => ExpectHasType(ty),
         }

compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs

@@ -38,6 +38,7 @@ use rustc_trait_selection::traits::{
 };
 use tracing::{debug, instrument};
 
+use rustc_infer::traits::ObligationCause;
 use crate::callee::{self, DeferredCallResolution};
 use crate::errors::{self, CtorIsPrivate};
 use crate::method::{self, MethodCallee};
@@ -429,17 +430,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
     pub(crate) fn require_type_has_static_alignment(&self, ty: Ty<'tcx>, span: Span) {
         if !ty.references_error() {
-            let tail = self.tcx.struct_tail_raw(
-                ty,
-                |ty| {
-                    if self.next_trait_solver() {
-                        self.try_structurally_resolve_type(span, ty)
-                    } else {
-                        self.normalize(span, ty)
-                    }
-                },
-                || {},
-            );
+            let tail = self.tcx.struct_tail_raw(ty, |ty| {
+                if self.next_trait_solver() {
+                    self.try_structurally_resolve_type(span, ty)
+                } else {
+                    self.normalize(span, ty)
+                }
+            }, || {}, ObligationCause::dummy());
             // Sized types have static alignment, and so do slices.
             if tail.is_trivially_sized(self.tcx) || matches!(tail.kind(), ty::Slice(..)) {
                 // Nothing else is required here.

compiler/rustc_middle/src/error.rs

@@ -71,6 +71,8 @@ pub enum TypeMismatchReason {
 #[diag(middle_recursion_limit_reached)]
 #[help]
 pub(crate) struct RecursionLimitReached<'tcx> {
+    #[primary_span]
+    pub span: Span,
     pub ty: Ty<'tcx>,
     pub suggested_limit: rustc_session::Limit,
 }

compiler/rustc_middle/src/ty/layout.rs

@@ -22,6 +22,7 @@ use rustc_target::spec::{
 use tracing::debug;
 use {rustc_abi as abi, rustc_hir as hir};
 
+use crate::traits::ObligationCause;
 use crate::middle::codegen_fn_attrs::CodegenFnAttrFlags;
 use crate::query::TyCtxtAt;
 use crate::ty::normalize_erasing_regions::NormalizationError;
@@ -398,6 +399,7 @@ impl<'tcx> SizeSkeleton<'tcx> {
                         ),
                     },
                     || {},
+                    ObligationCause::dummy(),
                 );
 
                 match tail.kind() {

compiler/rustc_middle/src/ty/sty.rs

@@ -23,6 +23,7 @@ use ty::util::{AsyncDropGlueMorphology, IntTypeExt};
 
 use super::GenericParamDefKind;
 use crate::infer::canonical::Canonical;
+use crate::traits::ObligationCause;
 use crate::ty::InferTy::*;
 use crate::ty::{
     self, AdtDef, BoundRegionKind, Discr, GenericArg, GenericArgs, GenericArgsRef, List, ParamEnv,
@@ -1702,7 +1703,12 @@ impl<'tcx> Ty<'tcx> {
         tcx: TyCtxt<'tcx>,
         normalize: impl FnMut(Ty<'tcx>) -> Ty<'tcx>,
     ) -> Result<Ty<'tcx>, Ty<'tcx>> {
-        let tail = tcx.struct_tail_raw(self, normalize, || {});
+        let tail = tcx.struct_tail_raw(
+            self,
+            normalize,
+            || {},
+            ObligationCause::dummy(),
+        );
         match tail.kind() {
             // Sized types
             ty::Infer(ty::IntVar(_) | ty::FloatVar(_))

compiler/rustc_middle/src/ty/util.rs

@@ -21,6 +21,7 @@ use tracing::{debug, instrument};
 
 use super::TypingEnv;
 use crate::middle::codegen_fn_attrs::CodegenFnAttrFlags;
+use crate::traits::ObligationCause;
 use crate::mir;
 use crate::query::Providers;
 use crate::ty::fold::fold_regions;
@@ -217,7 +218,12 @@ impl<'tcx> TyCtxt<'tcx> {
         typing_env: ty::TypingEnv<'tcx>,
     ) -> Ty<'tcx> {
         let tcx = self;
-        tcx.struct_tail_raw(ty, |ty| tcx.normalize_erasing_regions(typing_env, ty), || {})
+        tcx.struct_tail_raw(
+            ty,
+            |ty| tcx.normalize_erasing_regions(typing_env, ty),
+            || {}, // ✅ Closure goes **before** ObligationCause
+            ObligationCause::dummy(), // ✅ ObligationCause is **last**
+        )
     }
 
     /// Returns true if a type has metadata.
@@ -250,23 +256,27 @@ impl<'tcx> TyCtxt<'tcx> {
         self,
         mut ty: Ty<'tcx>,
         mut normalize: impl FnMut(Ty<'tcx>) -> Ty<'tcx>,
-        // This is currently used to allow us to walk a ValTree
-        // in lockstep with the type in order to get the ValTree branch that
-        // corresponds to an unsized field.
         mut f: impl FnMut() -> (),
+        obligation_cause: ObligationCause<'tcx>,
     ) -> Ty<'tcx> {
         let recursion_limit = self.recursion_limit();
+
         for iteration in 0.. {
             if !recursion_limit.value_within_limit(iteration) {
                 let suggested_limit = match recursion_limit {
                     Limit(0) => Limit(2),
                     limit => limit * 2,
                 };
-                let reported = self
-                    .dcx()
-                    .emit_err(crate::error::RecursionLimitReached { ty, suggested_limit });
+
+                let reported = self.dcx().emit_err(crate::error::RecursionLimitReached {
+                    ty,
+                    suggested_limit,
+                    span: obligation_cause.span,
+                });
+
                 return Ty::new_error(self, reported);
             }
+
             match *ty.kind() {
                 ty::Adt(def, args) => {
                     if !def.is_struct() {
@@ -302,14 +312,14 @@ impl<'tcx> TyCtxt<'tcx> {
                     }
                 }
 
-                _ => {
-                    break;
-                }
+                _ => break,
             }
         }
+
         ty
     }
 
+
     /// Same as applying `struct_tail` on `source` and `target`, but only
     /// keeps going as long as the two types are instances of the same
     /// structure definitions.

compiler/rustc_trait_selection/src/traits/project.rs

@@ -1106,20 +1106,20 @@ fn assemble_candidates_from_impls<'cx, 'tcx>(
                     let tail = selcx.tcx().struct_tail_raw(
                         self_ty,
                         |ty| {
-                            // We throw away any obligations we get from this, since we normalize
-                            // and confirm these obligations once again during confirmation
                             normalize_with_depth(
                                 selcx,
                                 obligation.param_env,
                                 obligation.cause.clone(),
                                 obligation.recursion_depth + 1,
                                 ty,
                             )
-                            .value
+                                .value
                         },
-                        || {},
+                        || {}, // ✅ Move closure before ObligationCause
+                        obligation.cause.clone(), // ✅ ObligationCause must be last
                     );
 
+
                     match tail.kind() {
                         ty::Bool
                         | ty::Char

compiler/rustc_ty_utils/src/layout.rs

@@ -22,6 +22,7 @@ use rustc_span::{Symbol, sym};
 use tracing::{debug, instrument};
 use {rustc_abi as abi, rustc_hir as hir};
 
+use rustc_infer::traits::ObligationCause;
 use crate::errors::{NonPrimitiveSimdType, OversizedSimdType, ZeroLengthSimdType};
 
 mod invariant;
@@ -318,7 +319,7 @@ fn layout_of_uncached<'tcx>(
                             // error.
                             match tcx.try_normalize_erasing_regions(
                                 cx.typing_env,
-                                tcx.struct_tail_raw(pointee, |ty| ty, || {}),
+                                tcx.struct_tail_raw(pointee, |ty| ty, || {}, ObligationCause::dummy()),
                             ) {
                                 Ok(_) => {}
                                 Err(better_err) => {