more

Author: BoxyUwU

src/tools/clippy/clippy_lints/src/future_not_send.rs

@@ -90,7 +90,7 @@ impl<'tcx> LateLintPass<'tcx> for FutureNotSend {
             let ocx = ObligationCtxt::new_with_diagnostics(&infcx);
             let cause = traits::ObligationCause::misc(span, fn_def_id);
             ocx.register_bound(cause, cx.param_env, ret_ty, send_trait);
-            let send_errors = ocx.select_all_or_error();
+            let send_errors = ocx.evaluate_registered_obligations_or_error();
 
             // Allow errors that try to prove `Send` for types that "mention" a generic parameter at the "top
             // level".

src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs

@@ -475,7 +475,7 @@ fn is_ty_const_destruct<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, body: &Body<'tcx>
 
         let ocx = ObligationCtxt::new(&infcx);
         ocx.register_obligations(impl_src.nested_obligations());
-        ocx.select_all_or_error().is_empty()
+        ocx.evaluate_registered_obligations_or_error().is_empty()
     }
 
     !ty.needs_drop(tcx, ConstCx::new(tcx, body).typing_env)

src/tools/rust-analyzer/crates/hir-ty/src/autoderef.rs

@@ -304,7 +304,7 @@ fn structurally_normalize_ty<'db>(
         // evaluate/fulfill mismatches, but that's not a reason for an ICE.
         return None;
     };
-    let errors = ocx.select_where_possible();
+    let errors = ocx.try_evaluate_registered_obligations();
     if !errors.is_empty() {
         unreachable!();
     }

src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs

