to_assoc_type_id,
traits::{FnTrait, Solution, SolutionVariables},
AliasEq, AliasTy, BoundVar, CallableDefId, CallableSig, Canonical, DebruijnIndex,
- GenericPredicate, InEnvironment, Interner, Obligation, ProjectionTy, Scalar, Substitution, Ty,
- TyDefId, TyKind, TyVariableKind,
+ InEnvironment, Interner, Obligation, ProjectionTy, Scalar, Substitution, Ty, TyDefId, TyKind,
+ TyVariableKind, WhereClause,
};
use itertools::Itertools;
use rustc_hash::FxHashSet;
db.generic_predicates_for_param(self.id)
.into_iter()
.filter_map(|pred| match &pred.value {
- hir_ty::GenericPredicate::Implemented(trait_ref) => {
+ hir_ty::WhereClause::Implemented(trait_ref) => {
Some(Trait::from(trait_ref.hir_trait_id()))
}
_ => None,
self.ty.value.impl_trait_bounds(db).map(|it| {
it.into_iter()
.filter_map(|pred| match pred {
- hir_ty::GenericPredicate::Implemented(trait_ref) => {
+ hir_ty::WhereClause::Implemented(trait_ref) => {
Some(Trait::from(trait_ref.hir_trait_id()))
}
_ => None,
fn walk_bounds(
db: &dyn HirDatabase,
type_: &Type,
- bounds: &[GenericPredicate],
+ bounds: &[WhereClause],
cb: &mut impl FnMut(Type),
) {
for pred in bounds {
match pred {
- GenericPredicate::Implemented(trait_ref) => {
+ WhereClause::Implemented(trait_ref) => {
cb(type_.clone());
walk_substs(db, type_, &trait_ref.substitution, cb);
}
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;
#[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>;
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, ImplTraitId, Interner, Lifetime, Obligation, OpaqueTy,
+ ProjectionTy, Scalar, Substitution, TraitRef, Ty, TyKind, WhereClause,
};
pub struct HirFormatter<'a> {
_ => 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);
pub fn write_bounds_like_dyn_trait_with_prefix(
prefix: &str,
- predicates: &[GenericPredicate],
+ predicates: &[WhereClause],
f: &mut HirFormatter,
) -> Result<(), HirDisplayError> {
write!(f, "{}", 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.
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_);
}
}
}
- 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 {
}
ty.hir_fmt(f)?;
}
- GenericPredicate::Error => {
+ WhereClause::Error => {
if angle_open {
// impl Trait<X, {error}>
write!(f, ", ")?;
}
}
-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!(
)?;
ty.hir_fmt(f)?;
}
- GenericPredicate::AliasEq(_) | GenericPredicate::Error => write!(f, "{{error}}")?,
+ WhereClause::AliasEq(_) | WhereClause::Error => write!(f, "{{error}}")?,
}
Ok(())
}
use super::{InferenceContext, Obligation};
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> {
}
}
- 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))
/// 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
/// 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>`.
Error,
}
-impl GenericPredicate {
+impl WhereClause {
pub fn is_error(&self) -> bool {
- matches!(self, GenericPredicate::Error)
+ matches!(self, WhereClause::Error)
}
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(_) | WhereClause::Error => 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),
+ WhereClause::Error => {}
}
}
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),
+ WhereClause::Error => {}
}
}
}
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,
}
}
- 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()) {
// 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(),
});
#[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 {
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)]
// 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);
}
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 } => {
&'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),
- )
+ Some(bindings.clone().map_or(WhereClause::Error, WhereClause::Implemented))
}
TypeBound::Lifetime(_) => None,
- TypeBound::Error => Some(GenericPredicate::Error),
+ TypeBound::Error => Some(WhereClause::Error),
};
trait_ref.into_iter().chain(
bindings
&'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,
&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 {
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(
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();
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);
_db: &dyn HirDatabase,
_cycle: &[String],
_param_id: &TypeParamId,
-) -> Arc<[Binders<GenericPredicate>]> {
+) -> Arc<[Binders<WhereClause>]> {
Arc::new([])
}
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> =
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));
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);
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, TraitRef, Ty,
+ TyKind, TypeWalk, WhereClause,
};
use self::chalk::{from_chalk, Interner, ToChalk};
}
impl Obligation {
- pub fn from_predicate(predicate: GenericPredicate) -> Option<Obligation> {
+ pub fn from_predicate(predicate: WhereClause) -> 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,
+ WhereClause::Implemented(trait_ref) => Some(Obligation::Trait(trait_ref)),
+ WhereClause::AliasEq(alias_eq) => Some(Obligation::AliasEq(alias_eq)),
+ WhereClause::Error => None,
}
}
}
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,
// |-------------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(
.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.
from_assoc_type_id,
primitive::UintTy,
traits::{Canonical, Obligation},
- AliasTy, CallableDefId, FnPointer, GenericPredicate, InEnvironment, OpaqueTy, ProjectionTy,
- Scalar, Substitution, TraitRef, Ty,
+ AliasTy, CallableDefId, FnPointer, InEnvironment, OpaqueTy, ProjectionTy, Scalar, Substitution,
+ TraitRef, Ty, WhereClause,
};
use super::interner::*;
}
}
-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"),
+ WhereClause::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()
.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(_) => {
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
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;
}
};
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);
.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,
})
})
projects / rust.git / commitdiff