mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rename GenericPredicate -> WhereClause

Browse Source
This commit is contained in:
Florian Diebold 2021-03-20 10:46:36 +01:00
parent 8b16af590d
commit 7a5fb37cf1
10 changed files with 89 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
crates/hir/src/lib.rs
View File

@ -57,8 +57,8 @@
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;
@ -1461,7 +1461,7 @@ pub fn trait_bounds(self, db: &dyn HirDatabase) -> Vec<Trait> {
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,
@ -2022,7 +2022,7 @@ pub fn as_impl_traits(&self, db: &dyn HirDatabase) -> Option<Vec<Trait>> {
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,
@ -2060,12 +2060,12 @@ fn walk_substs(
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);
}

11
crates/hir_ty/src/db.rs
View File

@ -12,8 +12,8 @@
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 @@ fn return_type_impl_traits(
#[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>;

29
crates/hir_ty/src/display.rs
View File

@ -19,8 +19,8 @@
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> {
@ -353,7 +353,7 @@ fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
_ => 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,7 +731,7 @@ fn write_bounds_like_dyn_trait(
}
ty.hir_fmt(f)?;
}
GenericPredicate::Error => {
WhereClause::Error => {
if angle_open {
// impl Trait<X, {error}>
write!(f, ", ")?;
@ -778,18 +778,15 @@ fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
}
}
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 +796,7 @@ fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
)?;
ty.hir_fmt(f)?;
}
GenericPredicate::AliasEq(_) | GenericPredicate::Error => write!(f, "{{error}}")?,
WhereClause::AliasEq(_) | WhereClause::Error => write!(f, "{{error}}")?,
}
Ok(())
}

17
crates/hir_ty/src/infer/unify.rs
View File

@ -7,8 +7,8 @@
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> {
@ -382,21 +382,16 @@ pub(super) fn unify_inner_trivial(&mut self, ty1: &Ty, ty2: &Ty, depth: usize) -
}
}
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))

38
crates/hir_ty/src/lib.rs
View File

@ -276,7 +276,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,7 +564,7 @@ fn walk_mut_binders(
/// 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>`.
@ -574,32 +574,32 @@ pub enum GenericPredicate {
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 => {}
}
}
@ -609,9 +609,9 @@ fn walk_mut_binders(
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 => {}
}
}
}
@ -815,7 +815,7 @@ pub fn equals_ctor(&self, other: &Ty) -> bool {
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 +894,7 @@ fn substs_mut(&mut self) -> Option<&mut Substitution> {
}
}
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 +907,7 @@ pub fn impl_trait_bounds(&self, db: &dyn HirDatabase) -> Option<Vec<GenericPredi
// 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 +1166,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 {

37
crates/hir_ty/src/lower.rs
View File

@ -33,9 +33,9 @@
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 @@ pub(crate) fn lower_partly_resolved_path(
// 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 @@ fn trait_ref_substs_from_path(
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 @@ pub(crate) fn lower_type_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
@ -722,7 +719,7 @@ fn assoc_type_bindings_from_type_bound(
&'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 @@ fn assoc_type_bindings_from_type_bound(
&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 @@ fn assoc_type_bindings_from_type_bound(
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([])
}
@ -925,7 +922,7 @@ pub(crate) fn trait_environment_query(
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 +948,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 +963,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);

12
crates/hir_ty/src/traits.rs
View File

@ -9,8 +9,8 @@
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};
@ -96,11 +96,11 @@ pub enum Obligation {
}
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,
}
}
}

8
crates/hir_ty/src/traits/chalk.rs
View File

@ -21,8 +21,8 @@
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,
@ -218,7 +218,7 @@ fn opaque_ty_data(&self, id: chalk_ir::OpaqueTyId<Interner>) -> Arc<OpaqueTyDatu
// |-------------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 +229,7 @@ fn opaque_ty_data(&self, id: chalk_ir::OpaqueTyId<Interner>) -> Arc<OpaqueTyDatu
.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.

26
crates/hir_ty/src/traits/chalk/mapping.rs
View File

@ -14,8 +14,8 @@
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::*;
@ -304,28 +304,28 @@ fn from_chalk(
}
}
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()
@ -333,11 +333,9 @@ fn from_chalk(
.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(_) => {
@ -534,13 +532,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 +551,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;
}

4
crates/hir_ty/src/utils.rs
View File

@ -15,7 +15,7 @@
};
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,
})
})