a

Author: Markus Westerlind

compiler/rustc_trait_selection/src/traits/fulfill.rs

@@ -218,22 +218,16 @@ impl<'tcx> TraitEngine<'tcx> for FulfillmentContext<'tcx> {
         &mut self,
         infcx: &InferCtxt<'_, 'tcx>,
     ) -> Result<(), Vec<FulfillmentError<'tcx>>> {
-        let result = (|| {
-            self.select_where_possible(infcx)?;
-
-            let errors: Vec<_> = self
-                .predicates
-                .to_errors(CodeAmbiguity)
-                .into_iter()
-                .map(to_fulfillment_error)
-                .collect();
-
-            if errors.is_empty() { Ok(()) } else { Err(errors) }
-        })();
-        if let Some(offset) = self.predicates.take_watcher_offset() {
-            infcx.deregister_unify_watcher(offset);
-        }
-        result
+        self.select_where_possible(infcx)?;
+
+        let errors: Vec<_> = self
+            .predicates
+            .to_errors(CodeAmbiguity)
+            .into_iter()
+            .map(to_fulfillment_error)
+            .collect();
+
+        if errors.is_empty() { Ok(()) } else { Err(errors) }
     }
 
     fn select_where_possible(
@@ -543,9 +537,7 @@ impl<'a, 'b, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'b, 'tcx> {
                                     stalled_on.extend(
                                         substs
                                             .types()
-                                            .filter_map(|arg| {
-                                                TyOrConstInferVar::maybe_from_generic_arg(arg)
-                                            })
+                                            .filter_map(|ty| TyOrConstInferVar::maybe_from_ty(ty))
                                             .map(|ty| infcx.root_ty_or_const(ty)),
                                     );
                                     Err(ErrorHandled::TooGeneric)

compiler/rustc_typeck/src/check/check.rs

@@ -11,6 +11,7 @@ use rustc_hir::lang_items::LangItem;
 use rustc_hir::{ItemKind, Node};
 use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
 use rustc_infer::infer::{RegionVariableOrigin, TyCtxtInferExt};
+use rustc_infer::traits::TraitEngine;
 use rustc_middle::ty::fold::TypeFoldable;
 use rustc_middle::ty::subst::GenericArgKind;
 use rustc_middle::ty::util::{Discr, IntTypeExt, Representability};
@@ -616,7 +617,7 @@ fn check_opaque_meets_bounds<'tcx>(
 
         // Check that all obligations are satisfied by the implementation's
         // version.
-        if let Err(ref errors) = inh.fulfillment_cx.borrow_mut().select_all_or_error(&infcx) {
+        if let Err(ref errors) = inh.fulfillment_cx.borrow_mut().select_or_error(&infcx) {
             infcx.report_fulfillment_errors(errors, None, false);
         }
 

compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs

@@ -702,7 +702,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         fallback_has_occurred: bool,
         mutate_fullfillment_errors: impl Fn(&mut Vec<traits::FulfillmentError<'tcx>>),
     ) {
-        let result = self.fulfillment_cx.borrow_mut().select_all_where_possible(self);
+        let result = self.fulfillment_cx.borrow_mut().select_where_possible(self);
         if let Err(mut errors) = result {
             mutate_fullfillment_errors(&mut errors);
             self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);