17 files changed, 199 insertions, 211 deletions

diff --git a/crates/hir_ty/src/autoderef.rs b/crates/hir_ty/src/autoderef.rs
index 33b966026..23ab042c1 100644
--- a/crates/hir_ty/src/autoderef.rs
+++ b/crates/hir_ty/src/autoderef.rs
@@ -6,6 +6,7 @@
 use std::iter::successors;
 
 use base_db::CrateId;
+use chalk_ir::cast::Cast;
 use hir_def::lang_item::LangItemTarget;
 use hir_expand::name::name;
 use log::{info, warn};
@@ -15,8 +16,8 @@ use crate::{
     to_assoc_type_id, to_chalk_trait_id,
     traits::{InEnvironment, Solution},
     utils::generics,
-    AliasEq, AliasTy, BoundVar, Canonical, DebruijnIndex, Interner, Obligation, ProjectionTy,
-    Substitution, TraitRef, Ty, TyKind,
+    AliasEq, AliasTy, BoundVar, Canonical, DebruijnIndex, Interner, ProjectionTy, Substitution,
+    TraitRef, Ty, TyKind,
 };
 
 const AUTODEREF_RECURSION_LIMIT: usize = 10;
@@ -74,7 +75,7 @@ fn deref_by_trait(
     let implements_goal = Canonical {
         kinds: ty.value.kinds.clone(),
         value: InEnvironment {
-            value: Obligation::Trait(trait_ref),
+            value: trait_ref.cast(&Interner),
             environment: ty.environment.clone(),
         },
     };
@@ -92,7 +93,7 @@ fn deref_by_trait(
             .intern(&Interner),
     };
 
-    let obligation = super::Obligation::AliasEq(projection);
+    let obligation = projection.cast(&Interner);
 
     let in_env = InEnvironment { value: obligation, environment: ty.environment };
 
diff --git a/crates/hir_ty/src/chalk_cast.rs b/crates/hir_ty/src/chalk_cast.rs
new file mode 100644
index 000000000..bf884ae15
--- /dev/null
+++ b/crates/hir_ty/src/chalk_cast.rs
@@ -0,0 +1,53 @@
+//! Implementations of the Chalk `Cast` trait for our types.
+
+use chalk_ir::{
+    cast::{Cast, CastTo},
+    interner::HasInterner,
+};
+
+use crate::{AliasEq, DomainGoal, Interner, TraitRef, WhereClause};
+
+macro_rules! has_interner {
+    ($t:ty) => {
+        impl HasInterner for $t {
+            type Interner = crate::Interner;
+        }
+    };
+}
+
+has_interner!(WhereClause);
+has_interner!(DomainGoal);
+
+impl CastTo<WhereClause> for TraitRef {
+    fn cast_to(self, _interner: &Interner) -> WhereClause {
+        WhereClause::Implemented(self)
+    }
+}
+
+impl CastTo<WhereClause> for AliasEq {
+    fn cast_to(self, _interner: &Interner) -> WhereClause {
+        WhereClause::AliasEq(self)
+    }
+}
+
+impl CastTo<DomainGoal> for WhereClause {
+    fn cast_to(self, _interner: &Interner) -> DomainGoal {
+        DomainGoal::Holds(self)
+    }
+}
+
+macro_rules! transitive_impl {
+    ($a:ty, $b:ty, $c:ty) => {
+        impl CastTo<$c> for $a {
+            fn cast_to(self, interner: &Interner) -> $c {
+                self.cast::<$b>(interner).cast(interner)
+            }
+        }
+    };
+}
+
+// In Chalk, these can be done as blanket impls, but that doesn't work here
+// because of coherence
+
+transitive_impl!(TraitRef, WhereClause, DomainGoal);
+transitive_impl!(AliasEq, WhereClause, DomainGoal);
diff --git a/crates/hir_ty/src/db.rs b/crates/hir_ty/src/db.rs
index 74a048672..91a2e0b5b 100644
--- a/crates/hir_ty/src/db.rs
+++ b/crates/hir_ty/src/db.rs
@@ -12,8 +12,8 @@ use la_arena::ArenaMap;
 use crate::{
     method_resolution::{InherentImpls, TraitImpls},
     traits::chalk,
-    Binders, CallableDefId, FnDefId, GenericPredicate, ImplTraitId, InferenceResult, PolyFnSig,
-    ReturnTypeImplTraits, TraitRef, Ty, TyDefId, ValueTyDefId,
+    Binders, CallableDefId, FnDefId, ImplTraitId, InferenceResult, PolyFnSig, ReturnTypeImplTraits,
+    TraitRef, Ty, TyDefId, ValueTyDefId, WhereClause,
 };
 use hir_expand::name::Name;
 
@@ -57,13 +57,10 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> {
 
     #[salsa::invoke(crate::lower::generic_predicates_for_param_query)]
     #[salsa::cycle(crate::lower::generic_predicates_for_param_recover)]
-    fn generic_predicates_for_param(
-        &self,
-        param_id: TypeParamId,
-    ) -> Arc<[Binders<GenericPredicate>]>;
+    fn generic_predicates_for_param(&self, param_id: TypeParamId) -> Arc<[Binders<WhereClause>]>;
 
     #[salsa::invoke(crate::lower::generic_predicates_query)]
-    fn generic_predicates(&self, def: GenericDefId) -> Arc<[Binders<GenericPredicate>]>;
+    fn generic_predicates(&self, def: GenericDefId) -> Arc<[Binders<WhereClause>]>;
 
     #[salsa::invoke(crate::lower::trait_environment_query)]
     fn trait_environment(&self, def: GenericDefId) -> Arc<crate::TraitEnvironment>;
@@ -122,7 +119,7 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> {
     fn trait_solve(
         &self,
         krate: CrateId,
-        goal: crate::Canonical<crate::InEnvironment<crate::Obligation>>,
+        goal: crate::Canonical<crate::InEnvironment<crate::DomainGoal>>,
     ) -> Option<crate::traits::Solution>;
 
     #[salsa::invoke(crate::traits::chalk::program_clauses_for_chalk_env_query)]
diff --git a/crates/hir_ty/src/display.rs b/crates/hir_ty/src/display.rs
index 59a1bd9b0..3845009ae 100644
--- a/crates/hir_ty/src/display.rs
+++ b/crates/hir_ty/src/display.rs
@@ -19,8 +19,8 @@ use hir_expand::name::Name;
 use crate::{
     db::HirDatabase, from_assoc_type_id, from_foreign_def_id, from_placeholder_idx, primitive,
     to_assoc_type_id, traits::chalk::from_chalk, utils::generics, AdtId, AliasEq, AliasTy,
-    CallableDefId, CallableSig, GenericPredicate, ImplTraitId, Interner, Lifetime, Obligation,
-    OpaqueTy, ProjectionTy, Scalar, Substitution, TraitRef, Ty, TyKind,
+    CallableDefId, CallableSig, DomainGoal, ImplTraitId, Interner, Lifetime, OpaqueTy,
+    ProjectionTy, Scalar, Substitution, TraitRef, Ty, TyKind, WhereClause,
 };
 
 pub struct HirFormatter<'a> {
@@ -353,7 +353,7 @@ impl HirDisplay for Ty {
                     _ => Cow::Borrowed(&[][..]),
                 };
 
-                if let [GenericPredicate::Implemented(trait_ref), _] = predicates.as_ref() {
+                if let [WhereClause::Implemented(trait_ref), _] = predicates.as_ref() {
                     let trait_ = trait_ref.hir_trait_id();
                     if fn_traits(f.db.upcast(), trait_).any(|it| it == trait_) {
                         return write!(f, "{}", ty_display);
@@ -652,7 +652,7 @@ fn fn_traits(db: &dyn DefDatabase, trait_: TraitId) -> impl Iterator<Item = Trai
 
 pub fn write_bounds_like_dyn_trait_with_prefix(
     prefix: &str,
-    predicates: &[GenericPredicate],
+    predicates: &[WhereClause],
     f: &mut HirFormatter,
 ) -> Result<(), HirDisplayError> {
     write!(f, "{}", prefix)?;
@@ -665,7 +665,7 @@ pub fn write_bounds_like_dyn_trait_with_prefix(
 }
 
 fn write_bounds_like_dyn_trait(
-    predicates: &[GenericPredicate],
+    predicates: &[WhereClause],
     f: &mut HirFormatter,
 ) -> Result<(), HirDisplayError> {
     // Note: This code is written to produce nice results (i.e.
@@ -679,7 +679,7 @@ fn write_bounds_like_dyn_trait(
     let mut is_fn_trait = false;
     for p in predicates.iter() {
         match p {
-            GenericPredicate::Implemented(trait_ref) => {
+            WhereClause::Implemented(trait_ref) => {
                 let trait_ = trait_ref.hir_trait_id();
                 if !is_fn_trait {
                     is_fn_trait = fn_traits(f.db.upcast(), trait_).any(|it| it == trait_);
@@ -710,12 +710,12 @@ fn write_bounds_like_dyn_trait(
                     }
                 }
             }
-            GenericPredicate::AliasEq(alias_eq) if is_fn_trait => {
+            WhereClause::AliasEq(alias_eq) if is_fn_trait => {
                 is_fn_trait = false;
                 write!(f, " -> ")?;
                 alias_eq.ty.hir_fmt(f)?;
             }
-            GenericPredicate::AliasEq(AliasEq { ty, alias }) => {
+            WhereClause::AliasEq(AliasEq { ty, alias }) => {
                 // in types in actual Rust, these will always come
                 // after the corresponding Implemented predicate
                 if angle_open {
@@ -731,16 +731,6 @@ fn write_bounds_like_dyn_trait(
                 }
                 ty.hir_fmt(f)?;
             }
-            GenericPredicate::Error => {
-                if angle_open {
-                    // impl Trait<X, {error}>
-                    write!(f, ", ")?;
-                } else if !first {
-                    // impl Trait + {error}
-                    write!(f, " + ")?;
-                }
-                p.hir_fmt(f)?;
-            }
         }
         first = false;
     }
@@ -778,18 +768,15 @@ impl HirDisplay for TraitRef {
     }
 }
 
-impl HirDisplay for GenericPredicate {
+impl HirDisplay for WhereClause {
     fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
         if f.should_truncate() {
             return write!(f, "{}", TYPE_HINT_TRUNCATION);
         }
 
         match self {
-            GenericPredicate::Implemented(trait_ref) => trait_ref.hir_fmt(f)?,
-            GenericPredicate::AliasEq(AliasEq {
-                alias: AliasTy::Projection(projection_ty),
-                ty,
-            }) => {
+            WhereClause::Implemented(trait_ref) => trait_ref.hir_fmt(f)?,
+            WhereClause::AliasEq(AliasEq { alias: AliasTy::Projection(projection_ty), ty }) => {
                 write!(f, "<")?;
                 projection_ty.trait_ref(f.db).hir_fmt_ext(f, true)?;
                 write!(
@@ -799,7 +786,7 @@ impl HirDisplay for GenericPredicate {
                 )?;
                 ty.hir_fmt(f)?;
             }
-            GenericPredicate::AliasEq(_) | GenericPredicate::Error => write!(f, "{{error}}")?,
+            WhereClause::AliasEq(_) => write!(f, "{{error}}")?,
         }
         Ok(())
     }
@@ -818,22 +805,12 @@ impl HirDisplay for Lifetime {
     }
 }
 
-impl HirDisplay for Obligation {
+impl HirDisplay for DomainGoal {
     fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
         match self {
-            Obligation::Trait(tr) => {
-                write!(f, "Implements(")?;
-                tr.hir_fmt(f)?;
-                write!(f, ")")
-            }
-            Obligation::AliasEq(AliasEq { alias, ty }) => {
-                write!(f, "Normalize(")?;
-                match alias {
-                    AliasTy::Projection(projection_ty) => projection_ty.hir_fmt(f)?,
-                    AliasTy::Opaque(opaque) => opaque.hir_fmt(f)?,
-                }
-                write!(f, " => ")?;
-                ty.hir_fmt(f)?;
+            DomainGoal::Holds(wc) => {
+                write!(f, "Holds(")?;
+                wc.hir_fmt(f)?;
                 write!(f, ")")
             }
         }
diff --git a/crates/hir_ty/src/infer.rs b/crates/hir_ty/src/infer.rs
index 82186979a..b9e434c78 100644
--- a/crates/hir_ty/src/infer.rs
+++ b/crates/hir_ty/src/infer.rs
@@ -18,7 +18,7 @@ use std::mem;
 use std::ops::Index;
 use std::sync::Arc;
 
-use chalk_ir::Mutability;
+use chalk_ir::{cast::Cast, Mutability};
 use hir_def::{
     body::Body,
     data::{ConstData, FunctionData, StaticData},
@@ -37,7 +37,7 @@ use stdx::impl_from;
 use syntax::SmolStr;
 
 use super::{
-    traits::{Guidance, Obligation, Solution},
+    traits::{DomainGoal, Guidance, Solution},
     InEnvironment, ProjectionTy, Substitution, TraitEnvironment, TraitRef, Ty, TypeWalk,
 };
 use crate::{
@@ -204,7 +204,7 @@ struct InferenceContext<'a> {
     resolver: Resolver,
     table: unify::InferenceTable,
     trait_env: Arc<TraitEnvironment>,
-    obligations: Vec<Obligation>,
+    obligations: Vec<DomainGoal>,
     result: InferenceResult,
     /// The return type of the function being inferred, or the closure if we're
     /// currently within one.
@@ -403,8 +403,8 @@ impl<'a> InferenceContext<'a> {
                     }),
                     ty: ty.clone(),
                 };
-                self.obligations.push(Obligation::Trait(trait_ref));
-                self.obligations.push(Obligation::AliasEq(alias_eq));
+                self.obligations.push(trait_ref.cast(&Interner));
+                self.obligations.push(alias_eq.cast(&Interner));
                 self.resolve_ty_as_possible(ty)
             }
             None => self.err_ty(),
@@ -430,7 +430,7 @@ impl<'a> InferenceContext<'a> {
     fn normalize_projection_ty(&mut self, proj_ty: ProjectionTy) -> Ty {
         let var = self.table.new_type_var();
         let alias_eq = AliasEq { alias: AliasTy::Projection(proj_ty), ty: var.clone() };
-        let obligation = Obligation::AliasEq(alias_eq);
+        let obligation = alias_eq.cast(&Interner);
         self.obligations.push(obligation);
         var
     }
diff --git a/crates/hir_ty/src/infer/coerce.rs b/crates/hir_ty/src/infer/coerce.rs
index b86474ed4..07eb96573 100644
--- a/crates/hir_ty/src/infer/coerce.rs
+++ b/crates/hir_ty/src/infer/coerce.rs
@@ -4,12 +4,11 @@
 //!
 //! See: https://doc.rust-lang.org/nomicon/coercions.html
 
-use chalk_ir::{Mutability, TyVariableKind};
+use chalk_ir::{cast::Cast, Mutability, TyVariableKind};
 use hir_def::lang_item::LangItemTarget;
 
 use crate::{
-    autoderef, to_chalk_trait_id, traits::Solution, Interner, Obligation, Substitution, TraitRef,
-    Ty, TyKind,
+    autoderef, to_chalk_trait_id, traits::Solution, Interner, Substitution, TraitRef, Ty, TyKind,
 };
 
 use super::{InEnvironment, InferenceContext};
@@ -143,7 +142,7 @@ impl<'a> InferenceContext<'a> {
             .build();
         let trait_ref =
             TraitRef { trait_id: to_chalk_trait_id(coerce_unsized_trait), substitution: substs };
-        let goal = InEnvironment::new(self.trait_env.clone(), Obligation::Trait(trait_ref));
+        let goal = InEnvironment::new(self.trait_env.clone(), trait_ref.cast(&Interner));
 
         let canonicalizer = self.canonicalizer();
         let canonicalized = canonicalizer.canonicalize_obligation(goal);
diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs
index 93548b6c0..79bbc5dab 100644
--- a/crates/hir_ty/src/infer/expr.rs
+++ b/crates/hir_ty/src/infer/expr.rs
@@ -3,7 +3,7 @@
 use std::iter::{repeat, repeat_with};
 use std::{mem, sync::Arc};
 
-use chalk_ir::{Mutability, TyVariableKind};
+use chalk_ir::{cast::Cast, Mutability, TyVariableKind};
 use hir_def::{
     expr::{Array, BinaryOp, Expr, ExprId, Literal, Statement, UnaryOp},
     path::{GenericArg, GenericArgs},
@@ -21,7 +21,7 @@ use crate::{
     to_assoc_type_id, to_chalk_trait_id,
     traits::{chalk::from_chalk, FnTrait, InEnvironment},
     utils::{generics, variant_data, Generics},
-    AdtId, Binders, CallableDefId, FnPointer, FnSig, Interner, Obligation, Rawness, Scalar,
+    AdtId, Binders, CallableDefId, DomainGoal, FnPointer, FnSig, Interner, Rawness, Scalar,
     Substitution, TraitRef, Ty, TyKind,
 };
 
@@ -90,10 +90,9 @@ impl<'a> InferenceContext<'a> {
             Substitution::build_for_generics(&generic_params).push(ty.clone()).push(arg_ty).build();
 
         let trait_env = Arc::clone(&self.trait_env);
-        let implements_fn_trait = Obligation::Trait(TraitRef {
-            trait_id: to_chalk_trait_id(fn_once_trait),
-            substitution: substs.clone(),
-        });
+        let implements_fn_trait: DomainGoal =
+            TraitRef { trait_id: to_chalk_trait_id(fn_once_trait), substitution: substs.clone() }
+                .cast(&Interner);
         let goal = self.canonicalizer().canonicalize_obligation(InEnvironment {
             value: implements_fn_trait.clone(),
             environment: trait_env,
@@ -938,22 +937,20 @@ impl<'a> InferenceContext<'a> {
             let generic_predicates = self.db.generic_predicates(def.into());
             for predicate in generic_predicates.iter() {
                 let predicate = predicate.clone().subst(parameters);
-                if let Some(obligation) = Obligation::from_predicate(predicate) {
-                    self.obligations.push(obligation);
-                }
+                self.obligations.push(predicate.cast(&Interner));
             }
             // add obligation for trait implementation, if this is a trait method
             match def {
                 CallableDefId::FunctionId(f) => {
                     if let AssocContainerId::TraitId(trait_) = f.lookup(self.db.upcast()).container
                     {
-                        // construct a TraitDef
+                        // construct a TraitRef
                         let substs =
                             parameters.prefix(generics(self.db.upcast(), trait_.into()).len());
-                        self.obligations.push(Obligation::Trait(TraitRef {
-                            trait_id: to_chalk_trait_id(trait_),
-                            substitution: substs,
-                        }));
+                        self.obligations.push(
+                            TraitRef { trait_id: to_chalk_trait_id(trait_), substitution: substs }
+                                .cast(&Interner),
+                        );
                     }
                 }
                 CallableDefId::StructId(_) | CallableDefId::EnumVariantId(_) => {}
diff --git a/crates/hir_ty/src/infer/path.rs b/crates/hir_ty/src/infer/path.rs
index e15135fc1..58cce56ab 100644
--- a/crates/hir_ty/src/infer/path.rs
+++ b/crates/hir_ty/src/infer/path.rs
@@ -2,6 +2,7 @@
 
 use std::iter;
 
+use chalk_ir::cast::Cast;
 use hir_def::{
     path::{Path, PathSegment},
     resolver::{ResolveValueResult, Resolver, TypeNs, ValueNs},
@@ -256,10 +257,13 @@ impl<'a> InferenceContext<'a> {
                             .push(ty.clone())
                             .fill(std::iter::repeat_with(|| self.table.new_type_var()))
                             .build();
-                        self.obligations.push(super::Obligation::Trait(TraitRef {
-                            trait_id: to_chalk_trait_id(trait_),
-                            substitution: trait_substs.clone(),
-                        }));
+                        self.obligations.push(
+                            TraitRef {
+                                trait_id: to_chalk_trait_id(trait_),
+                                substitution: trait_substs.clone(),
+                            }
+                            .cast(&Interner),
+                        );
                         Some(trait_substs)
                     }
                     AssocContainerId::ModuleId(_) => None,
diff --git a/crates/hir_ty/src/infer/unify.rs b/crates/hir_ty/src/infer/unify.rs
index 4738ec08a..1fc03c8f4 100644
--- a/crates/hir_ty/src/infer/unify.rs
+++ b/crates/hir_ty/src/infer/unify.rs
@@ -5,10 +5,10 @@ use std::borrow::Cow;
 use chalk_ir::{FloatTy, IntTy, TyVariableKind};
 use ena::unify::{InPlaceUnificationTable, NoError, UnifyKey, UnifyValue};
 
-use super::{InferenceContext, Obligation};
+use super::{DomainGoal, InferenceContext};
 use crate::{
-    AliasEq, AliasTy, BoundVar, Canonical, DebruijnIndex, FnPointer, GenericPredicate,
-    InEnvironment, InferenceVar, Interner, Scalar, Substitution, Ty, TyKind, TypeWalk,
+    AliasEq, AliasTy, BoundVar, Canonical, DebruijnIndex, FnPointer, InEnvironment, InferenceVar,
+    Interner, Scalar, Substitution, Ty, TyKind, TypeWalk, WhereClause,
 };
 
 impl<'a> InferenceContext<'a> {
@@ -87,14 +87,11 @@ impl<'a, 'b> Canonicalizer<'a, 'b> {
 
     pub(crate) fn canonicalize_obligation(
         mut self,
-        obligation: InEnvironment<Obligation>,
-    ) -> Canonicalized<InEnvironment<Obligation>> {
+        obligation: InEnvironment<DomainGoal>,
+    ) -> Canonicalized<InEnvironment<DomainGoal>> {
         let result = match obligation.value {
-            Obligation::Trait(tr) => {
-                Obligation::Trait(self.do_canonicalize(tr, DebruijnIndex::INNERMOST))
-            }
-            Obligation::AliasEq(alias_eq) => {
-                Obligation::AliasEq(self.do_canonicalize(alias_eq, DebruijnIndex::INNERMOST))
+            DomainGoal::Holds(wc) => {
+                DomainGoal::Holds(self.do_canonicalize(wc, DebruijnIndex::INNERMOST))
             }
         };
         self.into_canonicalized(InEnvironment {
@@ -382,21 +379,16 @@ impl InferenceTable {
         }
     }
 
-    fn unify_preds(
-        &mut self,
-        pred1: &GenericPredicate,
-        pred2: &GenericPredicate,
-        depth: usize,
-    ) -> bool {
+    fn unify_preds(&mut self, pred1: &WhereClause, pred2: &WhereClause, depth: usize) -> bool {
         match (pred1, pred2) {
-            (GenericPredicate::Implemented(tr1), GenericPredicate::Implemented(tr2))
+            (WhereClause::Implemented(tr1), WhereClause::Implemented(tr2))
                 if tr1.trait_id == tr2.trait_id =>
             {
                 self.unify_substs(&tr1.substitution, &tr2.substitution, depth + 1)
             }
             (
-                GenericPredicate::AliasEq(AliasEq { alias: alias1, ty: ty1 }),
-                GenericPredicate::AliasEq(AliasEq { alias: alias2, ty: ty2 }),
+                WhereClause::AliasEq(AliasEq { alias: alias1, ty: ty1 }),
+                WhereClause::AliasEq(AliasEq { alias: alias2, ty: ty2 }),
             ) => {
                 let (substitution1, substitution2) = match (alias1, alias2) {
                     (AliasTy::Projection(projection_ty1), AliasTy::Projection(projection_ty2))
diff --git a/crates/hir_ty/src/lib.rs b/crates/hir_ty/src/lib.rs
index 2afcb5413..c46529879 100644
--- a/crates/hir_ty/src/lib.rs
+++ b/crates/hir_ty/src/lib.rs
@@ -13,6 +13,7 @@ mod op;
 mod lower;
 pub(crate) mod infer;
 pub(crate) mod utils;
+mod chalk_cast;
 
 pub mod display;
 pub mod db;
@@ -45,9 +46,11 @@ pub use lower::{
     associated_type_shorthand_candidates, callable_item_sig, CallableDefId, ImplTraitLoweringMode,
     TyDefId, TyLoweringContext, ValueTyDefId,
 };
-pub use traits::{AliasEq, InEnvironment, Obligation, TraitEnvironment};
+pub use traits::{AliasEq, DomainGoal, InEnvironment, TraitEnvironment};
 
-pub use chalk_ir::{AdtId, BoundVar, DebruijnIndex, Mutability, Safety, Scalar, TyVariableKind};
+pub use chalk_ir::{
+    cast::Cast, AdtId, BoundVar, DebruijnIndex, Mutability, Safety, Scalar, TyVariableKind,
+};
 
 pub use crate::traits::chalk::Interner;
 
@@ -276,7 +279,7 @@ pub enum TyKind {
     /// represents the `Self` type inside the bounds. This is currently
     /// implicit; Chalk has the `Binders` struct to make it explicit, but it
     /// didn't seem worth the overhead yet.
-    Dyn(Arc<[GenericPredicate]>),
+    Dyn(Arc<[WhereClause]>),
 
     /// A placeholder for a type which could not be computed; this is propagated
     /// to avoid useless error messages. Doubles as a placeholder where type
@@ -564,42 +567,34 @@ impl TypeWalk for TraitRef {
 /// Like `generics::WherePredicate`, but with resolved types: A condition on the
 /// parameters of a generic item.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum GenericPredicate {
+pub enum WhereClause {
     /// The given trait needs to be implemented for its type parameters.
     Implemented(TraitRef),
     /// An associated type bindings like in `Iterator<Item = T>`.
     AliasEq(AliasEq),
-    /// We couldn't resolve the trait reference. (If some type parameters can't
-    /// be resolved, they will just be Unknown).
-    Error,
 }
 
-impl GenericPredicate {
-    pub fn is_error(&self) -> bool {
-        matches!(self, GenericPredicate::Error)
-    }
-
+impl WhereClause {
     pub fn is_implemented(&self) -> bool {
-        matches!(self, GenericPredicate::Implemented(_))
+        matches!(self, WhereClause::Implemented(_))
     }
 
     pub fn trait_ref(&self, db: &dyn HirDatabase) -> Option<TraitRef> {
         match self {
-            GenericPredicate::Implemented(tr) => Some(tr.clone()),
-            GenericPredicate::AliasEq(AliasEq { alias: AliasTy::Projection(proj), .. }) => {
+            WhereClause::Implemented(tr) => Some(tr.clone()),
+            WhereClause::AliasEq(AliasEq { alias: AliasTy::Projection(proj), .. }) => {
                 Some(proj.trait_ref(db))
             }
-            GenericPredicate::AliasEq(_) | GenericPredicate::Error => None,
+            WhereClause::AliasEq(_) => None,
         }
     }
 }
 
-impl TypeWalk for GenericPredicate {
+impl TypeWalk for WhereClause {
     fn walk(&self, f: &mut impl FnMut(&Ty)) {
         match self {
-            GenericPredicate::Implemented(trait_ref) => trait_ref.walk(f),
-            GenericPredicate::AliasEq(alias_eq) => alias_eq.walk(f),
-            GenericPredicate::Error => {}
+            WhereClause::Implemented(trait_ref) => trait_ref.walk(f),
+            WhereClause::AliasEq(alias_eq) => alias_eq.walk(f),
         }
     }
 
@@ -609,9 +604,8 @@ impl TypeWalk for GenericPredicate {
         binders: DebruijnIndex,
     ) {
         match self {
-            GenericPredicate::Implemented(trait_ref) => trait_ref.walk_mut_binders(f, binders),
-            GenericPredicate::AliasEq(alias_eq) => alias_eq.walk_mut_binders(f, binders),
-            GenericPredicate::Error => {}
+            WhereClause::Implemented(trait_ref) => trait_ref.walk_mut_binders(f, binders),
+            WhereClause::AliasEq(alias_eq) => alias_eq.walk_mut_binders(f, binders),
         }
     }
 }
@@ -815,7 +809,7 @@ impl Ty {
     pub fn dyn_trait_ref(&self) -> Option<&TraitRef> {
         match self.interned(&Interner) {
             TyKind::Dyn(bounds) => bounds.get(0).and_then(|b| match b {
-                GenericPredicate::Implemented(trait_ref) => Some(trait_ref),
+                WhereClause::Implemented(trait_ref) => Some(trait_ref),
                 _ => None,
             }),
             _ => None,
@@ -894,7 +888,7 @@ impl Ty {
         }
     }
 
-    pub fn impl_trait_bounds(&self, db: &dyn HirDatabase) -> Option<Vec<GenericPredicate>> {
+    pub fn impl_trait_bounds(&self, db: &dyn HirDatabase) -> Option<Vec<WhereClause>> {
         match self.interned(&Interner) {
             TyKind::OpaqueType(opaque_ty_id, ..) => {
                 match db.lookup_intern_impl_trait_id((*opaque_ty_id).into()) {
@@ -907,7 +901,7 @@ impl Ty {
                             // This is only used by type walking.
                             // Parameters will be walked outside, and projection predicate is not used.
                             // So just provide the Future trait.
-                            let impl_bound = GenericPredicate::Implemented(TraitRef {
+                            let impl_bound = WhereClause::Implemented(TraitRef {
                                 trait_id: to_chalk_trait_id(future_trait),
                                 substitution: Substitution::empty(),
                             });
@@ -1166,7 +1160,7 @@ pub struct ReturnTypeImplTraits {
 
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub(crate) struct ReturnTypeImplTrait {
-    pub(crate) bounds: Binders<Vec<GenericPredicate>>,
+    pub(crate) bounds: Binders<Vec<WhereClause>>,
 }
 
 pub fn to_foreign_def_id(id: TypeAliasId) -> ForeignDefId {
diff --git a/crates/hir_ty/src/lower.rs b/crates/hir_ty/src/lower.rs
index 7d22c3df5..cbbb535e5 100644
--- a/crates/hir_ty/src/lower.rs
+++ b/crates/hir_ty/src/lower.rs
@@ -33,9 +33,9 @@ use crate::{
         all_super_trait_refs, associated_type_by_name_including_super_traits, generics,
         variant_data,
     },
-    AliasEq, AliasTy, Binders, BoundVar, CallableSig, DebruijnIndex, FnPointer, FnSig,
-    GenericPredicate, ImplTraitId, OpaqueTy, PolyFnSig, ProjectionTy, ReturnTypeImplTrait,
-    ReturnTypeImplTraits, Substitution, TraitEnvironment, TraitRef, Ty, TyKind, TypeWalk,
+    AliasEq, AliasTy, Binders, BoundVar, CallableSig, DebruijnIndex, FnPointer, FnSig, ImplTraitId,
+    OpaqueTy, PolyFnSig, ProjectionTy, ReturnTypeImplTrait, ReturnTypeImplTraits, Substitution,
+    TraitEnvironment, TraitRef, Ty, TyKind, TypeWalk, WhereClause,
 };
 
 #[derive(Debug)]
@@ -373,8 +373,7 @@ impl<'a> TyLoweringContext<'a> {
                     // FIXME report error (ambiguous associated type)
                     TyKind::Unknown.intern(&Interner)
                 } else {
-                    TyKind::Dyn(Arc::new([GenericPredicate::Implemented(trait_ref)]))
-                        .intern(&Interner)
+                    TyKind::Dyn(Arc::new([WhereClause::Implemented(trait_ref)])).intern(&Interner)
                 };
                 return (ty, None);
             }
@@ -667,7 +666,7 @@ impl<'a> TyLoweringContext<'a> {
     pub(crate) fn lower_where_predicate(
         &'a self,
         where_predicate: &'a WherePredicate,
-    ) -> impl Iterator<Item = GenericPredicate> + 'a {
+    ) -> impl Iterator<Item = WhereClause> + 'a {
         match where_predicate {
             WherePredicate::ForLifetime { target, bound, .. }
             | WherePredicate::TypeBound { target, bound } => {
@@ -699,17 +698,15 @@ impl<'a> TyLoweringContext<'a> {
         &'a self,
         bound: &'a TypeBound,
         self_ty: Ty,
-    ) -> impl Iterator<Item = GenericPredicate> + 'a {
+    ) -> impl Iterator<Item = WhereClause> + 'a {
         let mut bindings = None;
         let trait_ref = match bound {
             TypeBound::Path(path) => {
                 bindings = self.lower_trait_ref_from_path(path, Some(self_ty));
-                Some(
-                    bindings.clone().map_or(GenericPredicate::Error, GenericPredicate::Implemented),
-                )
+                bindings.clone().map(WhereClause::Implemented)
             }
             TypeBound::Lifetime(_) => None,
-            TypeBound::Error => Some(GenericPredicate::Error),
+            TypeBound::Error => None,
         };
         trait_ref.into_iter().chain(
             bindings
@@ -722,7 +719,7 @@ impl<'a> TyLoweringContext<'a> {
         &'a self,
         bound: &'a TypeBound,
         trait_ref: TraitRef,
-    ) -> impl Iterator<Item = GenericPredicate> + 'a {
+    ) -> impl Iterator<Item = WhereClause> + 'a {
         let last_segment = match bound {
             TypeBound::Path(path) => path.segments().last(),
             TypeBound::Error | TypeBound::Lifetime(_) => None,
@@ -738,7 +735,7 @@ impl<'a> TyLoweringContext<'a> {
                     &binding.name,
                 );
                 let (super_trait_ref, associated_ty) = match found {
-                    None => return SmallVec::<[GenericPredicate; 1]>::new(),
+                    None => return SmallVec::<[WhereClause; 1]>::new(),
                     Some(t) => t,
                 };
                 let projection_ty = ProjectionTy {
@@ -752,7 +749,7 @@ impl<'a> TyLoweringContext<'a> {
                     let ty = self.lower_ty(type_ref);
                     let alias_eq =
                         AliasEq { alias: AliasTy::Projection(projection_ty.clone()), ty };
-                    preds.push(GenericPredicate::AliasEq(alias_eq));
+                    preds.push(WhereClause::AliasEq(alias_eq));
                 }
                 for bound in &binding.bounds {
                     preds.extend(self.lower_type_bound(
@@ -809,7 +806,7 @@ pub fn associated_type_shorthand_candidates<R>(
             let mut traits_: Vec<_> = predicates
                 .iter()
                 .filter_map(|pred| match &pred.value {
-                    GenericPredicate::Implemented(tr) => Some(tr.clone()),
+                    WhereClause::Implemented(tr) => Some(tr.clone()),
                     _ => None,
                 })
                 .collect();
@@ -881,7 +878,7 @@ pub(crate) fn field_types_query(
 pub(crate) fn generic_predicates_for_param_query(
     db: &dyn HirDatabase,
     param_id: TypeParamId,
-) -> Arc<[Binders<GenericPredicate>]> {
+) -> Arc<[Binders<WhereClause>]> {
     let resolver = param_id.parent.resolver(db.upcast());
     let ctx =
         TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable);
@@ -907,7 +904,7 @@ pub(crate) fn generic_predicates_for_param_recover(
     _db: &dyn HirDatabase,
     _cycle: &[String],
     _param_id: &TypeParamId,
-) -> Arc<[Binders<GenericPredicate>]> {
+) -> Arc<[Binders<WhereClause>]> {
     Arc::new([])
 }
 
@@ -922,10 +919,7 @@ pub(crate) fn trait_environment_query(
     let mut clauses = Vec::new();
     for pred in resolver.where_predicates_in_scope() {
         for pred in ctx.lower_where_predicate(pred) {
-            if pred.is_error() {
-                continue;
-            }
-            if let GenericPredicate::Implemented(tr) = &pred {
+            if let WhereClause::Implemented(tr) = &pred {
                 traits_in_scope.push((tr.self_type_parameter().clone(), tr.hir_trait_id()));
             }
             let program_clause: chalk_ir::ProgramClause<Interner> =
@@ -951,7 +945,7 @@ pub(crate) fn trait_environment_query(
         cov_mark::hit!(trait_self_implements_self);
         let substs = Substitution::type_params(db, trait_id);
         let trait_ref = TraitRef { trait_id: to_chalk_trait_id(trait_id), substitution: substs };
-        let pred = GenericPredicate::Implemented(trait_ref);
+        let pred = WhereClause::Implemented(trait_ref);
         let program_clause: chalk_ir::ProgramClause<Interner> =
             pred.clone().to_chalk(db).cast(&Interner);
         clauses.push(program_clause.into_from_env_clause(&Interner));
@@ -966,7 +960,7 @@ pub(crate) fn trait_environment_query(
 pub(crate) fn generic_predicates_query(
     db: &dyn HirDatabase,
     def: GenericDefId,
-) -> Arc<[Binders<GenericPredicate>]> {
+) -> Arc<[Binders<WhereClause>]> {
     let resolver = def.resolver(db.upcast());
     let ctx =
         TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable);
diff --git a/crates/hir_ty/src/method_resolution.rs b/crates/hir_ty/src/method_resolution.rs
index 01b78fb44..da6bc2a4a 100644
--- a/crates/hir_ty/src/method_resolution.rs
+++ b/crates/hir_ty/src/method_resolution.rs
@@ -6,7 +6,7 @@ use std::{iter, sync::Arc};
 
 use arrayvec::ArrayVec;
 use base_db::CrateId;
-use chalk_ir::Mutability;
+use chalk_ir::{cast::Cast, Mutability};
 use hir_def::{
     lang_item::LangItemTarget, AssocContainerId, AssocItemId, FunctionId, GenericDefId, HasModule,
     ImplId, Lookup, ModuleId, TraitId,
@@ -767,7 +767,7 @@ fn generic_implements_goal(
     env: Arc<TraitEnvironment>,
     trait_: TraitId,
     self_ty: Canonical<Ty>,
-) -> Canonical<InEnvironment<super::Obligation>> {
+) -> Canonical<InEnvironment<super::DomainGoal>> {
     let mut kinds = self_ty.kinds.to_vec();
     let substs = super::Substitution::build_for_def(db, trait_)
         .push(self_ty.value)
@@ -775,7 +775,7 @@ fn generic_implements_goal(
         .build();
     kinds.extend(iter::repeat(chalk_ir::TyVariableKind::General).take(substs.len() - 1));
     let trait_ref = TraitRef { trait_id: to_chalk_trait_id(trait_), substitution: substs };
-    let obligation = super::Obligation::Trait(trait_ref);
+    let obligation = trait_ref.cast(&Interner);
     Canonical { kinds: kinds.into(), value: InEnvironment::new(env, obligation) }
 }
 
diff --git a/crates/hir_ty/src/tests/traits.rs b/crates/hir_ty/src/tests/traits.rs
index 8270fa219..8f2bdffc0 100644
--- a/crates/hir_ty/src/tests/traits.rs
+++ b/crates/hir_ty/src/tests/traits.rs
@@ -1412,8 +1412,8 @@ fn weird_bounds() {
             50..51 'b': impl
             69..70 'c': impl Trait
             86..87 'd': impl
-            107..108 'e': impl {error}
-            123..124 'f': impl Trait + {error}
+            107..108 'e': impl
+            123..124 'f': impl Trait
             147..149 '{}': ()
         "#]],
     );
diff --git a/crates/hir_ty/src/traits.rs b/crates/hir_ty/src/traits.rs
index ac7de7605..7dadd1ffb 100644
--- a/crates/hir_ty/src/traits.rs
+++ b/crates/hir_ty/src/traits.rs
@@ -9,8 +9,8 @@ use hir_def::{lang_item::LangItemTarget, TraitId};
 use stdx::panic_context;
 
 use crate::{
-    db::HirDatabase, AliasTy, Canonical, DebruijnIndex, GenericPredicate, HirDisplay, Substitution,
-    TraitRef, Ty, TyKind, TypeWalk,
+    db::HirDatabase, AliasTy, Canonical, DebruijnIndex, HirDisplay, Substitution, Ty, TyKind,
+    TypeWalk, WhereClause,
 };
 
 use self::chalk::{from_chalk, Interner, ToChalk};
@@ -88,21 +88,8 @@ impl<T> InEnvironment<T> {
 /// a certain type implements a certain trait. Proving the Obligation might
 /// result in additional information about inference variables.
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub enum Obligation {
-    /// Prove that a certain type implements a trait (the type is the `Self` type
-    /// parameter to the `TraitRef`).
-    Trait(TraitRef),
-    AliasEq(AliasEq),
-}
-
-impl Obligation {
-    pub fn from_predicate(predicate: GenericPredicate) -> Option<Obligation> {
-        match predicate {
-            GenericPredicate::Implemented(trait_ref) => Some(Obligation::Trait(trait_ref)),
-            GenericPredicate::AliasEq(alias_eq) => Some(Obligation::AliasEq(alias_eq)),
-            GenericPredicate::Error => None,
-        }
-    }
+pub enum DomainGoal {
+    Holds(WhereClause),
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
@@ -137,16 +124,20 @@ impl TypeWalk for AliasEq {
 pub(crate) fn trait_solve_query(
     db: &dyn HirDatabase,
     krate: CrateId,
-    goal: Canonical<InEnvironment<Obligation>>,
+    goal: Canonical<InEnvironment<DomainGoal>>,
 ) -> Option<Solution> {
     let _p = profile::span("trait_solve_query").detail(|| match &goal.value.value {
-        Obligation::Trait(it) => db.trait_data(it.hir_trait_id()).name.to_string(),
-        Obligation::AliasEq(_) => "alias_eq".to_string(),
+        DomainGoal::Holds(WhereClause::Implemented(it)) => {
+            db.trait_data(it.hir_trait_id()).name.to_string()
+        }
+        DomainGoal::Holds(WhereClause::AliasEq(_)) => "alias_eq".to_string(),
     });
     log::info!("trait_solve_query({})", goal.value.value.display(db));
 
-    if let Obligation::AliasEq(AliasEq { alias: AliasTy::Projection(projection_ty), .. }) =
-        &goal.value.value
+    if let DomainGoal::Holds(WhereClause::AliasEq(AliasEq {
+        alias: AliasTy::Projection(projection_ty),
+        ..
+    })) = &goal.value.value
     {
         if let TyKind::BoundVar(_) = &projection_ty.substitution[0].interned(&Interner) {
             // Hack: don't ask Chalk to normalize with an unknown self type, it'll say that's impossible
diff --git a/crates/hir_ty/src/traits/chalk.rs b/crates/hir_ty/src/traits/chalk.rs
index 080764e76..734679414 100644
--- a/crates/hir_ty/src/traits/chalk.rs
+++ b/crates/hir_ty/src/traits/chalk.rs
@@ -21,8 +21,8 @@ use crate::{
     method_resolution::{TyFingerprint, ALL_FLOAT_FPS, ALL_INT_FPS},
     to_assoc_type_id, to_chalk_trait_id,
     utils::generics,
-    AliasEq, AliasTy, BoundVar, CallableDefId, CallableSig, DebruijnIndex, FnDefId,
-    GenericPredicate, ProjectionTy, Substitution, TraitRef, Ty, TyKind,
+    AliasEq, AliasTy, BoundVar, CallableDefId, CallableSig, DebruijnIndex, FnDefId, ProjectionTy,
+    Substitution, TraitRef, Ty, TyKind, WhereClause,
 };
 use mapping::{
     convert_where_clauses, generic_predicate_to_inline_bound, make_binders, TypeAliasAsValue,
@@ -187,13 +187,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
                 let data = &datas.value.impl_traits[idx as usize];
                 let bound = OpaqueTyDatumBound {
                     bounds: make_binders(
-                        data.bounds
-                            .value
-                            .iter()
-                            .cloned()
-                            .filter(|b| !b.is_error())
-                            .map(|b| b.to_chalk(self.db))
-                            .collect(),
+                        data.bounds.value.iter().cloned().map(|b| b.to_chalk(self.db)).collect(),
                         1,
                     ),
                     where_clauses: make_binders(vec![], 0),
@@ -218,7 +212,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
                     //        |-------------OpaqueTyDatumBound--------------|
                     // for<T> <Self> [Future<Self>, Future::Output<Self> = T]
                     //     ^1  ^0            ^0                    ^0      ^1
-                    let impl_bound = GenericPredicate::Implemented(TraitRef {
+                    let impl_bound = WhereClause::Implemented(TraitRef {
                         trait_id: to_chalk_trait_id(future_trait),
                         // Self type as the first parameter.
                         substitution: Substitution::single(
@@ -229,7 +223,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
                             .intern(&Interner),
                         ),
                     });
-                    let proj_bound = GenericPredicate::AliasEq(AliasEq {
+                    let proj_bound = WhereClause::AliasEq(AliasEq {
                         alias: AliasTy::Projection(ProjectionTy {
                             associated_ty_id: to_assoc_type_id(future_output),
                             // Self type as the first parameter.
diff --git a/crates/hir_ty/src/traits/chalk/mapping.rs b/crates/hir_ty/src/traits/chalk/mapping.rs
index 62b779008..65feb82e5 100644
--- a/crates/hir_ty/src/traits/chalk/mapping.rs
+++ b/crates/hir_ty/src/traits/chalk/mapping.rs
@@ -13,9 +13,9 @@ use crate::{
     db::HirDatabase,
     from_assoc_type_id,
     primitive::UintTy,
-    traits::{Canonical, Obligation},
-    AliasTy, CallableDefId, FnPointer, GenericPredicate, InEnvironment, OpaqueTy, ProjectionTy,
-    Scalar, Substitution, TraitRef, Ty,
+    traits::{Canonical, DomainGoal},
+    AliasTy, CallableDefId, FnPointer, InEnvironment, OpaqueTy, ProjectionTy, Scalar, Substitution,
+    TraitRef, Ty, WhereClause,
 };
 
 use super::interner::*;
@@ -98,7 +98,7 @@ impl ToChalk for Ty {
             TyKind::Dyn(predicates) => {
                 let where_clauses = chalk_ir::QuantifiedWhereClauses::from_iter(
                     &Interner,
-                    predicates.iter().filter(|p| !p.is_error()).cloned().map(|p| p.to_chalk(db)),
+                    predicates.iter().cloned().map(|p| p.to_chalk(db)),
                 );
                 let bounded_ty = chalk_ir::DynTy {
                     bounds: make_binders(where_clauses, 1),
@@ -304,28 +304,27 @@ impl ToChalk for TypeAliasAsValue {
     }
 }
 
-impl ToChalk for GenericPredicate {
+impl ToChalk for WhereClause {
     type Chalk = chalk_ir::QuantifiedWhereClause<Interner>;
 
     fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::QuantifiedWhereClause<Interner> {
         match self {
-            GenericPredicate::Implemented(trait_ref) => {
+            WhereClause::Implemented(trait_ref) => {
                 let chalk_trait_ref = trait_ref.to_chalk(db);
                 let chalk_trait_ref = chalk_trait_ref.shifted_in(&Interner);
                 make_binders(chalk_ir::WhereClause::Implemented(chalk_trait_ref), 0)
             }
-            GenericPredicate::AliasEq(alias_eq) => make_binders(
+            WhereClause::AliasEq(alias_eq) => make_binders(
                 chalk_ir::WhereClause::AliasEq(alias_eq.to_chalk(db).shifted_in(&Interner)),
                 0,
             ),
-            GenericPredicate::Error => panic!("tried passing GenericPredicate::Error to Chalk"),
         }
     }
 
     fn from_chalk(
         db: &dyn HirDatabase,
         where_clause: chalk_ir::QuantifiedWhereClause<Interner>,
-    ) -> GenericPredicate {
+    ) -> WhereClause {
         // we don't produce any where clauses with binders and can't currently deal with them
         match where_clause
             .skip_binders()
@@ -333,11 +332,9 @@ impl ToChalk for GenericPredicate {
             .shifted_out(&Interner)
             .expect("unexpected bound vars in where clause")
         {
-            chalk_ir::WhereClause::Implemented(tr) => {
-                GenericPredicate::Implemented(from_chalk(db, tr))
-            }
+            chalk_ir::WhereClause::Implemented(tr) => WhereClause::Implemented(from_chalk(db, tr)),
             chalk_ir::WhereClause::AliasEq(alias_eq) => {
-                GenericPredicate::AliasEq(from_chalk(db, alias_eq))
+                WhereClause::AliasEq(from_chalk(db, alias_eq))
             }
 
             chalk_ir::WhereClause::LifetimeOutlives(_) => {
@@ -425,13 +422,15 @@ impl ToChalk for AliasEq {
     }
 }
 
-impl ToChalk for Obligation {
+impl ToChalk for DomainGoal {
     type Chalk = chalk_ir::DomainGoal<Interner>;
 
     fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::DomainGoal<Interner> {
         match self {
-            Obligation::Trait(tr) => tr.to_chalk(db).cast(&Interner),
-            Obligation::AliasEq(alias_eq) => alias_eq.to_chalk(db).cast(&Interner),
+            DomainGoal::Holds(WhereClause::Implemented(tr)) => tr.to_chalk(db).cast(&Interner),
+            DomainGoal::Holds(WhereClause::AliasEq(alias_eq)) => {
+                alias_eq.to_chalk(db).cast(&Interner)
+            }
         }
     }
 
@@ -523,10 +522,6 @@ pub(super) fn convert_where_clauses(
     let generic_predicates = db.generic_predicates(def);
     let mut result = Vec::with_capacity(generic_predicates.len());
     for pred in generic_predicates.iter() {
-        if pred.value.is_error() {
-            // skip errored predicates completely
-            continue;
-        }
         result.push(pred.clone().subst(substs).to_chalk(db));
     }
     result
@@ -534,13 +529,13 @@ pub(super) fn convert_where_clauses(
 
 pub(super) fn generic_predicate_to_inline_bound(
     db: &dyn HirDatabase,
-    pred: &GenericPredicate,
+    pred: &WhereClause,
     self_ty: &Ty,
 ) -> Option<rust_ir::InlineBound<Interner>> {
     // An InlineBound is like a GenericPredicate, except the self type is left out.
     // We don't have a special type for this, but Chalk does.
     match pred {
-        GenericPredicate::Implemented(trait_ref) => {
+        WhereClause::Implemented(trait_ref) => {
             if &trait_ref.substitution[0] != self_ty {
                 // we can only convert predicates back to type bounds if they
                 // have the expected self type
@@ -553,7 +548,7 @@ pub(super) fn generic_predicate_to_inline_bound(
             let trait_bound = rust_ir::TraitBound { trait_id: trait_ref.trait_id, args_no_self };
             Some(rust_ir::InlineBound::TraitBound(trait_bound))
         }
-        GenericPredicate::AliasEq(AliasEq { alias: AliasTy::Projection(projection_ty), ty }) => {
+        WhereClause::AliasEq(AliasEq { alias: AliasTy::Projection(projection_ty), ty }) => {
             if &projection_ty.substitution[0] != self_ty {
                 return None;
             }
diff --git a/crates/hir_ty/src/utils.rs b/crates/hir_ty/src/utils.rs
index b66243d48..1ec1ecd43 100644
--- a/crates/hir_ty/src/utils.rs
+++ b/crates/hir_ty/src/utils.rs
@@ -15,7 +15,7 @@ use hir_def::{
 };
 use hir_expand::name::{name, Name};
 
-use crate::{db::HirDatabase, GenericPredicate, TraitRef};
+use crate::{db::HirDatabase, TraitRef, WhereClause};
 
 fn direct_super_traits(db: &dyn DefDatabase, trait_: TraitId) -> Vec<TraitId> {
     let resolver = trait_.resolver(db);
@@ -64,7 +64,7 @@ fn direct_super_trait_refs(db: &dyn HirDatabase, trait_ref: &TraitRef) -> Vec<Tr
         .iter()
         .filter_map(|pred| {
             pred.as_ref().filter_map(|pred| match pred {
-                GenericPredicate::Implemented(tr) => Some(tr.clone()),
+                WhereClause::Implemented(tr) => Some(tr.clone()),
                 _ => None,
             })
         })