new stuff

Author: BoxyUwU

compiler/rustc_borrowck/src/constraints/mod.rs

@@ -96,8 +96,8 @@ impl<'tcx> fmt::Debug for OutlivesConstraint<'tcx> {
     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(
             formatter,
-            "({:?}: {:?}) due to {:?} ({:?}) ({:?})",
-            self.sup, self.sub, self.locations, self.variance_info, self.category,
+            "({:?}: {:?}) due to {:?} ({:?}) ({:?}) (span: {:?})",
+            self.sup, self.sub, self.locations, self.variance_info, self.category, self.span,
         )
     }
 }

compiler/rustc_borrowck/src/diagnostics/region_errors.rs

@@ -57,7 +57,8 @@ impl<'tcx> ConstraintDescription for ConstraintCategory<'tcx> {
             ConstraintCategory::OpaqueType => "opaque type ",
             ConstraintCategory::ClosureUpvar(_) => "closure capture ",
             ConstraintCategory::Usage => "this usage ",
-            ConstraintCategory::Predicate(_)
+            ConstraintCategory::SolverRegionConstraint(_)
+            | ConstraintCategory::Predicate(_)
             | ConstraintCategory::Boring
             | ConstraintCategory::BoringNoLocation
             | ConstraintCategory::Internal
@@ -473,6 +474,14 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
         let errci = ErrorConstraintInfo { fr, outlived_fr, category, span: cause.span };
 
         let mut diag = match (category, fr_is_local, outlived_fr_is_local) {
+            (ConstraintCategory::SolverRegionConstraint(span), _, _) => {
+                let mut d = self.dcx().struct_span_err(
+                    span,
+                    "unsatisfied lifetime constraint from -Zassumptions-on-binders :3",
+                );
+                d.note("meoow :c");
+                d
+            }
             (ConstraintCategory::Return(kind), true, false) if self.is_closure_fn_mut(fr) => {
                 self.report_fnmut_error(&errci, kind)
             }

compiler/rustc_borrowck/src/region_infer/mod.rs

@@ -1798,6 +1798,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
                 // the `'region: 'static` constraints introduced by placeholder outlives.
                 ConstraintCategory::Internal => 7,
                 ConstraintCategory::OutlivesUnnameablePlaceholder(_) => 8,
+                ConstraintCategory::SolverRegionConstraint(_) => 9,
             };
 
             debug!("constraint {constraint:?} category: {category:?}, interest: {interest:?}");

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -187,6 +187,7 @@ pub(crate) fn type_check<'tcx>(
         &mut converter,
         typeck.known_type_outlives_obligations,
         universal_region_relations.outlives.clone(),
+        infcx.tcx.def_span(infcx.root_def_id),
     );
 
     // In case type check encountered an error region, we suppress unhelpful extra

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -197,7 +197,7 @@ where
 
     lint_redundant_lifetimes(tcx, body_def_id, &outlives_env);
 
-    let errors = infcx.resolve_regions_with_outlives_env(&outlives_env);
+    let errors = infcx.resolve_regions_with_outlives_env(&outlives_env, tcx.def_span(body_def_id));
     if errors.is_empty() {
         return Ok(());
     }
@@ -211,7 +211,8 @@ where
         // the implied bounds hack if this contains `bevy_ecs`'s `ParamSet` type.
         false,
     );
