feat: move fulfillment into rustc_next_trait_solver

Signed-off-by: Amirhossein Akhlaghpour <m9.akhlaghpoor@gmail.com>

Author: amirHdev

compiler/rustc_borrowck/src/diagnostics/region_errors.rs

@@ -1172,10 +1172,9 @@ impl<'diag, 'tcx> MirBorrowckCtxt<'_, 'diag, 'tcx> {
         let ocx = ObligationCtxt::new(&self.infcx);
         ocx.register_obligations(clauses.iter().map(|(clause, span)| {
             trace!(?clause);
-            Obligation::misc(
+            Obligation::new(
                 tcx,
-                span,
-                self.mir_def_id(),
+                rustc_middle::traits::ObligationCause::misc(span, self.mir_def_id()),
                 self.infcx.param_env,
                 clause.skip_norm_wip(),
             )

compiler/rustc_infer/src/traits/mod.rs

@@ -7,17 +7,10 @@ mod project;
 mod structural_impls;
 pub mod util;
 
-use std::cmp;
-use std::hash::{Hash, Hasher};
-
-use hir::def_id::LocalDefId;
-use rustc_hir as hir;
-use rustc_macros::{TypeFoldable, TypeVisitable};
 use rustc_middle::traits::query::NoSolution;
 use rustc_middle::traits::solve::Certainty;
 pub use rustc_middle::traits::*;
-use rustc_middle::ty::{self, Ty, TyCtxt, Upcast};
-use rustc_span::Span;
+use rustc_middle::ty::{self, TyCtxt};
 use thin_vec::ThinVec;
 
 pub use self::engine::{FromSolverError, ScrubbedTraitError, TraitEngine, TraitErrors};
@@ -28,93 +21,16 @@ pub use self::project::{
 };
 use crate::infer::InferCtxt;
 
-/// An `Obligation` represents some trait reference (e.g., `i32: Eq`) for
-/// which the "impl_source" must be found. The process of finding an "impl_source" is
-/// called "resolving" the `Obligation`. This process consists of
-/// either identifying an `impl` (e.g., `impl Eq for i32`) that
-/// satisfies the obligation, or else finding a bound that is in
-/// scope. The eventual result is usually a `Selection` (defined below).
-#[derive(Clone, TypeFoldable, TypeVisitable)]
-pub struct Obligation<'tcx, T> {
-    /// The reason we have to prove this thing.
-    /// FIXME: we shouldn't ignore the cause but instead change the affected visitors
-    /// to only visit predicates manually.
-    #[type_foldable(identity)]
-    #[type_visitable(ignore)]
-    pub cause: ObligationCause<'tcx>,
-
-    /// The environment in which we should prove this thing.
-    pub param_env: ty::ParamEnv<'tcx>,
-
-    /// The thing we are trying to prove.
-    pub predicate: T,
-
-    /// If we started proving this as a result of trying to prove
-    /// something else, track the total depth to ensure termination.
-    /// If this goes over a certain threshold, we abort compilation --
-    /// in such cases, we can not say whether or not the predicate
-    /// holds for certain. Stupid halting problem; such a drag.
-    #[type_foldable(identity)]
-    #[type_visitable(ignore)]
-    pub recursion_depth: usize,
-}
-
-impl<'tcx, T: Copy> Obligation<'tcx, T> {
-    pub fn as_goal(&self) -> solve::Goal<'tcx, T> {
-        solve::Goal { param_env: self.param_env, predicate: self.predicate }
-    }
-}
-
-impl<'tcx, T: PartialEq> PartialEq<Obligation<'tcx, T>> for Obligation<'tcx, T> {
-    #[inline]
-    fn eq(&self, other: &Obligation<'tcx, T>) -> bool {
-        // Ignore `cause` and `recursion_depth`. This is a small performance
-        // win for a few crates, and a huge performance win for the crate in
-        // https://github.com/rust-lang/rustc-perf/pull/1680, which greatly
-        // stresses the trait system.
-        self.param_env == other.param_env && self.predicate == other.predicate
-    }
-}
-
-impl<T: Eq> Eq for Obligation<'_, T> {}
-
-impl<T: Hash> Hash for Obligation<'_, T> {
-    fn hash<H: Hasher>(&self, state: &mut H) -> () {
-        // See the comment on `Obligation::eq`.
-        self.param_env.hash(state);
-        self.predicate.hash(state);
-    }
-}
+/// An obligation represents a predicate which must be proven in a
+/// particular parameter environment.
+pub type Obligation<'tcx, T> = rustc_type_ir::solve::Obligation<TyCtxt<'tcx>, T>;
 
 pub type PredicateObligation<'tcx> = Obligation<'tcx, ty::Predicate<'tcx>>;
 pub type TraitObligation<'tcx> = Obligation<'tcx, ty::TraitPredicate<'tcx>>;
 pub type PolyTraitObligation<'tcx> = Obligation<'tcx, ty::PolyTraitPredicate<'tcx>>;
 
 pub type PredicateObligations<'tcx> = ThinVec<PredicateObligation<'tcx>>;
 