@@ -160,7 +160,7 @@ impl<'a, 'b, 'db> Coerce<'a, 'b, 'db> {
                 Ok(InferOk { value, obligations }) => {
                     let mut ocx = ObligationCtxt::new(this.infer_ctxt());
                     ocx.register_obligations(obligations);
-                    if ocx.select_where_possible().is_empty() {
+                    if ocx.try_evaluate_registered_obligations().is_empty() {
                         Ok(InferOk { value, obligations: ocx.into_pending_obligations() })
                     } else {
                         Err(TypeError::Mismatch)
@@ -744,7 +744,7 @@ impl<'a, 'b, 'db> Coerce<'a, 'b, 'db> {
                 Some(PredicateKind::AliasRelate(..)) => {
                     let mut ocx = ObligationCtxt::new(self.infer_ctxt());
                     ocx.register_obligation(obligation);
-                    if !ocx.select_where_possible().is_empty() {
+                    if !ocx.try_evaluate_registered_obligations().is_empty() {
                         return Err(TypeError::Mismatch);
                     }
                     coercion.obligations.extend(ocx.into_pending_obligations());
@@ -1116,7 +1116,7 @@ impl<'db> InferenceContext<'db> {
                             let mut ocx = ObligationCtxt::new(&table.infer_ctxt);
                             let value =
                                 ocx.lub(&ObligationCause::new(), table.param_env, prev_ty, new_ty)?;
-                            if ocx.select_where_possible().is_empty() {
+                            if ocx.try_evaluate_registered_obligations().is_empty() {
                                 Ok(InferOk { value, obligations: ocx.into_pending_obligations() })
                             } else {
                                 Err(TypeError::Mismatch)

src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs

@@ -2136,7 +2136,7 @@ impl<'db> InferenceContext<'db> {
                             expected_output.to_nextsolver(interner),
                             formal_output,
                         )?;
-                        if !ocx.select_where_possible().is_empty() {
+                        if !ocx.try_evaluate_registered_obligations().is_empty() {
                             return Err(crate::next_solver::TypeError::Mismatch);
                         }
 

src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs

@@ -938,7 +938,7 @@ impl<'db> InferenceTable<'db> {
     }
 
     pub(crate) fn select_obligations_where_possible(&mut self) {
-        self.fulfillment_cx.select_where_possible(&self.infer_ctxt);
+        self.fulfillment_cx.try_evaluate_registered_obligations(&self.infer_ctxt);
     }
 
     pub(super) fn register_predicate(

src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs

@@ -1772,7 +1772,7 @@ fn is_valid_trait_method_candidate(
                             ctxt.register_predicate_obligation(&table.infer_ctxt, pred);
                         }
                         // FIXME: Are we doing this correctly? Probably better to follow rustc more closely.
-                        check_that!(ctxt.select_where_possible(&table.infer_ctxt).is_empty());
+                        check_that!(ctxt.try_evaluate_registered_obligations(&table.infer_ctxt).is_empty());
                     }
 
                     check_that!(table.unify(receiver_ty, &expected_receiver));

src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill.rs

@@ -54,7 +54,7 @@ struct ObligationStorage<'db> {
     /// Obligations which resulted in an overflow in fulfillment itself.
     ///
     /// We cannot eagerly return these as error so we instead store them here
-    /// to avoid recomputing them each time `select_where_possible` is called.
+    /// to avoid recomputing them each time `try_evaluate_registered_obligations` is called.
     /// This also allows us to return the correct `FulfillmentError` for them.
     overflowed: Vec<PredicateObligation<'db>>,
     pending: PendingObligations<'db>,
@@ -95,7 +95,7 @@ impl<'db> ObligationStorage<'db> {
             // IMPORTANT: we must not use solve any inference variables in the obligations
             // as this is all happening inside of a probe. We use a probe to make sure
             // we get all obligations involved in the overflow. We pretty much check: if
-            // we were to do another step of `select_where_possible`, which goals would
+            // we were to do another step of `try_evaluate_registered_obligations`, which goals would
             // change.
             // FIXME: <https://github.com/Gankra/thin-vec/pull/66> is merged, this can be removed.
             self.overflowed.extend(
@@ -131,7 +131,7 @@ impl<'db> FulfillmentCtxt<'db> {
         infcx: &InferCtxt<'db>,
         obligation: PredicateObligation<'db>,
     ) {
-        // FIXME: See the comment in `select_where_possible()`.
+        // FIXME: See the comment in `try_evaluate_registered_obligations()`.
         // assert_eq!(self.usable_in_snapshot, infcx.num_open_snapshots());
         self.obligations.register(obligation, None);
     }
@@ -141,7 +141,7 @@ impl<'db> FulfillmentCtxt<'db> {
         infcx: &InferCtxt<'db>,
         obligations: impl IntoIterator<Item = PredicateObligation<'db>>,
     ) {
-        // FIXME: See the comment in `select_where_possible()`.
+        // FIXME: See the comment in `try_evaluate_registered_obligations()`.
         // assert_eq!(self.usable_in_snapshot, infcx.num_open_snapshots());
         obligations.into_iter().for_each(|obligation| self.obligations.register(obligation, None));
     }
@@ -158,7 +158,7 @@ impl<'db> FulfillmentCtxt<'db> {
             .collect()
     }
 
-    pub(crate) fn select_where_possible(
+    pub(crate) fn try_evaluate_registered_obligations(
         &mut self,
         infcx: &InferCtxt<'db>,
     ) -> Vec<NextSolverError<'db>> {
@@ -223,11 +223,11 @@ impl<'db> FulfillmentCtxt<'db> {
         errors
     }
 
-    pub(crate) fn select_all_or_error(
+    pub(crate) fn evaluate_registered_obligations_or_error(
         &mut self,
         infcx: &InferCtxt<'db>,
     ) -> Vec<NextSolverError<'db>> {
-        let errors = self.select_where_possible(infcx);
+        let errors = self.try_evaluate_registered_obligations(infcx);
         if !errors.is_empty() {
             return errors;
         }

src/tools/rust-analyzer/crates/hir-ty/src/next_solver/inspect.rs

@@ -92,7 +92,7 @@ impl<'db> NormalizesToTermHack<'db> {
         let mut ocx = ObligationCtxt::new(infcx);
         ocx.eq(&ObligationCause::dummy(), param_env, self.term, self.unconstrained_term)?;
         f(&mut ocx);
-        let errors = ocx.select_all_or_error();
+        let errors = ocx.evaluate_registered_obligations_or_error();
         if errors.is_empty() {
             Ok(Certainty::Yes)
         } else if errors.iter().all(|e| !matches!(e, NextSolverError::TrueError(_))) {

src/tools/rust-analyzer/crates/hir-ty/src/next_solver/normalize.rs

@@ -77,7 +77,7 @@ where
         stalled_coroutine_goals: vec![],
     };
     let value = value.try_fold_with(&mut folder)?;
-    let errors = folder.fulfill_cx.select_all_or_error(at.infcx);
+    let errors = folder.fulfill_cx.evaluate_registered_obligations_or_error(at.infcx);
     if errors.is_empty() { Ok((value, folder.stalled_coroutine_goals)) } else { Err(errors) }
 }
 
@@ -138,7 +138,7 @@ impl<'db> NormalizationFolder<'_, 'db> {
     fn select_all_and_stall_coroutine_predicates(
         &mut self,
     ) -> Result<(), Vec<NextSolverError<'db>>> {
-        let errors = self.fulfill_cx.select_where_possible(self.at.infcx);
+        let errors = self.fulfill_cx.try_evaluate_registered_obligations(self.at.infcx);
         if !errors.is_empty() {
             return Err(errors);
         }