Auto merge of #164974 - JonathanBrouwer:rollup-zHkdUDx, r=<try>

Rollup of 8 pull requests


try-job: dist-various-1
try-job: test-various
try-job: test-x86_64-gnu-aux
try-job: test-x86_64-msvc-1
try-job: test-aarch64-apple-1
try-job: test-aarch64-apple-2
try-job: test-x86_64-mingw-1
try-job: test-i686-msvc
try-job: test-armhf-gnu
try-job: test-x86_64-gnu-llvm-22-3

Author: bors

compiler/rustc_errors/src/emitter.rs

@@ -365,7 +365,7 @@ pub trait Emitter {
         let Some(source_map) = self.source_map() else { return };
         let should_hide = |span| {
             source_map.is_imported(span) || {
-                let expn = span.data().ctxt.outer_expn_data();
+                let expn = span.ctxt().outer_expn_data();
                 expn.diagnostic_opaque && matches!(expn.kind, ExpnKind::Macro(MacroKind::Bang, _))
             }
         };

compiler/rustc_expand/src/proc_macro_server.rs

@@ -527,24 +527,24 @@ impl server::Server for Rustc<'_, '_> {
         .map_err(|_| String::from("failed to parse to literal"))?
         .map_err(cancel_diags_into_string)?;
 
-        let first_span = parser.token.span.data();
+        let (first_span_lo, first_span_hi) = parser.token.span.lo_hi();
         let minus_present = parser.eat(exp!(Minus));
 
-        let lit_span = parser.token.span.data();
+        let (lit_span_lo, lit_span_hi) = parser.token.span.lo_hi();
         let tk::Literal(mut lit) = parser.token.kind else {
             return Err("not a literal".to_string());
         };
 
         // Check no comment or whitespace surrounding the (possibly negative)
         // literal, or more tokens after it.
-        if (lit_span.hi.0 - first_span.lo.0) as usize != s.len() {
+        if (lit_span_hi.0 - first_span_lo.0) as usize != s.len() {
             return Err("comment or whitespace around literal".to_string());
         }
 
         if minus_present {
             // If minus is present, check no comment or whitespace in between it
             // and the literal token.
-            if first_span.hi.0 != lit_span.lo.0 {
+            if first_span_hi.0 != lit_span_lo.0 {
                 return Err("comment or whitespace after minus".to_string());
             }
 

compiler/rustc_infer/src/infer/at.rs

@@ -171,7 +171,7 @@ impl<'tcx> InferCtxt<'tcx> {
     /// If possible, prefer the wrapper methods on `ObligationCtxt`,
     /// `FnCtxt`, or `TypeChecker`.
     pub fn sub_raw<T>(
-        self,
+        &self,
         cause: &ObligationCause<'tcx>,
         param_env: ParamEnv<'tcx>,
         define_opaque_types: DefineOpaqueTypes,
@@ -181,7 +181,20 @@ impl<'tcx> InferCtxt<'tcx> {
     where
         T: ToTrace<'tcx>,
     {
-        self.at(cause, param_env).sub(define_opaque_types, expected, actual)
+        if self.next_trait_solver {
+            NextSolverRelate::relate(self, param_env, expected, ty::Covariant, actual, cause.span)
+                .map(|goals| self.goals_to_obligations(cause, goals))
+        } else {
+            let mut op = TypeRelating::new(
+                self,
+                ToTrace::to_trace(cause, expected, actual),
+                param_env,
+                define_opaque_types,
+                ty::Covariant,
+            );
+            op.relate(expected, actual)?;
+            Ok(InferOk { value: (), obligations: op.into_obligations() })
+        }
     }
 
     /// Makes `expected == actual`.
@@ -288,41 +301,6 @@ pub trait ToTrace<'tcx>: Relate<TyCtxt<'tcx>> + Copy {
 }
 
 impl<'a, 'tcx> At<'a, 'tcx> {
-    /// Makes `expected <: actual`.
-    ///
-    /// FIXME: To be removed in favor of the [`InferCtxt::sub_raw`] method instead.
-    pub fn sub<T>(
-        self,
-        define_opaque_types: DefineOpaqueTypes,
-        expected: T,
-        actual: T,
-    ) -> InferResult<'tcx, ()>
-    where
-        T: ToTrace<'tcx>,
-    {
-        if self.infcx.next_trait_solver {
-            NextSolverRelate::relate(
-                self.infcx,
-                self.param_env,
-                expected,
-                ty::Covariant,
-                actual,
-                self.cause.span,
-            )
-            .map(|goals| self.goals_to_obligations(goals))
-        } else {
-            let mut op = TypeRelating::new(
-                self.infcx,
-                ToTrace::to_trace(self.cause, expected, actual),
-                self.param_env,
-                define_opaque_types,
-                ty::Covariant,
-            );
-            op.relate(expected, actual)?;
-            Ok(InferOk { value: (), obligations: op.into_obligations() })
-        }
-    }
-
     /// Makes `expected == actual`.
     ///
     /// FIXME: To be removed in favor of the [`InferCtxt::eq_raw`] method instead.
@@ -391,7 +369,13 @@ impl<'a, 'tcx> At<'a, 'tcx> {
         T: ToTrace<'tcx>,
     {
         match variance {
-            ty::Covariant => self.sub(define_opaque_types, expected, actual),
+            ty::Covariant => self.infcx.sub_raw(
+                self.cause,
+                self.param_env,
+                define_opaque_types,
+                expected,
+                actual,
+            ),
             ty::Invariant => self.eq(define_opaque_types, expected, actual),
             ty::Contravariant => self.infcx.sup_raw(
                 self.cause,

compiler/rustc_infer/src/infer/mod.rs

@@ -883,7 +883,7 @@ impl<'tcx> InferCtxt<'tcx> {
 
         self.enter_forall(predicate, |ty::SubtypePredicate { a_is_expected, a, b }| {
             if a_is_expected {
-                Ok(self.at(cause, param_env).sub(DefineOpaqueTypes::Yes, a, b))
+                Ok(self.sub_raw(cause, param_env, DefineOpaqueTypes::Yes, a, b))
             } else {
                 Ok(self.sup_raw(cause, param_env, DefineOpaqueTypes::Yes, b, a))
             }

compiler/rustc_infer/src/infer/relate/lattice.rs

@@ -255,15 +255,30 @@ impl<'infcx, 'tcx> LatticeOp<'infcx, 'tcx> {
     // relates `v` to `a` first, which may help us to avoid unnecessary
     // type variable obligations. See caller for details.
     fn relate_bound(&mut self, v: Ty<'tcx>, a: Ty<'tcx>, b: Ty<'tcx>) -> RelateResult<'tcx, ()> {
-        let at = self.infcx.at(&self.trace.cause, self.param_env);
         match self.kind {
             LatticeOpKind::Glb => {
-                self.obligations.extend(at.sub(DefineOpaqueTypes::Yes, v, a)?.into_obligations());
-                self.obligations.extend(at.sub(DefineOpaqueTypes::Yes, v, b)?.into_obligations());
+                self.obligations.extend(
+                    self.infcx
+                        .sub_raw(&self.trace.cause, self.param_env, DefineOpaqueTypes::Yes, v, a)?
+                        .into_obligations(),
+                );
+                self.obligations.extend(
+                    self.infcx
+                        .sub_raw(&self.trace.cause, self.param_env, DefineOpaqueTypes::Yes, v, b)?
+                        .into_obligations(),
+                );
             }
             LatticeOpKind::Lub => {
-                self.obligations.extend(at.sub(DefineOpaqueTypes::Yes, a, v)?.into_obligations());
-                self.obligations.extend(at.sub(DefineOpaqueTypes::Yes, b, v)?.into_obligations());
+                self.obligations.extend(
+                    self.infcx
+                        .sub_raw(&self.trace.cause, self.param_env, DefineOpaqueTypes::Yes, a, v)?
+                        .into_obligations(),
+                );
+                self.obligations.extend(
+                    self.infcx
+                        .sub_raw(&self.trace.cause, self.param_env, DefineOpaqueTypes::Yes, b, v)?
+                        .into_obligations(),
+                );
             }
         }
         Ok(())

compiler/rustc_interface/src/callbacks.rs

@@ -30,7 +30,7 @@ fn track_span_parent(def_id: rustc_span::def_id::LocalDefId) {
             if tracks_deps {
                 let _span = icx.tcx.source_span(def_id);
                 // Sanity check: relative span's parent must be an absolute span.
-                debug_assert_eq!(_span.data_untracked().parent, None);
+                debug_assert_eq!(_span.parent(), None);
             }
         }
     })

compiler/rustc_mir_transform/src/remove_noop_landing_pads.rs

@@ -172,15 +172,9 @@ fn find_noop_landing_pads<'tcx>(
 
     // This is a post-order traversal, so that if A post-dominates B
     // then A will be visited before B.
-    let postorder: Vec<_> = traversal::postorder(body).map(|(bb, _)| bb).collect();
-    for bb in postorder {
-        let is_nop_landing_pad = RemoveNoopLandingPads.is_nop_landing_pad(
-            tcx,
-            &body.basic_blocks[bb],
-            body,
-            &nop_landing_pads,
-            extra,
-        );
+    for (bb, bb_data) in traversal::postorder(body) {
+        let is_nop_landing_pad =
+            RemoveNoopLandingPads.is_nop_landing_pad(tcx, bb_data, body, &nop_landing_pads, extra);
         if is_nop_landing_pad {
             nop_landing_pads.insert(bb);
         }

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

@@ -7,7 +7,7 @@ use rustc_type_ir::outlives::{Component, push_outlives_components};
 #[cfg(not(feature = "nightly"))]
 use rustc_type_ir::region_constraint::TransitiveRelationBuilder;
 use rustc_type_ir::region_constraint::{
-    And, Assumptions, LeafRegionConstraint, Or, eagerly_handle_placeholders_in_universe,
+    And, Assumptions, LeafRegionConstraint, NoSpan, Or, eagerly_handle_placeholders_in_universe,
 };
 use rustc_type_ir::{
     AliasTy, Binder, ClauseKind, Const, InferCtxtLike, Interner, Region, TypeVisitable,
@@ -168,9 +168,9 @@ where
         use Component::*;
         use LeafRegionConstraint::*;
         match c {
-            Region(c_r) => Or::new_leaf(RegionOutlives(*c_r, r, ())),
+            Region(c_r) => Or::new_leaf(RegionOutlives(*c_r, r, NoSpan)),
             Placeholder(p) => {
-                Or::new_leaf(PlaceholderTyOutlives(Ty::new_placeholder(self.cx(), *p), r, ()))
+                Or::new_leaf(PlaceholderTyOutlives(Ty::new_placeholder(self.cx(), *p), r, NoSpan))
             }
             Alias(_, alias) => self.destructure_alias_outlives(*alias, r),
             UnresolvedInferenceVariable(_) => {
@@ -194,11 +194,11 @@ where
 
         let item_bounds =
             rustc_type_ir::outlives::declared_bounds_from_definition(self.cx(), alias)
-                .map(|bound| And::new([RegionOutlives(bound, r, ())]));
+                .map(|bound| And::new([RegionOutlives(bound, r, NoSpan)]));
         let item_bound_outlives = Or::new(item_bounds);
 
         let where_clause_outlives =
-            Or::new_leaf(AliasTyOutlivesViaEnv(Binder::dummy((alias, r)), ()));
+            Or::new_leaf(AliasTyOutlivesViaEnv(Binder::dummy((alias, r)), NoSpan));
 
         let mut components = Default::default();
         rustc_type_ir::outlives::compute_alias_components_recursive(

compiler/rustc_next_trait_solver/src/solve/mod.rs

@@ -155,10 +155,12 @@ where
         let ty::OutlivesClause(a, b) = goal.predicate;
 
         if self.cx().assumptions_on_binders() {
-            use rustc_type_ir::region_constraint::{LeafRegionConstraint, RegionConstraint};
+            use rustc_type_ir::region_constraint::{
+                LeafRegionConstraint, NoSpan, RegionConstraint,
+            };
 
             let constraint =
-                RegionConstraint::new_leaf(LeafRegionConstraint::RegionOutlives(a, b, ()));
+                RegionConstraint::new_leaf(LeafRegionConstraint::RegionOutlives(a, b, NoSpan));
             self.register_solver_region_constraint(constraint);
         } else {
             self.register_region_outlives(a, b, VisibleForLeakCheck::Yes);

compiler/rustc_parse/src/parser/expr.rs

@@ -2370,7 +2370,7 @@ impl<'a> Parser<'a> {
             let move_kw_span = self.prev_token.span;
             // Check for `move async` and recover
             if self.check_keyword(exp!(Async)) {
-                let move_async_span = self.token.span.with_lo(self.prev_token.span.data().lo);
+                let move_async_span = self.token.span.with_lo(self.prev_token.span.lo());
                 Err(self.dcx().create_err(crate::diagnostics::AsyncMoveOrderIncorrect {
                     span: move_async_span,
                 }))
@@ -2382,7 +2382,7 @@ impl<'a> Parser<'a> {
             self.psess.gated_spans.gate(sym::ergonomic_clones, use_kw_span);
             // Check for `use async` and recover
             if self.check_keyword(exp!(Async)) {
-                let use_async_span = self.token.span.with_lo(self.prev_token.span.data().lo);
+                let use_async_span = self.token.span.with_lo(self.prev_token.span.lo());
                 Err(self.dcx().create_err(crate::diagnostics::AsyncUseOrderIncorrect {
                     span: use_async_span,
                 }))