-impl<'tcx> PredicateObligation<'tcx> {
-    /// Flips the polarity of the inner predicate.
-    ///
-    /// Given `T: Trait` predicate it returns `T: !Trait` and given `T: !Trait` returns `T: Trait`.
-    pub fn flip_polarity(&self, tcx: TyCtxt<'tcx>) -> Option<PredicateObligation<'tcx>> {
-        Some(PredicateObligation {
-            cause: self.cause.clone(),
-            param_env: self.param_env,
-            predicate: self.predicate.flip_polarity(tcx)?,
-            recursion_depth: self.recursion_depth,
-        })
-    }
-}
-
-impl<'tcx> PolyTraitObligation<'tcx> {
-    pub fn derived_cause(
-        &self,
-        variant: impl FnOnce(DerivedCause<'tcx>) -> ObligationCauseCode<'tcx>,
-    ) -> ObligationCause<'tcx> {
-        self.cause.clone().derived_cause(self.predicate, variant)
-    }
-}
-
 // `PredicateObligation` is used a lot. Make sure it doesn't unintentionally get bigger.
 #[cfg(target_pointer_width = "64")]
 rustc_data_structures::static_assert_size!(PredicateObligation<'_>, 48);
@@ -125,61 +41,3 @@ pub type Selection<'tcx> = ImplSource<'tcx, PredicateObligation<'tcx>>;
 /// of root obligations.
 pub type ObligationInspector<'tcx> =
     fn(&InferCtxt<'tcx>, &PredicateObligation<'tcx>, Result<Certainty, NoSolution>);
-
-impl<'tcx, O> Obligation<'tcx, O> {
-    pub fn new(
-        tcx: TyCtxt<'tcx>,
-        cause: ObligationCause<'tcx>,
-        param_env: ty::ParamEnv<'tcx>,
-        predicate: impl Upcast<TyCtxt<'tcx>, O>,
-    ) -> Obligation<'tcx, O> {
-        Self::with_depth(tcx, cause, 0, param_env, predicate)
-    }
-
-    /// We often create nested obligations without setting the correct depth.
-    ///
-    /// To deal with this evaluate and fulfill explicitly update the depth
-    /// of nested obligations using this function.
-    pub fn set_depth_from_parent(&mut self, parent_depth: usize) {
-        self.recursion_depth = cmp::max(parent_depth + 1, self.recursion_depth);
-    }
-
-    pub fn with_depth(
-        tcx: TyCtxt<'tcx>,
-        cause: ObligationCause<'tcx>,
-        recursion_depth: usize,
-        param_env: ty::ParamEnv<'tcx>,
-        predicate: impl Upcast<TyCtxt<'tcx>, O>,
-    ) -> Obligation<'tcx, O> {
-        let predicate = predicate.upcast(tcx);
-        Obligation { cause, param_env, recursion_depth, predicate }
-    }
-
-    pub fn misc(
-        tcx: TyCtxt<'tcx>,
-        span: Span,
-        body_def_id: LocalDefId,
-        param_env: ty::ParamEnv<'tcx>,
-        trait_ref: impl Upcast<TyCtxt<'tcx>, O>,
-    ) -> Obligation<'tcx, O> {
-        Obligation::new(tcx, ObligationCause::misc(span, body_def_id), param_env, trait_ref)
-    }
-
-    pub fn with<P>(
-        &self,
-        tcx: TyCtxt<'tcx>,
-        value: impl Upcast<TyCtxt<'tcx>, P>,
-    ) -> Obligation<'tcx, P> {
-        Obligation::with_depth(tcx, self.cause.clone(), self.recursion_depth, self.param_env, value)
-    }
-}
-
-impl<'tcx> PolyTraitObligation<'tcx> {
-    pub fn polarity(&self) -> ty::PredicatePolarity {
-        self.predicate.skip_binder().polarity
-    }
-
-    pub fn self_ty(&self) -> ty::Binder<'tcx, Ty<'tcx>> {
-        self.predicate.map_bound(|p| p.self_ty())
-    }
-}

