squiid/rust
1
0
Fork 0
Code Issues Pull requests Projects Activity

Rename Substs -> Substitution

Browse source
This commit is contained in:
Florian Diebold 2021-03-15 21:02:34 +01:00
parent 00c80b208b
commit ce2cae45b5
17 changed files with 167 additions and 155 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
crates/hir/src/display.rs
View file

@ -13,7 +13,7 @@ use syntax::ast::{self, NameOwner};
use crate::{
Adt, Const, ConstParam, Enum, Field, Function, GenericParam, HasVisibility, LifetimeParam,
Module, Static, Struct, Substs, Trait, Type, TypeAlias, TypeParam, Union, Variant,
Module, Static, Struct, Substitution, Trait, Type, TypeAlias, TypeParam, Union, Variant,
};
impl HirDisplay for Function {
@ -235,7 +235,7 @@ impl HirDisplay for TypeParam {
fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
write!(f, "{}", self.name(f.db))?;
let bounds = f.db.generic_predicates_for_param(self.id);
let substs = Substs::type_params(f.db, self.id.parent);
let substs = Substitution::type_params(f.db, self.id.parent);
let predicates = bounds.iter().cloned().map(|b| b.subst(&substs)).collect::<Vec<_>>();
if !(predicates.is_empty() || f.omit_verbose_types()) {
write_bounds_like_dyn_trait_with_prefix(":", &predicates, f)?;

16
crates/hir/src/lib.rs
View file

@ -57,8 +57,8 @@ use hir_ty::{
to_assoc_type_id,
traits::{FnTrait, Solution, SolutionVariables},
AliasTy, BoundVar, CallableDefId, CallableSig, Canonical, DebruijnIndex, GenericPredicate,
InEnvironment, Interner, Obligation, ProjectionPredicate, ProjectionTy, Scalar, Substs, Ty,
TyDefId, TyKind, TyVariableKind,
InEnvironment, Interner, Obligation, ProjectionPredicate, ProjectionTy, Scalar, Substitution,
Ty, TyDefId, TyKind, TyVariableKind,
};
use itertools::Itertools;
use rustc_hash::FxHashSet;
@ -518,7 +518,7 @@ impl Field {
VariantDef::Union(it) => it.id.into(),
VariantDef::Variant(it) => it.parent.id.into(),
};
let substs = Substs::type_params(db, generic_def_id);
let substs = Substitution::type_params(db, generic_def_id);
let ty = db.field_types(var_id)[self.id].clone().subst(&substs);
Type::new(db, self.parent.module(db).id.krate(), var_id, ty)
}
@ -1471,7 +1471,7 @@ impl TypeParam {
let resolver = self.id.parent.resolver(db.upcast());
let krate = self.id.parent.module(db.upcast()).krate();
let ty = params.get(local_idx)?.clone();
let subst = Substs::type_params(db, self.id.parent);
let subst = Substitution::type_params(db, self.id.parent);
let ty = ty.subst(&subst.prefix(local_idx));
Some(Type::new_with_resolver_inner(db, krate, &resolver, ty))
}
@ -1674,7 +1674,7 @@ impl Type {
krate: CrateId,
def: impl HasResolver + Into<TyDefId> + Into<GenericDefId>,
) -> Type {
let substs = Substs::build_for_def(db, def).fill_with_unknown().build();
let substs = Substitution::build_for_def(db, def).fill_with_unknown().build();
let ty = db.ty(def.into()).subst(&substs);
Type::new(db, krate, def, ty)
}
@ -1754,7 +1754,7 @@ impl Type {
pub fn impls_trait(&self, db: &dyn HirDatabase, trait_: Trait, args: &[Type]) -> bool {
let trait_ref = hir_ty::TraitRef {
trait_: trait_.id,
substs: Substs::build_for_def(db, trait_.id)
substs: Substitution::build_for_def(db, trait_.id)
.push(self.ty.value.clone())
.fill(args.iter().map(|t| t.ty.value.clone()))
.build(),
@ -1778,7 +1778,7 @@ impl Type {
args: &[Type],
alias: TypeAlias,
) -> Option<Type> {
let subst = Substs::build_for_def(db, trait_.id)
let subst = Substitution::build_for_def(db, trait_.id)
.push(self.ty.value.clone())
.fill(args.iter().map(|t| t.ty.value.clone()))
.build();
@ -2045,7 +2045,7 @@ impl Type {
fn walk_substs(
db: &dyn HirDatabase,
type_: &Type,
substs: &Substs,
substs: &Substitution,
cb: &mut impl FnMut(Type),
) {
for ty in substs.iter() {

4
crates/hir/src/source_analyzer.rs
View file

@ -20,7 +20,7 @@ use hir_def::{
use hir_expand::{hygiene::Hygiene, name::AsName, HirFileId, InFile};
use hir_ty::{
diagnostics::{record_literal_missing_fields, record_pattern_missing_fields},
InferenceResult, Substs,
InferenceResult, Substitution,
};
use syntax::{
ast::{self, AstNode},
@ -329,7 +329,7 @@ impl SourceAnalyzer {
&self,
db: &dyn HirDatabase,
krate: CrateId,
substs: &Substs,
substs: &Substitution,
variant: VariantId,
missing_fields: Vec<LocalFieldId>,
) -> Vec<(Field, Type)> {

4
crates/hir_ty/src/autoderef.rs
View file

@ -15,7 +15,7 @@ use crate::{
to_assoc_type_id,
traits::{InEnvironment, Solution},
utils::generics,
BoundVar, Canonical, DebruijnIndex, Interner, Obligation, Substs, TraitRef, Ty, TyKind,
BoundVar, Canonical, DebruijnIndex, Interner, Obligation, Substitution, TraitRef, Ty, TyKind,
};
const AUTODEREF_RECURSION_LIMIT: usize = 10;
@ -65,7 +65,7 @@ fn deref_by_trait(
// FIXME make the Canonical / bound var handling nicer
let parameters =
Substs::build_for_generics(&generic_params).push(ty.value.value.clone()).build();
Substitution::build_for_generics(&generic_params).push(ty.value.value.clone()).build();
// Check that the type implements Deref at all
let trait_ref = TraitRef { trait_: deref_trait, substs: parameters.clone() };

4
crates/hir_ty/src/display.rs
View file

@ -20,7 +20,7 @@ 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, AliasTy, CallableDefId,
CallableSig, GenericPredicate, ImplTraitId, Interner, Lifetime, Obligation, OpaqueTy,
ProjectionTy, Scalar, Substs, TraitRef, Ty, TyKind,
ProjectionTy, Scalar, Substitution, TraitRef, Ty, TyKind,
};
pub struct HirFormatter<'a> {
@ -562,7 +562,7 @@ impl HirDisplay for Ty {
}
TypeParamProvenance::ArgumentImplTrait => {
let bounds = f.db.generic_predicates_for_param(id);
let substs = Substs::type_params_for_generics(f.db, &generics);
let substs = Substitution::type_params_for_generics(f.db, &generics);
write_bounds_like_dyn_trait_with_prefix(
"impl",
&bounds.iter().map(|b| b.clone().subst(&substs)).collect::<Vec<_>>(),

8
crates/hir_ty/src/infer.rs
View file

@ -38,7 +38,7 @@ use syntax::SmolStr;
use super::{
traits::{Guidance, Obligation, ProjectionPredicate, Solution},
InEnvironment, ProjectionTy, Substs, TraitEnvironment, TraitRef, Ty, TypeWalk,
InEnvironment, ProjectionTy, Substitution, TraitEnvironment, TraitRef, Ty, TypeWalk,
};
use crate::{
db::HirDatabase, infer::diagnostics::InferenceDiagnostic, lower::ImplTraitLoweringMode,
@ -390,7 +390,7 @@ impl<'a> InferenceContext<'a> {
_ => panic!("resolve_associated_type called with non-associated type"),
};
let ty = self.table.new_type_var();
let substs = Substs::build_for_def(self.db, res_assoc_ty)
let substs = Substitution::build_for_def(self.db, res_assoc_ty)
.push(inner_ty)
.fill(params.iter().cloned())
.build();
@ -469,7 +469,7 @@ impl<'a> InferenceContext<'a> {
}
TypeNs::SelfType(impl_id) => {
let generics = crate::utils::generics(self.db.upcast(), impl_id.into());
let substs = Substs::type_params_for_generics(self.db, &generics);
let substs = Substitution::type_params_for_generics(self.db, &generics);
let ty = self.db.impl_self_ty(impl_id).subst(&substs);
match unresolved {
None => {
@ -496,7 +496,7 @@ impl<'a> InferenceContext<'a> {
}
}
TypeNs::TypeAliasId(it) => {
let substs = Substs::build_for_def(self.db, it)
let substs = Substitution::build_for_def(self.db, it)
.fill(std::iter::repeat_with(|| self.table.new_type_var()))
.build();
let ty = self.db.ty(it.into()).subst(&substs);

6
crates/hir_ty/src/infer/coerce.rs
View file

@ -7,7 +7,9 @@
use chalk_ir::{Mutability, TyVariableKind};
use hir_def::lang_item::LangItemTarget;
use crate::{autoderef, traits::Solution, Interner, Obligation, Substs, TraitRef, Ty, TyKind};
use crate::{
autoderef, traits::Solution, Interner, Obligation, Substitution, TraitRef, Ty, TyKind,
};
use super::{InEnvironment, InferenceContext};
@ -134,7 +136,7 @@ impl<'a> InferenceContext<'a> {
return None;
}
let substs = Substs::build_for_generics(&generic_params)
let substs = Substitution::build_for_generics(&generic_params)
.push(from_ty.clone())
.push(to_ty.clone())
.build();

37
crates/hir_ty/src/infer/expr.rs
View file

@ -21,8 +21,8 @@ use crate::{
to_assoc_type_id,
traits::{chalk::from_chalk, FnTrait, InEnvironment},
utils::{generics, variant_data, Generics},
AdtId, Binders, CallableDefId, FnPointer, FnSig, Interner, Obligation, Rawness, Scalar, Substs,
TraitRef, Ty, TyKind,
AdtId, Binders, CallableDefId, FnPointer, FnSig, Interner, Obligation, Rawness, Scalar,
Substitution, TraitRef, Ty, TyKind,
};
use super::{
@ -77,7 +77,7 @@ impl<'a> InferenceContext<'a> {
return None;
}
let mut param_builder = Substs::builder(num_args);
let mut param_builder = Substitution::builder(num_args);
let mut arg_tys = vec![];
for _ in 0..num_args {
let arg = self.table.new_type_var();
@ -87,7 +87,7 @@ impl<'a> InferenceContext<'a> {
let parameters = param_builder.build();
let arg_ty = TyKind::Tuple(num_args, parameters).intern(&Interner);
let substs =
Substs::build_for_generics(&generic_params).push(ty.clone()).push(arg_ty).build();
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 =
@ -181,7 +181,7 @@ impl<'a> InferenceContext<'a> {
let inner_ty = self.infer_expr(*body, &Expectation::none());
let impl_trait_id = crate::ImplTraitId::AsyncBlockTypeImplTrait(self.owner, *body);
let opaque_ty_id = self.db.intern_impl_trait_id(impl_trait_id).into();
TyKind::OpaqueType(opaque_ty_id, Substs::single(inner_ty)).intern(&Interner)
TyKind::OpaqueType(opaque_ty_id, Substitution::single(inner_ty)).intern(&Interner)
}
Expr::Loop { body, label } => {
self.breakables.push(BreakableContext {
@ -262,12 +262,12 @@ impl<'a> InferenceContext<'a> {
let sig_ty = TyKind::Function(FnPointer {
num_args: sig_tys.len() - 1,
sig: FnSig { abi: (), safety: chalk_ir::Safety::Safe, variadic: false },
substs: Substs(sig_tys.clone().into()),
substs: Substitution(sig_tys.clone().into()),
})
.intern(&Interner);
let closure_id = self.db.intern_closure((self.owner, tgt_expr)).into();
let closure_ty =
TyKind::Closure(closure_id, Substs::single(sig_ty)).intern(&Interner);
TyKind::Closure(closure_id, Substitution::single(sig_ty)).intern(&Interner);
// Eagerly try to relate the closure type with the expected
// type, otherwise we often won't have enough information to
@ -402,7 +402,7 @@ impl<'a> InferenceContext<'a> {
self.unify(&ty, &expected.ty);
let substs = ty.substs().cloned().unwrap_or_else(Substs::empty);
let substs = ty.substs().cloned().unwrap_or_else(Substitution::empty);
let field_types = def_id.map(|it| self.db.field_types(it)).unwrap_or_default();
let variant_data = def_id.map(|it| variant_data(self.db.upcast(), it));
for field in fields.iter() {
@ -511,7 +511,8 @@ impl<'a> InferenceContext<'a> {
Expr::Box { expr } => {
let inner_ty = self.infer_expr_inner(*expr, &Expectation::none());
if let Some(box_) = self.resolve_boxed_box() {
let mut sb = Substs::builder(generics(self.db.upcast(), box_.into()).len());
let mut sb =
Substitution::builder(generics(self.db.upcast(), box_.into()).len());
sb = sb.push(inner_ty);
match self.db.generic_defaults(box_.into()).as_ref() {
[_, alloc_ty, ..] if !alloc_ty.value.is_unknown() => {
@ -610,31 +611,31 @@ impl<'a> InferenceContext<'a> {
let rhs_ty = rhs.map(|e| self.infer_expr(e, &rhs_expect));
match (range_type, lhs_ty, rhs_ty) {
(RangeOp::Exclusive, None, None) => match self.resolve_range_full() {
Some(adt) => Ty::adt_ty(adt, Substs::empty()),
Some(adt) => Ty::adt_ty(adt, Substitution::empty()),
None => self.err_ty(),
},
(RangeOp::Exclusive, None, Some(ty)) => match self.resolve_range_to() {
Some(adt) => Ty::adt_ty(adt, Substs::single(ty)),
Some(adt) => Ty::adt_ty(adt, Substitution::single(ty)),
None => self.err_ty(),
},
(RangeOp::Inclusive, None, Some(ty)) => {
match self.resolve_range_to_inclusive() {
Some(adt) => Ty::adt_ty(adt, Substs::single(ty)),
Some(adt) => Ty::adt_ty(adt, Substitution::single(ty)),
None => self.err_ty(),
}
}
(RangeOp::Exclusive, Some(_), Some(ty)) => match self.resolve_range() {
Some(adt) => Ty::adt_ty(adt, Substs::single(ty)),
Some(adt) => Ty::adt_ty(adt, Substitution::single(ty)),
None => self.err_ty(),
},
(RangeOp::Inclusive, Some(_), Some(ty)) => {
match self.resolve_range_inclusive() {
Some(adt) => Ty::adt_ty(adt, Substs::single(ty)),
Some(adt) => Ty::adt_ty(adt, Substitution::single(ty)),
None => self.err_ty(),
}
}
(RangeOp::Exclusive, Some(ty), None) => match self.resolve_range_from() {
Some(adt) => Ty::adt_ty(adt, Substs::single(ty)),
Some(adt) => Ty::adt_ty(adt, Substitution::single(ty)),
None => self.err_ty(),
},
(RangeOp::Inclusive, _, None) => self.err_ty(),
@ -681,7 +682,7 @@ impl<'a> InferenceContext<'a> {
self.infer_expr_coerce(*expr, &Expectation::has_type(ty.clone()));
}
TyKind::Tuple(tys.len(), Substs(tys.into())).intern(&Interner)
TyKind::Tuple(tys.len(), Substitution(tys.into())).intern(&Interner)
}
Expr::Array(array) => {
let elem_ty = match expected.ty.interned(&Interner) {
@ -887,7 +888,7 @@ impl<'a> InferenceContext<'a> {
def_generics: Option<Generics>,
generic_args: Option<&GenericArgs>,
receiver_ty: &Ty,
) -> Substs {
) -> Substitution {
let (parent_params, self_params, type_params, impl_trait_params) =
def_generics.as_ref().map_or((0, 0, 0, 0), |g| g.provenance_split());
assert_eq!(self_params, 0); // method shouldn't have another Self param
@ -926,7 +927,7 @@ impl<'a> InferenceContext<'a> {
substs.push(self.err_ty());
}
assert_eq!(substs.len(), total_len);
Substs(substs.into())
Substitution(substs.into())
}
fn register_obligations_for_call(&mut self, callable_ty: &Ty) {

12
crates/hir_ty/src/infer/pat.rs
View file

@ -12,7 +12,9 @@ use hir_def::{
use hir_expand::name::Name;
use super::{BindingMode, Expectation, InferenceContext};
use crate::{lower::lower_to_chalk_mutability, utils::variant_data, Interner, Substs, Ty, TyKind};
use crate::{
lower::lower_to_chalk_mutability, utils::variant_data, Interner, Substitution, Ty, TyKind,
};
impl<'a> InferenceContext<'a> {
fn infer_tuple_struct_pat(
@ -31,7 +33,7 @@ impl<'a> InferenceContext<'a> {
}
self.unify(&ty, expected);
let substs = ty.substs().cloned().unwrap_or_else(Substs::empty);
let substs = ty.substs().cloned().unwrap_or_else(Substitution::empty);
let field_tys = def.map(|it| self.db.field_types(it)).unwrap_or_default();
let (pre, post) = match ellipsis {
@ -70,7 +72,7 @@ impl<'a> InferenceContext<'a> {
self.unify(&ty, expected);
let substs = ty.substs().cloned().unwrap_or_else(Substs::empty);
let substs = ty.substs().cloned().unwrap_or_else(Substitution::empty);
let field_tys = def.map(|it| self.db.field_types(it)).unwrap_or_default();
for subpat in subpats {
@ -138,7 +140,7 @@ impl<'a> InferenceContext<'a> {
inner_tys.extend(expectations_iter.by_ref().take(n_uncovered_patterns).cloned());
inner_tys.extend(post.iter().zip(expectations_iter).map(infer_pat));
TyKind::Tuple(inner_tys.len(), Substs(inner_tys.into())).intern(&Interner)
TyKind::Tuple(inner_tys.len(), Substitution(inner_tys.into())).intern(&Interner)
}
Pat::Or(ref pats) => {
if let Some((first_pat, rest)) = pats.split_first() {
@ -237,7 +239,7 @@ impl<'a> InferenceContext<'a> {
};
let inner_ty = self.infer_pat(*inner, &inner_expected, default_bm);
Ty::adt_ty(box_adt, Substs::single(inner_ty))
Ty::adt_ty(box_adt, Substitution::single(inner_ty))
}
None => self.err_ty(),
},

20
crates/hir_ty/src/infer/path.rs
View file

@ -9,7 +9,7 @@ use hir_def::{
};
use hir_expand::name::Name;
use crate::{method_resolution, Interner, Substs, Ty, TyKind, ValueTyDefId};
use crate::{method_resolution, Interner, Substitution, Ty, TyKind, ValueTyDefId};
use super::{ExprOrPatId, InferenceContext, TraitRef};
@ -79,7 +79,7 @@ impl<'a> InferenceContext<'a> {
}
ValueNs::ImplSelf(impl_id) => {
let generics = crate::utils::generics(self.db.upcast(), impl_id.into());
let substs = Substs::type_params_for_generics(self.db, &generics);
let substs = Substitution::type_params_for_generics(self.db, &generics);
let ty = self.db.impl_self_ty(impl_id).subst(&substs);
if let Some((AdtId::StructId(struct_id), substs)) = ty.as_adt() {
let ty = self.db.value_ty(struct_id.into()).subst(&substs);
@ -94,10 +94,10 @@ impl<'a> InferenceContext<'a> {
let ty = self.db.value_ty(typable);
// self_subst is just for the parent
let parent_substs = self_subst.unwrap_or_else(Substs::empty);
let parent_substs = self_subst.unwrap_or_else(Substitution::empty);
let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver);
let substs = ctx.substs_from_path(path, typable, true);
let full_substs = Substs::builder(substs.len())
let full_substs = Substitution::builder(substs.len())
.use_parent_substs(&parent_substs)
.fill(substs.0[parent_substs.len()..].iter().cloned())
.build();
@ -111,7 +111,7 @@ impl<'a> InferenceContext<'a> {
path: &Path,
remaining_index: usize,
id: ExprOrPatId,
) -> Option<(ValueNs, Option<Substs>)> {
) -> Option<(ValueNs, Option<Substitution>)> {
assert!(remaining_index < path.segments().len());
// there may be more intermediate segments between the resolved one and
// the end. Only the last segment needs to be resolved to a value; from
@ -164,7 +164,7 @@ impl<'a> InferenceContext<'a> {
trait_ref: TraitRef,
segment: PathSegment<'_>,
id: ExprOrPatId,
) -> Option<(ValueNs, Option<Substs>)> {
) -> Option<(ValueNs, Option<Substitution>)> {
let trait_ = trait_ref.trait_;
let item =
self.db.trait_data(trait_).items.iter().map(|(_name, id)| (*id)).find_map(|item| {
@ -208,7 +208,7 @@ impl<'a> InferenceContext<'a> {
ty: Ty,
name: &Name,
id: ExprOrPatId,
) -> Option<(ValueNs, Option<Substs>)> {
) -> Option<(ValueNs, Option<Substitution>)> {
if let TyKind::Unknown = ty.interned(&Interner) {
return None;
}
@ -241,7 +241,7 @@ impl<'a> InferenceContext<'a> {
};
let substs = match container {
AssocContainerId::ImplId(impl_id) => {
let impl_substs = Substs::build_for_def(self.db, impl_id)
let impl_substs = Substitution::build_for_def(self.db, impl_id)
.fill(iter::repeat_with(|| self.table.new_type_var()))
.build();
let impl_self_ty = self.db.impl_self_ty(impl_id).subst(&impl_substs);
@ -250,7 +250,7 @@ impl<'a> InferenceContext<'a> {
}
AssocContainerId::TraitId(trait_) => {
// we're picking this method
let trait_substs = Substs::build_for_def(self.db, trait_)
let trait_substs = Substitution::build_for_def(self.db, trait_)
.push(ty.clone())
.fill(std::iter::repeat_with(|| self.table.new_type_var()))
.build();
@ -274,7 +274,7 @@ impl<'a> InferenceContext<'a> {
ty: &Ty,
name: &Name,
id: ExprOrPatId,
) -> Option<(ValueNs, Option<Substs>)> {
) -> Option<(ValueNs, Option<Substitution>)> {
let (enum_id, subst) = match ty.as_adt() {
Some((AdtId::EnumId(e), subst)) => (e, subst),
_ => return None,

16
crates/hir_ty/src/infer/unify.rs
View file

@ -8,7 +8,7 @@ use ena::unify::{InPlaceUnificationTable, NoError, UnifyKey, UnifyValue};
use super::{InferenceContext, Obligation};
use crate::{
BoundVar, Canonical, DebruijnIndex, FnPointer, GenericPredicate, InEnvironment, InferenceVar,
Interner, Scalar, Substs, Ty, TyKind, TypeWalk,
Interner, Scalar, Substitution, Ty, TyKind, TypeWalk,
};
impl<'a> InferenceContext<'a> {
@ -123,10 +123,10 @@ impl<T> Canonicalized<T> {
pub(super) fn apply_solution(
&self,
ctx: &mut InferenceContext<'_>,
solution: Canonical<Substs>,
solution: Canonical<Substitution>,
) {
// the solution may contain new variables, which we need to convert to new inference vars
let new_vars = Substs(
let new_vars = Substitution(
solution
.kinds
.iter()
@ -147,9 +147,9 @@ impl<T> Canonicalized<T> {
}
}
pub(crate) fn unify(tys: &Canonical<(Ty, Ty)>) -> Option<Substs> {
pub(crate) fn unify(tys: &Canonical<(Ty, Ty)>) -> Option<Substitution> {
let mut table = InferenceTable::new();
let vars = Substs(
let vars = Substitution(
tys.kinds
.iter()
// we always use type vars here because we want everything to
@ -173,7 +173,7 @@ pub(crate) fn unify(tys: &Canonical<(Ty, Ty)>) -> Option<Substs> {
}
}
Some(
Substs::builder(tys.kinds.len())
Substitution::builder(tys.kinds.len())
.fill(vars.iter().map(|v| table.resolve_ty_completely(v.clone())))
.build(),
)
@ -264,8 +264,8 @@ impl InferenceTable {
pub(crate) fn unify_substs(
&mut self,
substs1: &Substs,
substs2: &Substs,
substs1: &Substitution,
substs2: &Substitution,
depth: usize,
) -> bool {
substs1.0.iter().zip(substs2.0.iter()).all(|(t1, t2)| self.unify_inner(t1, t2, depth))

94
crates/hir_ty/src/lib.rs
View file

@ -67,7 +67,7 @@ pub enum Lifetime {
#[derive(Clone, PartialEq, Eq, Debug, Hash)]
pub struct OpaqueTy {
pub opaque_ty_id: OpaqueTyId,
pub substitution: Substs,
pub substitution: Substitution,
}
/// A "projection" type corresponds to an (unnormalized)
@ -76,7 +76,7 @@ pub struct OpaqueTy {
#[derive(Clone, PartialEq, Eq, Debug, Hash)]
pub struct ProjectionTy {
pub associated_ty_id: AssocTypeId,
pub substitution: Substs,
pub substitution: Substitution,
}
impl ProjectionTy {
@ -112,7 +112,7 @@ pub type FnSig = chalk_ir::FnSig<Interner>;
pub struct FnPointer {
pub num_args: usize,
pub sig: FnSig,
pub substs: Substs,
pub substs: Substitution,
}
#[derive(Clone, PartialEq, Eq, Debug, Hash)]
@ -137,19 +137,19 @@ pub enum AliasTy {
#[derive(Clone, PartialEq, Eq, Debug, Hash)]
pub enum TyKind {
/// Structures, enumerations and unions.
Adt(AdtId<Interner>, Substs),
Adt(AdtId<Interner>, Substitution),
/// Represents an associated item like `Iterator::Item`. This is used
/// when we have tried to normalize a projection like `T::Item` but
/// couldn't find a better representation. In that case, we generate
/// an **application type** like `(Iterator::Item)<T>`.
AssociatedType(AssocTypeId, Substs),
AssociatedType(AssocTypeId, Substitution),
/// a scalar type like `bool` or `u32`
Scalar(Scalar),
/// A tuple type. For example, `(i32, bool)`.
Tuple(usize, Substs),
Tuple(usize, Substitution),
/// An array with the given length. Written as `[T; n]`.
Array(Ty),
@ -169,7 +169,7 @@ pub enum TyKind {
/// analogous to the `AssociatedType` type constructor.
/// It is also used as the type of async block, with one type parameter
/// representing the Future::Output type.
OpaqueType(OpaqueTyId, Substs),
OpaqueType(OpaqueTyId, Substitution),
/// The anonymous type of a function declaration/definition. Each
/// function has a unique type, which is output (for a function
@ -183,7 +183,7 @@ pub enum TyKind {
/// fn foo() -> i32 { 1 }
/// let bar = foo; // bar: fn() -> i32 {foo}
/// ```
FnDef(FnDefId, Substs),
FnDef(FnDefId, Substitution),
/// The pointee of a string slice. Written as `str`.
Str,
@ -195,7 +195,7 @@ pub enum TyKind {
///
/// The closure signature is stored in a `FnPtr` type in the first type
/// parameter.
Closure(ClosureId, Substs),
Closure(ClosureId, Substitution),
/// Represents a foreign type declared in external blocks.
ForeignType(ForeignDefId),
@ -273,9 +273,9 @@ impl Ty {
/// A list of substitutions for generic parameters.
#[derive(Clone, PartialEq, Eq, Debug, Hash)]
pub struct Substs(SmallVec<[Ty; 2]>);
pub struct Substitution(SmallVec<[Ty; 2]>);
impl TypeWalk for Substs {
impl TypeWalk for Substitution {
fn walk(&self, f: &mut impl FnMut(&Ty)) {
for t in self.0.iter() {
t.walk(f);
@ -293,29 +293,29 @@ impl TypeWalk for Substs {
}
}
impl Substs {
impl Substitution {
pub fn interned(&self, _: &Interner) -> &[Ty] {
&self.0
}
pub fn empty() -> Substs {
Substs(SmallVec::new())
pub fn empty() -> Substitution {
Substitution(SmallVec::new())
}
pub fn single(ty: Ty) -> Substs {
Substs({
pub fn single(ty: Ty) -> Substitution {
Substitution({
let mut v = SmallVec::new();
v.push(ty);
v
})
}
pub fn prefix(&self, n: usize) -> Substs {
Substs(self.0[..std::cmp::min(self.0.len(), n)].into())
pub fn prefix(&self, n: usize) -> Substitution {
Substitution(self.0[..std::cmp::min(self.0.len(), n)].into())
}
pub fn suffix(&self, n: usize) -> Substs {
Substs(self.0[self.0.len() - std::cmp::min(self.0.len(), n)..].into())
pub fn suffix(&self, n: usize) -> Substitution {
Substitution(self.0[self.0.len() - std::cmp::min(self.0.len(), n)..].into())
}
pub fn as_single(&self) -> &Ty {
@ -326,15 +326,15 @@ impl Substs {
}
pub fn from_iter(_interner: &Interner, elements: impl IntoIterator<Item = Ty>) -> Self {
Substs(elements.into_iter().collect())
Substitution(elements.into_iter().collect())
}
/// Return Substs that replace each parameter by itself (i.e. `Ty::Param`).
pub(crate) fn type_params_for_generics(
db: &dyn HirDatabase,
generic_params: &Generics,
) -> Substs {
Substs(
) -> Substitution {
Substitution(
generic_params
.iter()
.map(|(id, _)| TyKind::Placeholder(to_placeholder_idx(db, id)).intern(&Interner))
@ -343,14 +343,14 @@ impl Substs {
}
/// Return Substs that replace each parameter by itself (i.e. `Ty::Param`).
pub fn type_params(db: &dyn HirDatabase, def: impl Into<GenericDefId>) -> Substs {
pub fn type_params(db: &dyn HirDatabase, def: impl Into<GenericDefId>) -> Substitution {
let params = generics(db.upcast(), def.into());
Substs::type_params_for_generics(db, &params)
Substitution::type_params_for_generics(db, &params)
}
/// Return Substs that replace each parameter by a bound variable.
pub(crate) fn bound_vars(generic_params: &Generics, debruijn: DebruijnIndex) -> Substs {
Substs(
pub(crate) fn bound_vars(generic_params: &Generics, debruijn: DebruijnIndex) -> Substitution {
Substitution(
generic_params
.iter()
.enumerate()
@ -363,11 +363,11 @@ impl Substs {
let def = def.into();
let params = generics(db.upcast(), def);
let param_count = params.len();
Substs::builder(param_count)
Substitution::builder(param_count)
}
pub(crate) fn build_for_generics(generic_params: &Generics) -> SubstsBuilder {
Substs::builder(generic_params.len())
Substitution::builder(generic_params.len())
}
fn builder(param_count: usize) -> SubstsBuilder {
@ -387,9 +387,9 @@ pub struct SubstsBuilder {
}
impl SubstsBuilder {
pub fn build(self) -> Substs {
pub fn build(self) -> Substitution {
assert_eq!(self.vec.len(), self.param_count);
Substs(self.vec.into())
Substitution(self.vec.into())
}
pub fn push(mut self, ty: Ty) -> Self {
@ -418,7 +418,7 @@ impl SubstsBuilder {
self
}
pub fn use_parent_substs(mut self, parent_substs: &Substs) -> Self {
pub fn use_parent_substs(mut self, parent_substs: &Substitution) -> Self {
assert!(self.vec.is_empty());
assert!(parent_substs.len() <= self.param_count);
self.vec.extend(parent_substs.iter().cloned());
@ -426,7 +426,7 @@ impl SubstsBuilder {
}
}
impl Deref for Substs {
impl Deref for Substitution {
type Target = [Ty];
fn deref(&self) -> &[Ty] {
@ -466,13 +466,13 @@ impl<T: Clone> Binders<&T> {
impl<T: TypeWalk> Binders<T> {
/// Substitutes all variables.
pub fn subst(self, subst: &Substs) -> T {
pub fn subst(self, subst: &Substitution) -> T {
assert_eq!(subst.len(), self.num_binders);
self.value.subst_bound_vars(subst)
}
/// Substitutes just a prefix of the variables (shifting the rest).
pub fn subst_prefix(self, subst: &Substs) -> Binders<T> {
pub fn subst_prefix(self, subst: &Substitution) -> Binders<T> {
assert!(subst.len() < self.num_binders);
Binders::new(self.num_binders - subst.len(), self.value.subst_bound_vars(subst))
}
@ -498,7 +498,7 @@ impl<T: TypeWalk> TypeWalk for Binders<T> {
pub struct TraitRef {
/// FIXME name?
pub trait_: TraitId,
pub substs: Substs,
pub substs: Substitution,
}
impl TraitRef {
@ -618,7 +618,7 @@ impl CallableSig {
}
}
pub fn from_substs(substs: &Substs) -> CallableSig {
pub fn from_substs(substs: &Substitution) -> CallableSig {
CallableSig { params_and_return: substs.iter().cloned().collect(), is_varargs: false }
}
@ -651,10 +651,10 @@ impl TypeWalk for CallableSig {
impl Ty {
pub fn unit() -> Self {
TyKind::Tuple(0, Substs::empty()).intern(&Interner)
TyKind::Tuple(0, Substitution::empty()).intern(&Interner)
}
pub fn adt_ty(adt: hir_def::AdtId, substs: Substs) -> Ty {
pub fn adt_ty(adt: hir_def::AdtId, substs: Substitution) -> Ty {
TyKind::Adt(AdtId(adt), substs).intern(&Interner)
}
@ -662,7 +662,7 @@ impl Ty {
TyKind::Function(FnPointer {
num_args: sig.params().len(),
sig: FnSig { abi: (), safety: Safety::Safe, variadic: sig.is_varargs },
substs: Substs::from_iter(&Interner, sig.params_and_return.iter().cloned()),
substs: Substitution::from_iter(&Interner, sig.params_and_return.iter().cloned()),
})
.intern(&Interner)
}
@ -709,14 +709,14 @@ impl Ty {
t
}
pub fn as_adt(&self) -> Option<(hir_def::AdtId, &Substs)> {
pub fn as_adt(&self) -> Option<(hir_def::AdtId, &Substitution)> {
match self.interned(&Interner) {
TyKind::Adt(AdtId(adt), parameters) => Some((*adt, parameters)),
_ => None,
}
}
pub fn as_tuple(&self) -> Option<&Substs> {
pub fn as_tuple(&self) -> Option<&Substitution> {
match self.interned(&Interner) {
TyKind::Tuple(_, substs) => Some(substs),
_ => None,
@ -828,7 +828,7 @@ impl Ty {
/// Returns the type parameters of this type if it has some (i.e. is an ADT
/// or function); so if `self` is `Option<u32>`, this returns the `u32`.
pub fn substs(&self) -> Option<&Substs> {
pub fn substs(&self) -> Option<&Substitution> {
match self.interned(&Interner) {
TyKind::Adt(_, substs)
| TyKind::FnDef(_, substs)
@ -841,7 +841,7 @@ impl Ty {
}
}
fn substs_mut(&mut self) -> Option<&mut Substs> {
fn substs_mut(&mut self) -> Option<&mut Substitution> {
match self.interned_mut() {
TyKind::Adt(_, substs)
| TyKind::FnDef(_, substs)
@ -869,7 +869,7 @@ impl Ty {
// So just provide the Future trait.
let impl_bound = GenericPredicate::Implemented(TraitRef {
trait_: future_trait,
substs: Substs::empty(),
substs: Substitution::empty(),
});
Some(vec![impl_bound])
} else {
@ -992,7 +992,7 @@ pub trait TypeWalk {
}
/// Substitutes `TyKind::Bound` vars with the given substitution.
fn subst_bound_vars(self, substs: &Substs) -> Self
fn subst_bound_vars(self, substs: &Substitution) -> Self
where
Self: Sized,
{
@ -1000,7 +1000,7 @@ pub trait TypeWalk {
}
/// Substitutes `TyKind::Bound` vars with the given substitution.
fn subst_bound_vars_at_depth(mut self, substs: &Substs, depth: DebruijnIndex) -> Self
fn subst_bound_vars_at_depth(mut self, substs: &Substitution, depth: DebruijnIndex) -> Self
where
Self: Sized,
{

46
crates/hir_ty/src/lower.rs
View file

@ -35,7 +35,7 @@ use crate::{
},
AliasTy, Binders, BoundVar, CallableSig, DebruijnIndex, FnPointer, FnSig, GenericPredicate,
ImplTraitId, OpaqueTy, PolyFnSig, ProjectionPredicate, ProjectionTy, ReturnTypeImplTrait,
ReturnTypeImplTraits, Substs, TraitEnvironment, TraitRef, Ty, TyKind, TypeWalk,
ReturnTypeImplTraits, Substitution, TraitEnvironment, TraitRef, Ty, TyKind, TypeWalk,
};
#[derive(Debug)]
@ -151,7 +151,7 @@ impl<'a> TyLoweringContext<'a> {
TypeRef::Never => TyKind::Never.intern(&Interner),
TypeRef::Tuple(inner) => {
let inner_tys = inner.iter().map(|tr| self.lower_ty(tr));
TyKind::Tuple(inner_tys.len(), Substs::from_iter(&Interner, inner_tys))
TyKind::Tuple(inner_tys.len(), Substitution::from_iter(&Interner, inner_tys))
.intern(&Interner)
}
TypeRef::Path(path) => {
@ -177,7 +177,7 @@ impl<'a> TyLoweringContext<'a> {
}
TypeRef::Placeholder => TyKind::Unknown.intern(&Interner),
TypeRef::Fn(params, is_varargs) => {
let substs = Substs(params.iter().map(|tr| self.lower_ty(tr)).collect());
let substs = Substitution(params.iter().map(|tr| self.lower_ty(tr)).collect());
TyKind::Function(FnPointer {
num_args: substs.len() - 1,
sig: FnSig { abi: (), safety: Safety::Safe, variadic: *is_varargs },
@ -228,7 +228,7 @@ impl<'a> TyLoweringContext<'a> {
let impl_trait_id = ImplTraitId::ReturnTypeImplTrait(func, idx);
let opaque_ty_id = self.db.intern_impl_trait_id(impl_trait_id).into();
let generics = generics(self.db.upcast(), func.into());
let parameters = Substs::bound_vars(&generics, self.in_binders);
let parameters = Substitution::bound_vars(&generics, self.in_binders);
TyKind::Alias(AliasTy::Opaque(OpaqueTy {
opaque_ty_id,
substitution: parameters,
@ -398,10 +398,10 @@ impl<'a> TyLoweringContext<'a> {
let generics = generics(self.db.upcast(), impl_id.into());
let substs = match self.type_param_mode {
TypeParamLoweringMode::Placeholder => {
Substs::type_params_for_generics(self.db, &generics)
Substitution::type_params_for_generics(self.db, &generics)
}
TypeParamLoweringMode::Variable => {
Substs::bound_vars(&generics, self.in_binders)
Substitution::bound_vars(&generics, self.in_binders)
}
};
self.db.impl_self_ty(impl_id).subst(&substs)
@ -410,10 +410,10 @@ impl<'a> TyLoweringContext<'a> {
let generics = generics(self.db.upcast(), adt.into());
let substs = match self.type_param_mode {
TypeParamLoweringMode::Placeholder => {
Substs::type_params_for_generics(self.db, &generics)
Substitution::type_params_for_generics(self.db, &generics)
}
TypeParamLoweringMode::Variable => {
Substs::bound_vars(&generics, self.in_binders)
Substitution::bound_vars(&generics, self.in_binders)
}
};
self.db.ty(adt.into()).subst(&substs)
@ -464,7 +464,7 @@ impl<'a> TyLoweringContext<'a> {
TypeParamLoweringMode::Placeholder => {
// if we're lowering to placeholders, we have to put
// them in now
let s = Substs::type_params(
let s = Substitution::type_params(
self.db,
self.resolver.generic_def().expect(
"there should be generics if there's a generic param",
@ -522,7 +522,7 @@ impl<'a> TyLoweringContext<'a> {
// special-case enum variants
resolved: ValueTyDefId,
infer_args: bool,
) -> Substs {
) -> Substitution {
let last = path.segments().last().expect("path should have at least one segment");
let (segment, generic_def) = match resolved {
ValueTyDefId::FunctionId(it) => (last, Some(it.into())),
@ -553,7 +553,7 @@ impl<'a> TyLoweringContext<'a> {
segment: PathSegment<'_>,
def_generic: Option<GenericDefId>,
infer_args: bool,
) -> Substs {
) -> Substitution {
let mut substs = Vec::new();
let def_generics = def_generic.map(|def| generics(self.db.upcast(), def));
@ -601,7 +601,7 @@ impl<'a> TyLoweringContext<'a> {
for default_ty in defaults.iter().skip(substs.len()) {
// each default can depend on the previous parameters
let substs_so_far = Substs(substs.clone().into());
let substs_so_far = Substitution(substs.clone().into());
substs.push(default_ty.clone().subst(&substs_so_far));
}
}
@ -614,7 +614,7 @@ impl<'a> TyLoweringContext<'a> {
}
assert_eq!(substs.len(), total_len);
Substs(substs.into())
Substitution(substs.into())
}
fn lower_trait_ref_from_path(
@ -656,7 +656,11 @@ impl<'a> TyLoweringContext<'a> {
self.lower_trait_ref_from_path(path, explicit_self_ty)
}
fn trait_ref_substs_from_path(&self, segment: PathSegment<'_>, resolved: TraitId) -> Substs {
fn trait_ref_substs_from_path(
&self,
segment: PathSegment<'_>,
resolved: TraitId,
) -> Substitution {
self.substs_from_path_segment(segment, Some(resolved.into()), false)
}
@ -817,7 +821,7 @@ pub fn associated_type_shorthand_candidates<R>(
{
let trait_ref = TraitRef {
trait_: trait_id,
substs: Substs::bound_vars(&generics, DebruijnIndex::INNERMOST),
substs: Substitution::bound_vars(&generics, DebruijnIndex::INNERMOST),
};
traits_.push(trait_ref);
}
@ -945,7 +949,7 @@ pub(crate) fn trait_environment_query(
// function default implementations (and hypothetical code
// inside consts or type aliases)
cov_mark::hit!(trait_self_implements_self);
let substs = Substs::type_params(db, trait_id);
let substs = Substitution::type_params(db, trait_id);
let trait_ref = TraitRef { trait_: trait_id, substs };
let pred = GenericPredicate::Implemented(trait_ref);
let program_clause: chalk_ir::ProgramClause<Interner> =
@ -1033,7 +1037,7 @@ fn fn_sig_for_fn(db: &dyn HirDatabase, def: FunctionId) -> PolyFnSig {
/// function body.
fn type_for_fn(db: &dyn HirDatabase, def: FunctionId) -> Binders<Ty> {
let generics = generics(db.upcast(), def.into());
let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST);
let substs = Substitution::bound_vars(&generics, DebruijnIndex::INNERMOST);
Binders::new(
substs.len(),
TyKind::FnDef(CallableDefId::FunctionId(def).to_chalk(db), substs).intern(&Interner),
@ -1078,7 +1082,7 @@ fn type_for_struct_constructor(db: &dyn HirDatabase, def: StructId) -> Binders<T
return type_for_adt(db, def.into());
}
let generics = generics(db.upcast(), def.into());
let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST);
let substs = Substitution::bound_vars(&generics, DebruijnIndex::INNERMOST);
Binders::new(
substs.len(),
TyKind::FnDef(CallableDefId::StructId(def).to_chalk(db), substs).intern(&Interner),
@ -1105,7 +1109,7 @@ fn type_for_enum_variant_constructor(db: &dyn HirDatabase, def: EnumVariantId) -
return type_for_adt(db, def.parent.into());
}
let generics = generics(db.upcast(), def.parent.into());
let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST);
let substs = Substitution::bound_vars(&generics, DebruijnIndex::INNERMOST);
Binders::new(
substs.len(),
TyKind::FnDef(CallableDefId::EnumVariantId(def).to_chalk(db), substs).intern(&Interner),
@ -1114,7 +1118,7 @@ fn type_for_enum_variant_constructor(db: &dyn HirDatabase, def: EnumVariantId) -
fn type_for_adt(db: &dyn HirDatabase, adt: AdtId) -> Binders<Ty> {
let generics = generics(db.upcast(), adt.into());
let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST);
let substs = Substitution::bound_vars(&generics, DebruijnIndex::INNERMOST);
Binders::new(substs.len(), Ty::adt_ty(adt, substs))
}
@ -1126,7 +1130,7 @@ fn type_for_type_alias(db: &dyn HirDatabase, t: TypeAliasId) -> Binders<Ty> {
if db.type_alias_data(t).is_extern {
Binders::new(0, TyKind::ForeignType(crate::to_foreign_def_id(t)).intern(&Interner))
} else {
let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST);
let substs = Substitution::bound_vars(&generics, DebruijnIndex::INNERMOST);
let type_ref = &db.type_alias_data(t).type_ref;
let inner = ctx.lower_ty(type_ref.as_ref().unwrap_or(&TypeRef::Error));
Binders::new(substs.len(), inner)

14
crates/hir_ty/src/method_resolution.rs
View file

@ -21,7 +21,7 @@ use crate::{
primitive::{self, FloatTy, IntTy, UintTy},
utils::all_super_traits,
AdtId, Canonical, DebruijnIndex, FnPointer, FnSig, ForeignDefId, InEnvironment, Interner,
Scalar, Substs, TraitEnvironment, TraitRef, Ty, TyKind, TypeWalk,
Scalar, Substitution, TraitEnvironment, TraitRef, Ty, TyKind, TypeWalk,
};
/// This is used as a key for indexing impls.
@ -672,10 +672,10 @@ pub(crate) fn inherent_impl_substs(
db: &dyn HirDatabase,
impl_id: ImplId,
self_ty: &Canonical<Ty>,
) -> Option<Substs> {
) -> Option<Substitution> {
// we create a var for each type parameter of the impl; we need to keep in
// mind here that `self_ty` might have vars of its own
let vars = Substs::build_for_def(db, impl_id)
let vars = Substitution::build_for_def(db, impl_id)
.fill_with_bound_vars(DebruijnIndex::INNERMOST, self_ty.kinds.len())
.build();
let self_ty_with_vars = db.impl_self_ty(impl_id).subst(&vars);
@ -693,7 +693,7 @@ pub(crate) fn inherent_impl_substs(
/// This replaces any 'free' Bound vars in `s` (i.e. those with indices past
/// num_vars_to_keep) by `TyKind::Unknown`.
fn fallback_bound_vars(s: Substs, num_vars_to_keep: usize) -> Substs {
fn fallback_bound_vars(s: Substitution, num_vars_to_keep: usize) -> Substitution {
s.fold_binders(
&mut |ty, binders| {
if let TyKind::BoundVar(bound) = ty.interned(&Interner) {
@ -716,13 +716,13 @@ fn transform_receiver_ty(
self_ty: &Canonical<Ty>,
) -> Option<Ty> {
let substs = match function_id.lookup(db.upcast()).container {
AssocContainerId::TraitId(_) => Substs::build_for_def(db, function_id)
AssocContainerId::TraitId(_) => Substitution::build_for_def(db, function_id)
.push(self_ty.value.clone())
.fill_with_unknown()
.build(),
AssocContainerId::ImplId(impl_id) => {
let impl_substs = inherent_impl_substs(db, impl_id, &self_ty)?;
Substs::build_for_def(db, function_id)
Substitution::build_for_def(db, function_id)
.use_parent_substs(&impl_substs)
.fill_with_unknown()
.build()
@ -768,7 +768,7 @@ fn generic_implements_goal(
self_ty: Canonical<Ty>,
) -> Canonical<InEnvironment<super::Obligation>> {
let mut kinds = self_ty.kinds.to_vec();
let substs = super::Substs::build_for_def(db, trait_)
let substs = super::Substitution::build_for_def(db, trait_)
.push(self_ty.value)
.fill_with_bound_vars(DebruijnIndex::INNERMOST, kinds.len())
.build();

4
crates/hir_ty/src/traits.rs
View file

@ -8,7 +8,7 @@ use chalk_solve::{logging_db::LoggingRustIrDatabase, Solver};
use hir_def::{lang_item::LangItemTarget, TraitId};
use stdx::panic_context;
use crate::{db::HirDatabase, DebruijnIndex, Substs};
use crate::{db::HirDatabase, DebruijnIndex, Substitution};
use super::{
Canonical, GenericPredicate, HirDisplay, ProjectionTy, TraitRef, Ty, TyKind, TypeWalk,
@ -252,7 +252,7 @@ fn solution_from_chalk(
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct SolutionVariables(pub Canonical<Substs>);
pub struct SolutionVariables(pub Canonical<Substitution>);
#[derive(Clone, Debug, PartialEq, Eq)]
/// A (possible) solution for a proposed goal.

18
crates/hir_ty/src/traits/chalk.rs
View file

@ -22,7 +22,7 @@ use crate::{
to_assoc_type_id,
utils::generics,
BoundVar, CallableDefId, CallableSig, DebruijnIndex, FnDefId, GenericPredicate,
ProjectionPredicate, ProjectionTy, Substs, TraitRef, Ty, TyKind,
ProjectionPredicate, ProjectionTy, Substitution, TraitRef, Ty, TyKind,
};
use mapping::{
convert_where_clauses, generic_predicate_to_inline_bound, make_binders, TypeAliasAsValue,
@ -221,7 +221,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
let impl_bound = GenericPredicate::Implemented(TraitRef {
trait_: future_trait,
// Self type as the first parameter.
substs: Substs::single(
substs: Substitution::single(
TyKind::BoundVar(BoundVar {
debruijn: DebruijnIndex::INNERMOST,
index: 0,
@ -236,7 +236,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
projection_ty: ProjectionTy {
associated_ty_id: to_assoc_type_id(future_output),
// Self type as the first parameter.
substitution: Substs::single(
substitution: Substitution::single(
TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0))
.intern(&Interner),
),
@ -313,7 +313,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
_closure_id: chalk_ir::ClosureId<Interner>,
_substs: &chalk_ir::Substitution<Interner>,
) -> chalk_ir::Substitution<Interner> {
Substs::empty().to_chalk(self.db)
Substitution::empty().to_chalk(self.db)
}
fn trait_name(&self, trait_id: chalk_ir::TraitId<Interner>) -> String {
@ -392,7 +392,7 @@ pub(crate) fn associated_ty_data_query(
// Lower bounds -- we could/should maybe move this to a separate query in `lower`
let type_alias_data = db.type_alias_data(type_alias);
let generic_params = generics(db.upcast(), type_alias.into());
let bound_vars = Substs::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
let bound_vars = Substitution::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
let resolver = hir_def::resolver::HasResolver::resolver(type_alias, db.upcast());
let ctx = crate::TyLoweringContext::new(db, &resolver)
.with_type_param_mode(crate::lower::TypeParamLoweringMode::Variable);
@ -427,7 +427,7 @@ pub(crate) fn trait_datum_query(
let trait_data = db.trait_data(trait_);
debug!("trait {:?} = {:?}", trait_id, trait_data.name);
let generic_params = generics(db.upcast(), trait_.into());
let bound_vars = Substs::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
let bound_vars = Substitution::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
let flags = rust_ir::TraitFlags {
auto: trait_data.is_auto,
upstream: trait_.lookup(db.upcast()).container.krate() != krate,
@ -496,7 +496,7 @@ pub(crate) fn struct_datum_query(
let upstream = adt_id.module(db.upcast()).krate() != krate;
let where_clauses = {
let generic_params = generics(db.upcast(), adt_id.into());
let bound_vars = Substs::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
let bound_vars = Substitution::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
convert_where_clauses(db, adt_id.into(), &bound_vars)
};
let flags = rust_ir::AdtFlags {
@ -545,7 +545,7 @@ fn impl_def_datum(
let impl_data = db.impl_data(impl_id);
let generic_params = generics(db.upcast(), impl_id.into());
let bound_vars = Substs::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
let bound_vars = Substitution::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
let trait_ = trait_ref.trait_;
let impl_type = if impl_id.lookup(db.upcast()).container.krate() == krate {
rust_ir::ImplType::Local
@ -635,7 +635,7 @@ pub(crate) fn fn_def_datum_query(
let callable_def: CallableDefId = from_chalk(db, fn_def_id);
let generic_params = generics(db.upcast(), callable_def.into());
let sig = db.callable_item_signature(callable_def);
let bound_vars = Substs::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
let bound_vars = Substitution::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
let where_clauses = convert_where_clauses(db, callable_def.into(), &bound_vars);
let bound = rust_ir::FnDefDatumBound {
// Note: Chalk doesn't actually use this information yet as far as I am aware, but we provide it anyway

15
crates/hir_ty/src/traits/chalk/mapping.rs
View file

@ -15,7 +15,7 @@ use crate::{
primitive::UintTy,
traits::{Canonical, Obligation},
AliasTy, CallableDefId, FnPointer, GenericPredicate, InEnvironment, OpaqueTy,
ProjectionPredicate, ProjectionTy, Scalar, Substs, TraitRef, Ty,
ProjectionPredicate, ProjectionTy, Scalar, Substitution, TraitRef, Ty,
};
use super::interner::*;
@ -134,7 +134,7 @@ impl ToChalk for Ty {
..
}) => {
assert_eq!(num_binders, 0);
let substs: Substs = from_chalk(
let substs: Substitution = from_chalk(
db,
substitution.0.shifted_out(&Interner).expect("fn ptr should have no binders"),
);
@ -213,14 +213,17 @@ fn array_to_chalk(db: &dyn HirDatabase, ty: Ty) -> chalk_ir::Ty<Interner> {
chalk_ir::TyKind::Array(arg, const_).intern(&Interner)
}
impl ToChalk for Substs {
impl ToChalk for Substitution {
type Chalk = chalk_ir::Substitution<Interner>;
fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::Substitution<Interner> {
chalk_ir::Substitution::from_iter(&Interner, self.iter().map(|ty| ty.clone().to_chalk(db)))
}
fn from_chalk(db: &dyn HirDatabase, parameters: chalk_ir::Substitution<Interner>) -> Substs {
fn from_chalk(
db: &dyn HirDatabase,
parameters: chalk_ir::Substitution<Interner>,
) -> Substitution {
let tys = parameters
.iter(&Interner)
.map(|p| match p.ty(&Interner) {
@ -228,7 +231,7 @@ impl ToChalk for Substs {
None => unimplemented!(),
})
.collect();
Substs(tys)
Substitution(tys)
}
}
@ -489,7 +492,7 @@ where
pub(super) fn convert_where_clauses(
db: &dyn HirDatabase,
def: GenericDefId,
substs: &Substs,
substs: &Substitution,
) -> Vec<chalk_ir::QuantifiedWhereClause<Interner>> {
let generic_predicates = db.generic_predicates(def);
let mut result = Vec::with_capacity(generic_predicates.len());