-    let errors_compat = infcx_compat.resolve_regions_with_outlives_env(&outlives_env);
+    let errors_compat =
+        infcx_compat.resolve_regions_with_outlives_env(&outlives_env, tcx.def_span(body_def_id));
     if errors_compat.is_empty() {
         // FIXME: Once we fix bevy, this would be the place to insert a warning
         // to upgrade bevy.

compiler/rustc_infer/src/infer/at.rs

@@ -81,7 +81,9 @@ impl<'tcx> InferCtxt<'tcx> {
             reported_signature_mismatch: self.reported_signature_mismatch.clone(),
             tainted_by_errors: self.tainted_by_errors.clone(),
             universe: self.universe.clone(),
-            universe_assumptions_for_next_solver: self.universe_assumptions_for_next_solver.clone(),
+            placeholder_assumptions_for_next_solver: self
+                .placeholder_assumptions_for_next_solver
+                .clone(),
             next_trait_solver: self.next_trait_solver,
             obligation_inspector: self.obligation_inspector.clone(),
         }
@@ -107,7 +109,9 @@ impl<'tcx> InferCtxt<'tcx> {
             reported_signature_mismatch: self.reported_signature_mismatch.clone(),
             tainted_by_errors: self.tainted_by_errors.clone(),
             universe: self.universe.clone(),
-            universe_assumptions_for_next_solver: self.universe_assumptions_for_next_solver.clone(),
+            placeholder_assumptions_for_next_solver: self
+                .placeholder_assumptions_for_next_solver
+                .clone(),
             next_trait_solver: self.next_trait_solver,
             obligation_inspector: self.obligation_inspector.clone(),
         };

compiler/rustc_infer/src/infer/context.rs

@@ -30,8 +30,8 @@ impl<'tcx> rustc_type_ir::InferCtxtLike for InferCtxt<'tcx> {
         self.typing_mode_raw()
     }
 
-    fn higher_ranked_assumptions_v2(&self) -> bool {
-        self.tcx.sess.opts.unstable_opts.higher_ranked_assumptions_v2
+    fn assumptions_on_binders(&self) -> bool {
+        self.tcx.sess.opts.unstable_opts.assumptions_on_binders
     }
 
     fn universe(&self) -> ty::UniverseIndex {
@@ -42,27 +42,40 @@ impl<'tcx> rustc_type_ir::InferCtxtLike for InferCtxt<'tcx> {
         self.create_next_universe()
     }
 
-    fn insert_universe_assumptions(
+    fn insert_placeholder_assumptions(
         &self,
         u: ty::UniverseIndex,
         assumptions: Option<rustc_type_ir::region_constraint::Assumptions<TyCtxt<'tcx>>>,
     ) {
-        self.universe_assumptions_for_next_solver.borrow_mut().insert(u, assumptions);
+        self.placeholder_assumptions_for_next_solver.borrow_mut().insert(u, assumptions);
     }
 
-    fn get_universe_assumptions(
+    fn get_placeholder_assumptions(
         &self,
         u: ty::UniverseIndex,
     ) -> Option<rustc_type_ir::region_constraint::Assumptions<TyCtxt<'tcx>>> {
-        self.universe_assumptions_for_next_solver.borrow().get(&u).unwrap().as_ref().cloned()
+        self.placeholder_assumptions_for_next_solver.borrow().get(&u).unwrap().as_ref().cloned()
     }
 
-    fn get_solve_region_constraint(
+    fn get_solver_region_constraint(
         &self,
     ) -> rustc_type_ir::region_constraint::RegionConstraint<TyCtxt<'tcx>> {
         self.inner.borrow().solver_region_constraint_storage.get_constraint()
     }
 
+    fn overwrite_solver_region_constraint(
+        &self,
+        constraint: rustc_type_ir::region_constraint::RegionConstraint<TyCtxt<'tcx>>,
+    ) {
+        let mut inner = self.inner.borrow_mut();
+        use rustc_data_structures::undo_log::UndoLogs;
+
+        use crate::infer::UndoLog;
+        let old_constraint = inner.solver_region_constraint_storage.get_constraint();
+        inner.undo_log.push(UndoLog::OverwriteSolverRegionConstraint { old_constraint });
+        inner.solver_region_constraint_storage.overwrite_solver_region_constraint(constraint);
+    }
+
     fn universe_of_ty(&self, vid: ty::TyVid) -> Option<ty::UniverseIndex> {
         match self.try_resolve_ty_var(vid) {
             Err(universe) => Some(universe),

compiler/rustc_infer/src/infer/mod.rs

@@ -322,7 +322,10 @@ pub struct InferCtxt<'tcx> {
     /// List of assumed wellformed types which we can derive implied
     /// bounds on a `for<...>` from. Only used unstabley and by the
     /// new solver.
-    universe_assumptions_for_next_solver: RefCell<
+    //
+    // FIXME(-Zassumptions-on-binders): This and `universe` should probably be
+    // in `InferCtxtInner` so they can participate in rollbacks and whatnot
+    placeholder_assumptions_for_next_solver: RefCell<
         FxIndexMap<
             ty::UniverseIndex,
             Option<rustc_type_ir::region_constraint::Assumptions<TyCtxt<'tcx>>>,
@@ -440,6 +443,10 @@ pub enum SubregionOrigin<'tcx> {
     },
 
     AscribeUserTypeProvePredicate(Span),
+
+    // FIXME(-Zassumptions-on-binders): this is a temporary hack until we support
+    // proper diagnostics for solver region constraints.
+    SolverRegionConstraint(Span),
 }
 
 // `SubregionOrigin` is used a lot. Make sure it doesn't unintentionally get bigger.
@@ -451,6 +458,7 @@ impl<'tcx> SubregionOrigin<'tcx> {
         match self {
             Self::Subtype(type_trace) => type_trace.cause.to_constraint_category(),
             Self::AscribeUserTypeProvePredicate(span) => ConstraintCategory::Predicate(*span),
+            Self::SolverRegionConstraint(span) => ConstraintCategory::SolverRegionConstraint(*span),
             _ => ConstraintCategory::BoringNoLocation,
         }
     }
@@ -650,7 +658,7 @@ impl<'tcx> InferCtxtBuilder<'tcx> {
             reported_signature_mismatch: Default::default(),
             tainted_by_errors: Cell::new(None),
             universe: Cell::new(ty::UniverseIndex::ROOT),
-            universe_assumptions_for_next_solver: RefCell::new(Default::default()),
+            placeholder_assumptions_for_next_solver: RefCell::new(Default::default()),
             next_trait_solver,
             obligation_inspector: Cell::new(None),
         }
@@ -1705,6 +1713,7 @@ impl<'tcx> SubregionOrigin<'tcx> {
             SubregionOrigin::CompareImplItemObligation { span, .. } => span,
             SubregionOrigin::AscribeUserTypeProvePredicate(span) => span,
             SubregionOrigin::CheckAssociatedTypeBounds { ref parent, .. } => parent.span(),
+            SubregionOrigin::SolverRegionConstraint(a) => a,
         }
     }
 
@@ -1836,4 +1845,13 @@ impl<'tcx> SolverRegionConstraintStorage<'tcx> {
             _ => unreachable!(),
         }
     }
+
+    #[instrument(level = "debug", skip(self))]
+    fn overwrite_solver_region_constraint(&mut self, constraint: SolverRegionConstraint<'tcx>) {
+        if !constraint.is_and() {
+            self.0 = SolverRegionConstraint::And(vec![constraint].into_boxed_slice())
+        } else {
+            self.0 = constraint;
+        }
+    }
 }

compiler/rustc_infer/src/infer/outlives/mod.rs

@@ -5,6 +5,7 @@ use std::iter;
 use rustc_data_structures::undo_log::UndoLogs;
 use rustc_middle::traits::query::{NoSolution, OutlivesBound};
 use rustc_middle::ty;
+use rustc_span::Span;
 use tracing::instrument;
 
 use self::env::OutlivesEnvironment;
@@ -49,8 +50,9 @@ impl<'tcx> InferCtxt<'tcx> {
             ty::PolyTypeOutlivesPredicate<'tcx>,
             SubregionOrigin<'tcx>,
         ) -> Result<ty::PolyTypeOutlivesPredicate<'tcx>, NoSolution>,
+        span: Span,
     ) -> Vec<RegionResolutionError<'tcx>> {