compiler/rustc_infer/src/traits/structural_impls.rs

@@ -1,7 +1,5 @@
 use std::fmt;
 
-use rustc_middle::ty;
-
 use crate::traits;
 use crate::traits::project::Normalized;
 
@@ -13,20 +11,6 @@ impl<'tcx, T: fmt::Debug> fmt::Debug for Normalized<'tcx, T> {
     }
 }
 
-impl<'tcx, O: fmt::Debug> fmt::Debug for traits::Obligation<'tcx, O> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        if ty::tls::with(|tcx| tcx.sess.verbose_internals()) {
-            write!(
-                f,
-                "Obligation(predicate={:?}, cause={:?}, param_env={:?}, depth={})",
-                self.predicate, self.cause, self.param_env, self.recursion_depth
-            )
-        } else {
-            write!(f, "Obligation(predicate={:?}, depth={})", self.predicate, self.recursion_depth)
-        }
-    }
-}
-
 impl<'tcx> fmt::Debug for traits::MismatchedProjectionTypes<'tcx> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "MismatchedProjectionTypes({:?})", self.err)

compiler/rustc_infer/src/traits/util.rs

@@ -1,9 +1,7 @@
 use rustc_data_structures::fx::FxHashSet;
 pub use rustc_middle::ty::elaborate::*;
 use rustc_middle::ty::{self, TyCtxt, Unnormalized};
-use rustc_span::{Ident, Span};
-
-use crate::traits::{self, Obligation, ObligationCauseCode, PredicateObligation};
+use rustc_span::Ident;
 
 pub fn anonymize_predicate<'tcx>(
     tcx: TyCtxt<'tcx>,
@@ -61,46 +59,6 @@ impl<'tcx> Extend<ty::Predicate<'tcx>> for PredicateSet<'tcx> {
     }
 }
 
