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 {
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)?;
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;
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)
}
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))
}
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)
}
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(),
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();
fn walk_substs(
db: &dyn HirDatabase,
type_: &Type,
- substs: &Substs,
+ substs: &Substitution,
cb: &mut impl FnMut(Type),
) {
for ty in substs.iter() {
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},
&self,
db: &dyn HirDatabase,
krate: CrateId,
- substs: &Substs,
+ substs: &Substitution,
variant: VariantId,
missing_fields: Vec<LocalFieldId>,
) -> Vec<(Field, Type)> {
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;
// 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() };
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> {
}
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<_>>(),
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,
_ => 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();
}
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 => {
}
}
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);
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};
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();
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::{
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();
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 =
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 {
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
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() {
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() => {
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(),
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) {
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
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) {
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(
}
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 {
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 {
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() {
};
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(),
},
};
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};
}
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);
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();
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
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| {
ty: Ty,
name: &Name,
id: ExprOrPatId,
- ) -> Option<(ValueNs, Option<Substs>)> {
+ ) -> Option<(ValueNs, Option<Substitution>)> {
if let TyKind::Unknown = ty.interned(&Interner) {
return None;
}
};
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);
}
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();
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,
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> {
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()
}
}
-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
}
}
Some(
- Substs::builder(tys.kinds.len())
+ Substitution::builder(tys.kinds.len())
.fill(vars.iter().map(|v| table.resolve_ty_completely(v.clone())))
.build(),
)
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))
#[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)
#[derive(Clone, PartialEq, Eq, Debug, Hash)]
pub struct ProjectionTy {
pub associated_ty_id: AssocTypeId,
- pub substitution: Substs,
+ pub substitution: Substitution,
}
impl ProjectionTy {
pub struct FnPointer {
pub num_args: usize,
pub sig: FnSig,
- pub substs: Substs,
+ pub substs: Substitution,
}
#[derive(Clone, PartialEq, Eq, Debug, Hash)]
#[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),
/// 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
/// 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,
///
/// 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),
/// 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);
}
}
-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 {
}
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))
}
/// 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, ¶ms)
+ Substitution::type_params_for_generics(db, ¶ms)
}
/// 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()
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 {
}
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 {
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());
}
}
-impl Deref for Substs {
+impl Deref for Substitution {
type Target = [Ty];
fn deref(&self) -> &[Ty] {
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))
}
pub struct TraitRef {
/// FIXME name?
pub trait_: TraitId,
- pub substs: Substs,
+ pub substs: Substitution,
}
impl TraitRef {
}
}
- 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 }
}
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)
}
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)
}
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,
/// 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)
}
}
- 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)
// 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 {
}
/// 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,
{
}
/// 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,
{
},
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)]
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) => {
}
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 },
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,
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)
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)
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",
// 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())),
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));
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));
}
}
}
assert_eq!(substs.len(), total_len);
- Substs(substs.into())
+ Substitution(substs.into())
}
fn lower_trait_ref_from_path(
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)
}
{
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);
}
// 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> =
/// 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),
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),
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),
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))
}
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)
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.
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);
/// 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) {
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()
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();
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,
}
#[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.
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,
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,
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),
),
_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 {
// 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);
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,
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 {
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
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
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::*;
..
}) => {
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"),
);
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) {
None => unimplemented!(),
})
.collect();
- Substs(tys)
+ Substitution(tys)
}
}
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());
projects / rust.git / commitdiff