-        match self.process_registered_region_obligations(outlives_env, deeply_normalize_ty) {
+        match self.process_registered_region_obligations(outlives_env, deeply_normalize_ty, span) {
             Ok(()) => {}
             Err((clause, origin)) => {
                 return vec![RegionResolutionError::CannotNormalize(clause, origin)];

compiler/rustc_infer/src/infer/outlives/obligations.rs

@@ -69,7 +69,7 @@ use rustc_middle::ty::{
     self, GenericArgKind, GenericArgsRef, PolyTypeOutlivesPredicate, Region, RegionVid, Ty, TyCtxt,
     TypeFoldable as _, TypeVisitableExt,
 };
-use rustc_span::DUMMY_SP;
+use rustc_span::Span;
 use smallvec::smallvec;
 use tracing::{debug, instrument};
 
@@ -147,7 +147,7 @@ impl<'tcx> InferCtxt<'tcx> {
         sub_region: Region<'tcx>,
         cause: &ObligationCause<'tcx>,
     ) {
-        assert!(!self.tcx.sess.opts.unstable_opts.higher_ranked_assumptions_v2);
+        assert!(!self.tcx.sess.opts.unstable_opts.assumptions_on_binders);
 
         // `is_global` means the type has no params, infer, placeholder, or non-`'static`
         // free regions. If the type has none of these things, then we can skip registering
@@ -206,12 +206,13 @@ impl<'tcx> InferCtxt<'tcx> {
     pub fn destructure_solver_region_constraints_for_regionck(
         &self,
         outlives_env: &OutlivesEnvironment<'tcx>,
+        span: Span,
     ) {
         let assumptions = rustc_type_ir::region_constraint::Assumptions::new(
             outlives_env.known_type_outlives().into_iter().cloned().collect(),
             outlives_env.free_region_map().relation.clone(),
         );
-        self.destructure_solve_region_constraints(assumptions, self);
+        self.destructure_solver_region_constraints(assumptions, self, span);
     }
 
     pub fn destructure_solver_region_constraints_for_borrowck(
@@ -220,38 +221,38 @@ impl<'tcx> InferCtxt<'tcx> {
         conversion: impl TypeOutlivesDelegate<'tcx>,
         known_type_outlives: &[PolyTypeOutlivesPredicate<'tcx>],
         region_outlives: TransitiveRelation<RegionVid>,
+        span: Span,
     ) {
         let assumptions = rustc_type_ir::region_constraint::Assumptions::new(
             known_type_outlives.into_iter().cloned().collect(),
             region_outlives.maybe_map(|r| Some(Region::new_var(self.tcx, r))).unwrap(),
         );
-        self.destructure_solve_region_constraints(assumptions, conversion);
+        self.destructure_solver_region_constraints(assumptions, conversion, span);
     }
 
     #[instrument(level = "debug", skip(self, conversion))]
-    pub fn destructure_solve_region_constraints(
+    pub fn destructure_solver_region_constraints(
         &self,
         assumptions: rustc_type_ir::region_constraint::Assumptions<TyCtxt<'tcx>>,
         mut conversion: impl TypeOutlivesDelegate<'tcx>,
+        span: Span,
     ) {
-        if !self.tcx.sess.opts.unstable_opts.higher_ranked_assumptions_v2 {
+        if !self.tcx.sess.opts.unstable_opts.assumptions_on_binders {
             return;
         }
 
         assert!(self.next_trait_solver());
 
-        // FIXME(-Zhigher-ranked-assumptions-v2): Implement diagnostics
-        let origin = SubregionOrigin::Reborrow(DUMMY_SP);
+        let origin = SubregionOrigin::SolverRegionConstraint(span);
         let category = origin.to_constraint_category();
 
         let constraint = self.inner.borrow().solver_region_constraint_storage.get_constraint();
         debug!(?constraint);
         let constraint =
-            rustc_type_ir::region_constraint::destructure_type_outlives_constraints_in_universe(
+            rustc_type_ir::region_constraint::destructure_type_outlives_constraints_in_root(
                 self,
                 constraint,
-                None,
-                &Some(assumptions),
+                &assumptions,
             );
         debug!(?constraint);
         let constraint = rustc_type_ir::region_constraint::evaluate_solver_constraint(&constraint);
@@ -274,9 +275,9 @@ impl<'tcx> InferCtxt<'tcx> {
                         category,
                     );
                 }
-                // FIXME(-Zhigher-ranked-assumptions-v2): actually implement OR as an  OR
+                // FIXME(-Zassumptions-on-binders): actually implement OR as an  OR
                 And(nested) | Or(nested) => constraints.extend(nested),
-                AliasTyOutlivesFromEnv(..) => unreachable!(),
+                AliasTyOutlivesViaEnv(..) => unreachable!(),
                 PlaceholderTyOutlives(..) => unreachable!(),
             }
         }
@@ -300,10 +301,11 @@ impl<'tcx> InferCtxt<'tcx> {
             SubregionOrigin<'tcx>,
         )
             -> Result<PolyTypeOutlivesPredicate<'tcx>, NoSolution>,
+        span: Span,
     ) -> Result<(), (PolyTypeOutlivesPredicate<'tcx>, SubregionOrigin<'tcx>)> {
         assert!(!self.in_snapshot(), "cannot process registered region obligations in a snapshot");
 
-        self.destructure_solver_region_constraints_for_regionck(outlives_env);
+        self.destructure_solver_region_constraints_for_regionck(outlives_env, span);
 
         // Must loop since the process of normalizing may itself register region obligations.
         for iteration in 0.. {