-/// For [`Obligation`], a sub-obligation is combined with the current obligation's
-/// param-env and cause code.
-impl<'tcx> Elaboratable<TyCtxt<'tcx>> for PredicateObligation<'tcx> {
-    fn predicate(&self) -> ty::Predicate<'tcx> {
-        self.predicate
-    }
-
-    fn child(&self, clause: ty::Clause<'tcx>) -> Self {
-        Obligation {
-            cause: self.cause.clone(),
-            param_env: self.param_env,
-            recursion_depth: 0,
-            predicate: clause.as_predicate(),
-        }
-    }
-
-    fn child_with_derived_cause(
-        &self,
-        clause: ty::Clause<'tcx>,
-        span: Span,
-        parent_trait_pred: ty::PolyTraitPredicate<'tcx>,
-        index: usize,
-    ) -> Self {
-        let cause = self.cause.clone().derived_cause(parent_trait_pred, |derived| {
-            ObligationCauseCode::ImplDerived(Box::new(traits::ImplDerivedCause {
-                derived,
-                impl_or_alias_def_id: parent_trait_pred.def_id(),
-                impl_def_clause_index: Some(index),
-                span,
-            }))
-        });
-        Obligation {
-            cause,
-            param_env: self.param_env,
-            recursion_depth: 0,
-            predicate: clause.as_predicate(),
-        }
-    }
-}
-
 /// A specialized variant of `elaborate` that only elaborates trait references that may
 /// define the given associated item with the name `assoc_name`. It uses the
 /// `explicit_supertraits_containing_assoc_item` query to avoid enumerating super-predicates that

compiler/rustc_middle/src/ty/context/impl_interner.rs

@@ -29,6 +29,14 @@ use crate::ty::{
     Region, RegionKind, Ty, TyCtxt,
 };
 
+impl<'tcx> rustc_type_ir::inherent::ObligationCause<TyCtxt<'tcx>>
+    for crate::traits::ObligationCause<'tcx>
+{
+    fn span(&self) -> Span {
+        self.span
+    }
+}
+
 #[allow(rustc::usage_of_ty_tykind)]
 impl<'tcx> Interner for TyCtxt<'tcx> {
     fn next_trait_solver_globally(self) -> bool {
@@ -61,6 +69,7 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
     type InherentAssocConstId = DefId;
     type InherentAssocTermId = DefId;
     type Span = Span;
+    type ObligationCause = crate::traits::ObligationCause<'tcx>;
 
     type GenericArgs = ty::GenericArgsRef<'tcx>;
 

compiler/rustc_middle/src/ty/elaborate_impl.rs

@@ -1,8 +1,53 @@
 use rustc_span::Span;
 use rustc_type_ir::elaborate::Elaboratable;
+use rustc_type_ir::solve::Obligation;
 
+use crate::traits::{ImplDerivedCause, ObligationCauseCode};
 use crate::ty::{self, TyCtxt};
 
+type PredicateObligation<'tcx> = Obligation<TyCtxt<'tcx>, ty::Predicate<'tcx>>;
+
+/// For `Obligation`, a sub-obligation is combined with the current
+/// obligation's param-env and cause code.
+impl<'tcx> Elaboratable<TyCtxt<'tcx>> for PredicateObligation<'tcx> {
+    fn predicate(&self) -> ty::Predicate<'tcx> {
+        self.predicate
+    }
+
+    fn child(&self, clause: ty::Clause<'tcx>) -> Self {
+        Obligation {
+            cause: self.cause.clone(),
+            param_env: self.param_env,
+            recursion_depth: 0,
+            predicate: clause.as_predicate(),
+        }
+    }
+
+    fn child_with_derived_cause(
+        &self,
+        clause: ty::Clause<'tcx>,
+        span: Span,
+        parent_trait_pred: ty::PolyTraitPredicate<'tcx>,
+        index: usize,
+    ) -> Self {
+        let cause = self.cause.clone().derived_cause(parent_trait_pred, |derived| {
+            ObligationCauseCode::ImplDerived(Box::new(ImplDerivedCause {
+                derived,
+                impl_or_alias_def_id: parent_trait_pred.def_id(),
+                impl_def_clause_index: Some(index),
+                span,
+            }))
+        });
+
+        Obligation {
+            cause,
+            param_env: self.param_env,
+            recursion_depth: 0,
+            predicate: clause.as_predicate(),
+        }
+    }
+}
+
 impl<'tcx> Elaboratable<TyCtxt<'tcx>> for ty::Clause<'tcx> {
     fn predicate(&self) -> ty::Predicate<'tcx> {
         self.as_predicate()