language-servers/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-09-19 08:40:24 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

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
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::{ use crate::{
Adt, Const, ConstParam, Enum, Field, Function, GenericParam, HasVisibility, LifetimeParam, 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 { impl HirDisplay for Function {
@ -235,7 +235,7 @@ impl HirDisplay for TypeParam {
fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
write!(f, "{}", self.name(f.db))?; write!(f, "{}", self.name(f.db))?;
let bounds = f.db.generic_predicates_for_param(self.id); 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<_>>(); let predicates = bounds.iter().cloned().map(|b| b.subst(&substs)).collect::<Vec<_>>();
if !(predicates.is_empty() || f.omit_verbose_types()) { if !(predicates.is_empty() || f.omit_verbose_types()) {
write_bounds_like_dyn_trait_with_prefix(":", &predicates, f)?; 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, to_assoc_type_id,
traits::{FnTrait, Solution, SolutionVariables}, traits::{FnTrait, Solution, SolutionVariables},
AliasTy, BoundVar, CallableDefId, CallableSig, Canonical, DebruijnIndex, GenericPredicate, AliasTy, BoundVar, CallableDefId, CallableSig, Canonical, DebruijnIndex, GenericPredicate,
InEnvironment, Interner, Obligation, ProjectionPredicate, ProjectionTy, Scalar, Substs, Ty, InEnvironment, Interner, Obligation, ProjectionPredicate, ProjectionTy, Scalar, Substitution,
TyDefId, TyKind, TyVariableKind, Ty, TyDefId, TyKind, TyVariableKind,
}; };
use itertools::Itertools; use itertools::Itertools;
use rustc_hash::FxHashSet; use rustc_hash::FxHashSet;
@ -518,7 +518,7 @@ impl Field {
VariantDef::Union(it) => it.id.into(), VariantDef::Union(it) => it.id.into(),
VariantDef::Variant(it) => it.parent.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); let ty = db.field_types(var_id)[self.id].clone().subst(&substs);
Type::new(db, self.parent.module(db).id.krate(), var_id, ty) 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 resolver = self.id.parent.resolver(db.upcast());
let krate = self.id.parent.module(db.upcast()).krate(); let krate = self.id.parent.module(db.upcast()).krate();
let ty = params.get(local_idx)?.clone(); 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)); let ty = ty.subst(&subst.prefix(local_idx));
Some(Type::new_with_resolver_inner(db, krate, &resolver, ty)) Some(Type::new_with_resolver_inner(db, krate, &resolver, ty))
} }
@ -1674,7 +1674,7 @@ impl Type {
krate: CrateId, krate: CrateId,
def: impl HasResolver + Into<TyDefId> + Into<GenericDefId>, def: impl HasResolver + Into<TyDefId> + Into<GenericDefId>,
) -> Type { ) -> 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); let ty = db.ty(def.into()).subst(&substs);
Type::new(db, krate, def, ty) 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 { pub fn impls_trait(&self, db: &dyn HirDatabase, trait_: Trait, args: &[Type]) -> bool {
let trait_ref = hir_ty::TraitRef { let trait_ref = hir_ty::TraitRef {
trait_: trait_.id, trait_: trait_.id,
substs: Substs::build_for_def(db, trait_.id) substs: Substitution::build_for_def(db, trait_.id)
.push(self.ty.value.clone()) .push(self.ty.value.clone())
.fill(args.iter().map(|t| t.ty.value.clone())) .fill(args.iter().map(|t| t.ty.value.clone()))
.build(), .build(),
@ -1778,7 +1778,7 @@ impl Type {
args: &[Type], args: &[Type],
alias: TypeAlias, alias: TypeAlias,
) -> Option<Type> { ) -> 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()) .push(self.ty.value.clone())
.fill(args.iter().map(|t| t.ty.value.clone())) .fill(args.iter().map(|t| t.ty.value.clone()))
.build(); .build();
@ -2045,7 +2045,7 @@ impl Type {
fn walk_substs( fn walk_substs(
db: &dyn HirDatabase, db: &dyn HirDatabase,
type_: &Type, type_: &Type,
substs: &Substs, substs: &Substitution,
cb: &mut impl FnMut(Type), cb: &mut impl FnMut(Type),
) { ) {
for ty in substs.iter() { 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_expand::{hygiene::Hygiene, name::AsName, HirFileId, InFile};
use hir_ty::{ use hir_ty::{
diagnostics::{record_literal_missing_fields, record_pattern_missing_fields}, diagnostics::{record_literal_missing_fields, record_pattern_missing_fields},
InferenceResult, Substs, InferenceResult, Substitution,
}; };
use syntax::{ use syntax::{
ast::{self, AstNode}, ast::{self, AstNode},
@ -329,7 +329,7 @@ impl SourceAnalyzer {
&self, &self,
db: &dyn HirDatabase, db: &dyn HirDatabase,
krate: CrateId, krate: CrateId,
substs: &Substs, substs: &Substitution,
variant: VariantId, variant: VariantId,
missing_fields: Vec<LocalFieldId>, missing_fields: Vec<LocalFieldId>,
) -> Vec<(Field, Type)> { ) -> Vec<(Field, Type)> {

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

@ -15,7 +15,7 @@ use crate::{
to_assoc_type_id, to_assoc_type_id,
traits::{InEnvironment, Solution}, traits::{InEnvironment, Solution},
utils::generics, 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; const AUTODEREF_RECURSION_LIMIT: usize = 10;
@ -65,7 +65,7 @@ fn deref_by_trait(
// FIXME make the Canonical / bound var handling nicer // FIXME make the Canonical / bound var handling nicer
let parameters = 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 // Check that the type implements Deref at all
let trait_ref = TraitRef { trait_: deref_trait, substs: parameters.clone() }; 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, 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, to_assoc_type_id, traits::chalk::from_chalk, utils::generics, AdtId, AliasTy, CallableDefId,
CallableSig, GenericPredicate, ImplTraitId, Interner, Lifetime, Obligation, OpaqueTy, CallableSig, GenericPredicate, ImplTraitId, Interner, Lifetime, Obligation, OpaqueTy,
ProjectionTy, Scalar, Substs, TraitRef, Ty, TyKind, ProjectionTy, Scalar, Substitution, TraitRef, Ty, TyKind,
}; };
pub struct HirFormatter<'a> { pub struct HirFormatter<'a> {
@ -562,7 +562,7 @@ impl HirDisplay for Ty {
} }
TypeParamProvenance::ArgumentImplTrait => { TypeParamProvenance::ArgumentImplTrait => {
let bounds = f.db.generic_predicates_for_param(id); 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( write_bounds_like_dyn_trait_with_prefix(
"impl", "impl",
&bounds.iter().map(|b| b.clone().subst(&substs)).collect::<Vec<_>>(), &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::{ use super::{
traits::{Guidance, Obligation, ProjectionPredicate, Solution}, traits::{Guidance, Obligation, ProjectionPredicate, Solution},
InEnvironment, ProjectionTy, Substs, TraitEnvironment, TraitRef, Ty, TypeWalk, InEnvironment, ProjectionTy, Substitution, TraitEnvironment, TraitRef, Ty, TypeWalk,
}; };
use crate::{ use crate::{
db::HirDatabase, infer::diagnostics::InferenceDiagnostic, lower::ImplTraitLoweringMode, db::HirDatabase, infer::diagnostics::InferenceDiagnostic, lower::ImplTraitLoweringMode,
@ -390,7 +390,7 @@ impl<'a> InferenceContext<'a> {
_ => panic!("resolve_associated_type called with non-associated type"), _ => panic!("resolve_associated_type called with non-associated type"),
}; };
let ty = self.table.new_type_var(); 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) .push(inner_ty)
.fill(params.iter().cloned()) .fill(params.iter().cloned())
.build(); .build();
@ -469,7 +469,7 @@ impl<'a> InferenceContext<'a> {
} }
TypeNs::SelfType(impl_id) => { TypeNs::SelfType(impl_id) => {
let generics = crate::utils::generics(self.db.upcast(), impl_id.into()); 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); let ty = self.db.impl_self_ty(impl_id).subst(&substs);
match unresolved { match unresolved {
None => { None => {
@ -496,7 +496,7 @@ impl<'a> InferenceContext<'a> {
} }
} }
TypeNs::TypeAliasId(it) => { 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())) .fill(std::iter::repeat_with(|| self.table.new_type_var()))
.build(); .build();
let ty = self.db.ty(it.into()).subst(&substs); 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 chalk_ir::{Mutability, TyVariableKind};
use hir_def::lang_item::LangItemTarget; 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}; use super::{InEnvironment, InferenceContext};
@ -134,7 +136,7 @@ impl<'a> InferenceContext<'a> {
return None; return None;
} }
let substs = Substs::build_for_generics(&generic_params) let substs = Substitution::build_for_generics(&generic_params)
.push(from_ty.clone()) .push(from_ty.clone())
.push(to_ty.clone()) .push(to_ty.clone())
.build(); .build();

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

@ -21,8 +21,8 @@ use crate::{
to_assoc_type_id, to_assoc_type_id,
traits::{chalk::from_chalk, FnTrait, InEnvironment}, traits::{chalk::from_chalk, FnTrait, InEnvironment},
utils::{generics, variant_data, Generics}, utils::{generics, variant_data, Generics},
AdtId, Binders, CallableDefId, FnPointer, FnSig, Interner, Obligation, Rawness, Scalar, Substs, AdtId, Binders, CallableDefId, FnPointer, FnSig, Interner, Obligation, Rawness, Scalar,
TraitRef, Ty, TyKind, Substitution, TraitRef, Ty, TyKind,
}; };
use super::{ use super::{
@ -77,7 +77,7 @@ impl<'a> InferenceContext<'a> {
return None; return None;
} }
let mut param_builder = Substs::builder(num_args); let mut param_builder = Substitution::builder(num_args);
let mut arg_tys = vec![]; let mut arg_tys = vec![];
for _ in 0..num_args { for _ in 0..num_args {
let arg = self.table.new_type_var(); let arg = self.table.new_type_var();
@ -87,7 +87,7 @@ impl<'a> InferenceContext<'a> {
let parameters = param_builder.build(); let parameters = param_builder.build();
let arg_ty = TyKind::Tuple(num_args, parameters).intern(&Interner); let arg_ty = TyKind::Tuple(num_args, parameters).intern(&Interner);
let substs = 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 trait_env = Arc::clone(&self.trait_env);
let implements_fn_trait = let implements_fn_trait =
@ -181,7 +181,7 @@ impl<'a> InferenceContext<'a> {
let inner_ty = self.infer_expr(*body, &Expectation::none()); let inner_ty = self.infer_expr(*body, &Expectation::none());
let impl_trait_id = crate::ImplTraitId::AsyncBlockTypeImplTrait(self.owner, *body); let impl_trait_id = crate::ImplTraitId::AsyncBlockTypeImplTrait(self.owner, *body);
let opaque_ty_id = self.db.intern_impl_trait_id(impl_trait_id).into(); 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 } => { Expr::Loop { body, label } => {
self.breakables.push(BreakableContext { self.breakables.push(BreakableContext {
@ -262,12 +262,12 @@ impl<'a> InferenceContext<'a> {
let sig_ty = TyKind::Function(FnPointer { let sig_ty = TyKind::Function(FnPointer {
num_args: sig_tys.len() - 1, num_args: sig_tys.len() - 1,
sig: FnSig { abi: (), safety: chalk_ir::Safety::Safe, variadic: false }, sig: FnSig { abi: (), safety: chalk_ir::Safety::Safe, variadic: false },
substs: Substs(sig_tys.clone().into()), substs: Substitution(sig_tys.clone().into()),
}) })
.intern(&Interner); .intern(&Interner);
let closure_id = self.db.intern_closure((self.owner, tgt_expr)).into(); let closure_id = self.db.intern_closure((self.owner, tgt_expr)).into();
let closure_ty = 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 // Eagerly try to relate the closure type with the expected
// type, otherwise we often won't have enough information to // type, otherwise we often won't have enough information to
@ -402,7 +402,7 @@ impl<'a> InferenceContext<'a> {
self.unify(&ty, &expected.ty); 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 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)); let variant_data = def_id.map(|it| variant_data(self.db.upcast(), it));
for field in fields.iter() { for field in fields.iter() {
@ -511,7 +511,8 @@ impl<'a> InferenceContext<'a> {
Expr::Box { expr } => { Expr::Box { expr } => {
let inner_ty = self.infer_expr_inner(*expr, &Expectation::none()); let inner_ty = self.infer_expr_inner(*expr, &Expectation::none());
if let Some(box_) = self.resolve_boxed_box() { 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); sb = sb.push(inner_ty);
match self.db.generic_defaults(box_.into()).as_ref() { match self.db.generic_defaults(box_.into()).as_ref() {
[_, alloc_ty, ..] if !alloc_ty.value.is_unknown() => { [_, 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)); let rhs_ty = rhs.map(|e| self.infer_expr(e, &rhs_expect));
match (range_type, lhs_ty, rhs_ty) { match (range_type, lhs_ty, rhs_ty) {
(RangeOp::Exclusive, None, None) => match self.resolve_range_full() { (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(), None => self.err_ty(),
}, },
(RangeOp::Exclusive, None, Some(ty)) => match self.resolve_range_to() { (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(), None => self.err_ty(),
}, },
(RangeOp::Inclusive, None, Some(ty)) => { (RangeOp::Inclusive, None, Some(ty)) => {
match self.resolve_range_to_inclusive() { 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(), None => self.err_ty(),
} }
} }
(RangeOp::Exclusive, Some(_), Some(ty)) => match self.resolve_range() { (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(), None => self.err_ty(),
}, },
(RangeOp::Inclusive, Some(_), Some(ty)) => { (RangeOp::Inclusive, Some(_), Some(ty)) => {
match self.resolve_range_inclusive() { 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(), None => self.err_ty(),
} }
} }
(RangeOp::Exclusive, Some(ty), None) => match self.resolve_range_from() { (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(), None => self.err_ty(),
}, },
(RangeOp::Inclusive, _, 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())); 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) => { Expr::Array(array) => {
let elem_ty = match expected.ty.interned(&Interner) { let elem_ty = match expected.ty.interned(&Interner) {
@ -887,7 +888,7 @@ impl<'a> InferenceContext<'a> {
def_generics: Option<Generics>, def_generics: Option<Generics>,
generic_args: Option<&GenericArgs>, generic_args: Option<&GenericArgs>,
receiver_ty: &Ty, receiver_ty: &Ty,
) -> Substs { ) -> Substitution {
let (parent_params, self_params, type_params, impl_trait_params) = let (parent_params, self_params, type_params, impl_trait_params) =
def_generics.as_ref().map_or((0, 0, 0, 0), |g| g.provenance_split()); 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 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()); substs.push(self.err_ty());
} }
assert_eq!(substs.len(), total_len); assert_eq!(substs.len(), total_len);
Substs(substs.into()) Substitution(substs.into())
} }
fn register_obligations_for_call(&mut self, callable_ty: &Ty) { 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 hir_expand::name::Name;
use super::{BindingMode, Expectation, InferenceContext}; 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> { impl<'a> InferenceContext<'a> {
fn infer_tuple_struct_pat( fn infer_tuple_struct_pat(
@ -31,7 +33,7 @@ impl<'a> InferenceContext<'a> {
} }
self.unify(&ty, expected); 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 field_tys = def.map(|it| self.db.field_types(it)).unwrap_or_default();
let (pre, post) = match ellipsis { let (pre, post) = match ellipsis {
@ -70,7 +72,7 @@ impl<'a> InferenceContext<'a> {
self.unify(&ty, expected); 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 field_tys = def.map(|it| self.db.field_types(it)).unwrap_or_default();
for subpat in subpats { 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(expectations_iter.by_ref().take(n_uncovered_patterns).cloned());
inner_tys.extend(post.iter().zip(expectations_iter).map(infer_pat)); 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) => { Pat::Or(ref pats) => {
if let Some((first_pat, rest)) = pats.split_first() { 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); 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(), 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 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}; use super::{ExprOrPatId, InferenceContext, TraitRef};
@ -79,7 +79,7 @@ impl<'a> InferenceContext<'a> {
} }
ValueNs::ImplSelf(impl_id) => { ValueNs::ImplSelf(impl_id) => {
let generics = crate::utils::generics(self.db.upcast(), impl_id.into()); 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); let ty = self.db.impl_self_ty(impl_id).subst(&substs);
if let Some((AdtId::StructId(struct_id), substs)) = ty.as_adt() { 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(struct_id.into()).subst(&substs);
@ -94,10 +94,10 @@ impl<'a> InferenceContext<'a> {
let ty = self.db.value_ty(typable); let ty = self.db.value_ty(typable);
// self_subst is just for the parent // 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 ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver);
let substs = ctx.substs_from_path(path, typable, true); 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) .use_parent_substs(&parent_substs)
.fill(substs.0[parent_substs.len()..].iter().cloned()) .fill(substs.0[parent_substs.len()..].iter().cloned())
.build(); .build();
@ -111,7 +111,7 @@ impl<'a> InferenceContext<'a> {
path: &Path, path: &Path,
remaining_index: usize, remaining_index: usize,
id: ExprOrPatId, id: ExprOrPatId,
) -> Option<(ValueNs, Option<Substs>)> { ) -> Option<(ValueNs, Option<Substitution>)> {
assert!(remaining_index < path.segments().len()); assert!(remaining_index < path.segments().len());
// there may be more intermediate segments between the resolved one and // 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 // 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, trait_ref: TraitRef,
segment: PathSegment<'_>, segment: PathSegment<'_>,
id: ExprOrPatId, id: ExprOrPatId,
) -> Option<(ValueNs, Option<Substs>)> { ) -> Option<(ValueNs, Option<Substitution>)> {
let trait_ = trait_ref.trait_; let trait_ = trait_ref.trait_;
let item = let item =
self.db.trait_data(trait_).items.iter().map(|(_name, id)| (*id)).find_map(|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, ty: Ty,
name: &Name, name: &Name,
id: ExprOrPatId, id: ExprOrPatId,
) -> Option<(ValueNs, Option<Substs>)> { ) -> Option<(ValueNs, Option<Substitution>)> {
if let TyKind::Unknown = ty.interned(&Interner) { if let TyKind::Unknown = ty.interned(&Interner) {
return None; return None;
} }
@ -241,7 +241,7 @@ impl<'a> InferenceContext<'a> {
}; };
let substs = match container { let substs = match container {
AssocContainerId::ImplId(impl_id) => { 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())) .fill(iter::repeat_with(|| self.table.new_type_var()))
.build(); .build();
let impl_self_ty = self.db.impl_self_ty(impl_id).subst(&impl_substs); 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_) => { AssocContainerId::TraitId(trait_) => {
// we're picking this method // 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()) .push(ty.clone())
.fill(std::iter::repeat_with(|| self.table.new_type_var())) .fill(std::iter::repeat_with(|| self.table.new_type_var()))
.build(); .build();
@ -274,7 +274,7 @@ impl<'a> InferenceContext<'a> {
ty: &Ty, ty: &Ty,
name: &Name, name: &Name,
id: ExprOrPatId, id: ExprOrPatId,
) -> Option<(ValueNs, Option<Substs>)> { ) -> Option<(ValueNs, Option<Substitution>)> {
let (enum_id, subst) = match ty.as_adt() { let (enum_id, subst) = match ty.as_adt() {
Some((AdtId::EnumId(e), subst)) => (e, subst), Some((AdtId::EnumId(e), subst)) => (e, subst),
_ => return None, _ => 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 super::{InferenceContext, Obligation};
use crate::{ use crate::{
BoundVar, Canonical, DebruijnIndex, FnPointer, GenericPredicate, InEnvironment, InferenceVar, BoundVar, Canonical, DebruijnIndex, FnPointer, GenericPredicate, InEnvironment, InferenceVar,
Interner, Scalar, Substs, Ty, TyKind, TypeWalk, Interner, Scalar, Substitution, Ty, TyKind, TypeWalk,
}; };
impl<'a> InferenceContext<'a> { impl<'a> InferenceContext<'a> {
@ -123,10 +123,10 @@ impl<T> Canonicalized<T> {
pub(super) fn apply_solution( pub(super) fn apply_solution(
&self, &self,
ctx: &mut InferenceContext<'_>, ctx: &mut InferenceContext<'_>,
solution: Canonical<Substs>, solution: Canonical<Substitution>,
) { ) {
// the solution may contain new variables, which we need to convert to new inference vars // the solution may contain new variables, which we need to convert to new inference vars
let new_vars = Substs( let new_vars = Substitution(
solution solution
.kinds .kinds
.iter() .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 mut table = InferenceTable::new();
let vars = Substs( let vars = Substitution(
tys.kinds tys.kinds
.iter() .iter()
// we always use type vars here because we want everything to // 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( Some(
Substs::builder(tys.kinds.len()) Substitution::builder(tys.kinds.len())
.fill(vars.iter().map(|v| table.resolve_ty_completely(v.clone()))) .fill(vars.iter().map(|v| table.resolve_ty_completely(v.clone())))
.build(), .build(),
) )
@ -264,8 +264,8 @@ impl InferenceTable {
pub(crate) fn unify_substs( pub(crate) fn unify_substs(
&mut self, &mut self,
substs1: &Substs, substs1: &Substitution,
substs2: &Substs, substs2: &Substitution,
depth: usize, depth: usize,
) -> bool { ) -> bool {
substs1.0.iter().zip(substs2.0.iter()).all(|(t1, t2)| self.unify_inner(t1, t2, depth)) 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)] #[derive(Clone, PartialEq, Eq, Debug, Hash)]
pub struct OpaqueTy { pub struct OpaqueTy {
pub opaque_ty_id: OpaqueTyId, pub opaque_ty_id: OpaqueTyId,
pub substitution: Substs, pub substitution: Substitution,
} }
/// A "projection" type corresponds to an (unnormalized) /// A "projection" type corresponds to an (unnormalized)
@ -76,7 +76,7 @@ pub struct OpaqueTy {
#[derive(Clone, PartialEq, Eq, Debug, Hash)] #[derive(Clone, PartialEq, Eq, Debug, Hash)]
pub struct ProjectionTy { pub struct ProjectionTy {
pub associated_ty_id: AssocTypeId, pub associated_ty_id: AssocTypeId,
pub substitution: Substs, pub substitution: Substitution,
} }
impl ProjectionTy { impl ProjectionTy {
@ -112,7 +112,7 @@ pub type FnSig = chalk_ir::FnSig<Interner>;
pub struct FnPointer { pub struct FnPointer {
pub num_args: usize, pub num_args: usize,
pub sig: FnSig, pub sig: FnSig,
pub substs: Substs, pub substs: Substitution,
} }
#[derive(Clone, PartialEq, Eq, Debug, Hash)] #[derive(Clone, PartialEq, Eq, Debug, Hash)]
@ -137,19 +137,19 @@ pub enum AliasTy {
#[derive(Clone, PartialEq, Eq, Debug, Hash)] #[derive(Clone, PartialEq, Eq, Debug, Hash)]
pub enum TyKind { pub enum TyKind {
/// Structures, enumerations and unions. /// Structures, enumerations and unions.
Adt(AdtId<Interner>, Substs), Adt(AdtId<Interner>, Substitution),
/// Represents an associated item like `Iterator::Item`. This is used /// Represents an associated item like `Iterator::Item`. This is used
/// when we have tried to normalize a projection like `T::Item` but /// when we have tried to normalize a projection like `T::Item` but
/// couldn't find a better representation. In that case, we generate /// couldn't find a better representation. In that case, we generate
/// an **application type** like `(Iterator::Item)<T>`. /// an **application type** like `(Iterator::Item)<T>`.
AssociatedType(AssocTypeId, Substs), AssociatedType(AssocTypeId, Substitution),
/// a scalar type like `bool` or `u32` /// a scalar type like `bool` or `u32`
Scalar(Scalar), Scalar(Scalar),
/// A tuple type. For example, `(i32, bool)`. /// A tuple type. For example, `(i32, bool)`.
Tuple(usize, Substs), Tuple(usize, Substitution),
/// An array with the given length. Written as `[T; n]`. /// An array with the given length. Written as `[T; n]`.
Array(Ty), Array(Ty),
@ -169,7 +169,7 @@ pub enum TyKind {
/// analogous to the `AssociatedType` type constructor. /// analogous to the `AssociatedType` type constructor.
/// It is also used as the type of async block, with one type parameter /// It is also used as the type of async block, with one type parameter
/// representing the Future::Output type. /// representing the Future::Output type.
OpaqueType(OpaqueTyId, Substs), OpaqueType(OpaqueTyId, Substitution),
/// The anonymous type of a function declaration/definition. Each /// The anonymous type of a function declaration/definition. Each
/// function has a unique type, which is output (for a function /// function has a unique type, which is output (for a function
@ -183,7 +183,7 @@ pub enum TyKind {
/// fn foo() -> i32 { 1 } /// fn foo() -> i32 { 1 }
/// let bar = foo; // bar: fn() -> i32 {foo} /// let bar = foo; // bar: fn() -> i32 {foo}
/// ``` /// ```
FnDef(FnDefId, Substs), FnDef(FnDefId, Substitution),
/// The pointee of a string slice. Written as `str`. /// The pointee of a string slice. Written as `str`.
Str, Str,
@ -195,7 +195,7 @@ pub enum TyKind {
/// ///
/// The closure signature is stored in a `FnPtr` type in the first type /// The closure signature is stored in a `FnPtr` type in the first type
/// parameter. /// parameter.
Closure(ClosureId, Substs), Closure(ClosureId, Substitution),
/// Represents a foreign type declared in external blocks. /// Represents a foreign type declared in external blocks.
ForeignType(ForeignDefId), ForeignType(ForeignDefId),
@ -273,9 +273,9 @@ impl Ty {
/// A list of substitutions for generic parameters. /// A list of substitutions for generic parameters.
#[derive(Clone, PartialEq, Eq, Debug, Hash)] #[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)) { fn walk(&self, f: &mut impl FnMut(&Ty)) {
for t in self.0.iter() { for t in self.0.iter() {
t.walk(f); t.walk(f);
@ -293,29 +293,29 @@ impl TypeWalk for Substs {
} }
} }
impl Substs { impl Substitution {
pub fn interned(&self, _: &Interner) -> &[Ty] { pub fn interned(&self, _: &Interner) -> &[Ty] {
&self.0 &self.0
} }
pub fn empty() -> Substs { pub fn empty() -> Substitution {
Substs(SmallVec::new()) Substitution(SmallVec::new())
} }
pub fn single(ty: Ty) -> Substs { pub fn single(ty: Ty) -> Substitution {
Substs({ Substitution({
let mut v = SmallVec::new(); let mut v = SmallVec::new();
v.push(ty); v.push(ty);
v v
}) })
} }
pub fn prefix(&self, n: usize) -> Substs { pub fn prefix(&self, n: usize) -> Substitution {
Substs(self.0[..std::cmp::min(self.0.len(), n)].into()) Substitution(self.0[..std::cmp::min(self.0.len(), n)].into())
} }
pub fn suffix(&self, n: usize) -> Substs { pub fn suffix(&self, n: usize) -> Substitution {
Substs(self.0[self.0.len() - std::cmp::min(self.0.len(), n)..].into()) Substitution(self.0[self.0.len() - std::cmp::min(self.0.len(), n)..].into())
} }
pub fn as_single(&self) -> &Ty { pub fn as_single(&self) -> &Ty {
@ -326,15 +326,15 @@ impl Substs {
} }
pub fn from_iter(_interner: &Interner, elements: impl IntoIterator<Item = Ty>) -> Self { 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`). /// Return Substs that replace each parameter by itself (i.e. `Ty::Param`).
pub(crate) fn type_params_for_generics( pub(crate) fn type_params_for_generics(
db: &dyn HirDatabase, db: &dyn HirDatabase,
generic_params: &Generics, generic_params: &Generics,
) -> Substs { ) -> Substitution {
Substs( Substitution(
generic_params generic_params
.iter() .iter()
.map(|(id, _)| TyKind::Placeholder(to_placeholder_idx(db, id)).intern(&Interner)) .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`). /// 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()); 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. /// Return Substs that replace each parameter by a bound variable.
pub(crate) fn bound_vars(generic_params: &Generics, debruijn: DebruijnIndex) -> Substs { pub(crate) fn bound_vars(generic_params: &Generics, debruijn: DebruijnIndex) -> Substitution {
Substs( Substitution(
generic_params generic_params
.iter() .iter()
.enumerate() .enumerate()
@ -363,11 +363,11 @@ impl Substs {
let def = def.into(); let def = def.into();
let params = generics(db.upcast(), def); let params = generics(db.upcast(), def);
let param_count = params.len(); let param_count = params.len();
Substs::builder(param_count) Substitution::builder(param_count)
} }
pub(crate) fn build_for_generics(generic_params: &Generics) -> SubstsBuilder { 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 { fn builder(param_count: usize) -> SubstsBuilder {
@ -387,9 +387,9 @@ pub struct SubstsBuilder {
} }
impl SubstsBuilder { impl SubstsBuilder {
pub fn build(self) -> Substs { pub fn build(self) -> Substitution {
assert_eq!(self.vec.len(), self.param_count); assert_eq!(self.vec.len(), self.param_count);
Substs(self.vec.into()) Substitution(self.vec.into())
} }
pub fn push(mut self, ty: Ty) -> Self { pub fn push(mut self, ty: Ty) -> Self {
@ -418,7 +418,7 @@ impl SubstsBuilder {
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!(self.vec.is_empty());
assert!(parent_substs.len() <= self.param_count); assert!(parent_substs.len() <= self.param_count);
self.vec.extend(parent_substs.iter().cloned()); self.vec.extend(parent_substs.iter().cloned());
@ -426,7 +426,7 @@ impl SubstsBuilder {
} }
} }
impl Deref for Substs { impl Deref for Substitution {
type Target = [Ty]; type Target = [Ty];
fn deref(&self) -> &[Ty] { fn deref(&self) -> &[Ty] {
@ -466,13 +466,13 @@ impl<T: Clone> Binders<&T> {
impl<T: TypeWalk> Binders<T> { impl<T: TypeWalk> Binders<T> {
/// Substitutes all variables. /// Substitutes all variables.
pub fn subst(self, subst: &Substs) -> T { pub fn subst(self, subst: &Substitution) -> T {
assert_eq!(subst.len(), self.num_binders); assert_eq!(subst.len(), self.num_binders);
self.value.subst_bound_vars(subst) self.value.subst_bound_vars(subst)
} }
/// Substitutes just a prefix of the variables (shifting the rest). /// 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); assert!(subst.len() < self.num_binders);
Binders::new(self.num_binders - subst.len(), self.value.subst_bound_vars(subst)) 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 { pub struct TraitRef {
/// FIXME name? /// FIXME name?
pub trait_: TraitId, pub trait_: TraitId,
pub substs: Substs, pub substs: Substitution,
} }
impl TraitRef { 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 } CallableSig { params_and_return: substs.iter().cloned().collect(), is_varargs: false }
} }
@ -651,10 +651,10 @@ impl TypeWalk for CallableSig {
impl Ty { impl Ty {
pub fn unit() -> Self { 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::Adt(AdtId(adt), substs).intern(&Interner)
} }
@ -662,7 +662,7 @@ impl Ty {
TyKind::Function(FnPointer { TyKind::Function(FnPointer {
num_args: sig.params().len(), num_args: sig.params().len(),
sig: FnSig { abi: (), safety: Safety::Safe, variadic: sig.is_varargs }, 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) .intern(&Interner)
} }
@ -709,14 +709,14 @@ impl Ty {
t 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) { match self.interned(&Interner) {
TyKind::Adt(AdtId(adt), parameters) => Some((*adt, parameters)), TyKind::Adt(AdtId(adt), parameters) => Some((*adt, parameters)),
_ => None, _ => None,
} }
} }
pub fn as_tuple(&self) -> Option<&Substs> { pub fn as_tuple(&self) -> Option<&Substitution> {
match self.interned(&Interner) { match self.interned(&Interner) {
TyKind::Tuple(_, substs) => Some(substs), TyKind::Tuple(_, substs) => Some(substs),
_ => None, _ => None,
@ -828,7 +828,7 @@ impl Ty {
/// Returns the type parameters of this type if it has some (i.e. is an ADT /// 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`. /// 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) { match self.interned(&Interner) {
TyKind::Adt(_, substs) TyKind::Adt(_, substs)
| TyKind::FnDef(_, 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() { match self.interned_mut() {
TyKind::Adt(_, substs) TyKind::Adt(_, substs)
| TyKind::FnDef(_, substs) | TyKind::FnDef(_, substs)
@ -869,7 +869,7 @@ impl Ty {
// So just provide the Future trait. // So just provide the Future trait.
let impl_bound = GenericPredicate::Implemented(TraitRef { let impl_bound = GenericPredicate::Implemented(TraitRef {
trait_: future_trait, trait_: future_trait,
substs: Substs::empty(), substs: Substitution::empty(),
}); });
Some(vec![impl_bound]) Some(vec![impl_bound])
} else { } else {
@ -992,7 +992,7 @@ pub trait TypeWalk {
} }
/// Substitutes `TyKind::Bound` vars with the given substitution. /// 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 where
Self: Sized, Self: Sized,
{ {
@ -1000,7 +1000,7 @@ pub trait TypeWalk {
} }
/// Substitutes `TyKind::Bound` vars with the given substitution. /// 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 where
Self: Sized, 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, AliasTy, Binders, BoundVar, CallableSig, DebruijnIndex, FnPointer, FnSig, GenericPredicate,
ImplTraitId, OpaqueTy, PolyFnSig, ProjectionPredicate, ProjectionTy, ReturnTypeImplTrait, ImplTraitId, OpaqueTy, PolyFnSig, ProjectionPredicate, ProjectionTy, ReturnTypeImplTrait,
ReturnTypeImplTraits, Substs, TraitEnvironment, TraitRef, Ty, TyKind, TypeWalk, ReturnTypeImplTraits, Substitution, TraitEnvironment, TraitRef, Ty, TyKind, TypeWalk,
}; };
#[derive(Debug)] #[derive(Debug)]
@ -151,7 +151,7 @@ impl<'a> TyLoweringContext<'a> {
TypeRef::Never => TyKind::Never.intern(&Interner), TypeRef::Never => TyKind::Never.intern(&Interner),
TypeRef::Tuple(inner) => { TypeRef::Tuple(inner) => {
let inner_tys = inner.iter().map(|tr| self.lower_ty(tr)); 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) .intern(&Interner)
} }
TypeRef::Path(path) => { TypeRef::Path(path) => {
@ -177,7 +177,7 @@ impl<'a> TyLoweringContext<'a> {
} }
TypeRef::Placeholder => TyKind::Unknown.intern(&Interner), TypeRef::Placeholder => TyKind::Unknown.intern(&Interner),
TypeRef::Fn(params, is_varargs) => { 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 { TyKind::Function(FnPointer {
num_args: substs.len() - 1, num_args: substs.len() - 1,
sig: FnSig { abi: (), safety: Safety::Safe, variadic: *is_varargs }, 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 impl_trait_id = ImplTraitId::ReturnTypeImplTrait(func, idx);
let opaque_ty_id = self.db.intern_impl_trait_id(impl_trait_id).into(); let opaque_ty_id = self.db.intern_impl_trait_id(impl_trait_id).into();
let generics = generics(self.db.upcast(), func.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 { TyKind::Alias(AliasTy::Opaque(OpaqueTy {
opaque_ty_id, opaque_ty_id,
substitution: parameters, substitution: parameters,
@ -398,10 +398,10 @@ impl<'a> TyLoweringContext<'a> {
let generics = generics(self.db.upcast(), impl_id.into()); let generics = generics(self.db.upcast(), impl_id.into());
let substs = match self.type_param_mode { let substs = match self.type_param_mode {
TypeParamLoweringMode::Placeholder => { TypeParamLoweringMode::Placeholder => {
Substs::type_params_for_generics(self.db, &generics) Substitution::type_params_for_generics(self.db, &generics)
} }
TypeParamLoweringMode::Variable => { 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) 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 generics = generics(self.db.upcast(), adt.into());
let substs = match self.type_param_mode { let substs = match self.type_param_mode {
TypeParamLoweringMode::Placeholder => { TypeParamLoweringMode::Placeholder => {
Substs::type_params_for_generics(self.db, &generics) Substitution::type_params_for_generics(self.db, &generics)
} }
TypeParamLoweringMode::Variable => { TypeParamLoweringMode::Variable => {
Substs::bound_vars(&generics, self.in_binders) Substitution::bound_vars(&generics, self.in_binders)
} }
}; };
self.db.ty(adt.into()).subst(&substs) self.db.ty(adt.into()).subst(&substs)
@ -464,7 +464,7 @@ impl<'a> TyLoweringContext<'a> {
TypeParamLoweringMode::Placeholder => { TypeParamLoweringMode::Placeholder => {
// if we're lowering to placeholders, we have to put // if we're lowering to placeholders, we have to put
// them in now // them in now
let s = Substs::type_params( let s = Substitution::type_params(
self.db, self.db,
self.resolver.generic_def().expect( self.resolver.generic_def().expect(
"there should be generics if there's a generic param", "there should be generics if there's a generic param",
@ -522,7 +522,7 @@ impl<'a> TyLoweringContext<'a> {
// special-case enum variants // special-case enum variants
resolved: ValueTyDefId, resolved: ValueTyDefId,
infer_args: bool, infer_args: bool,
) -> Substs { ) -> Substitution {
let last = path.segments().last().expect("path should have at least one segment"); let last = path.segments().last().expect("path should have at least one segment");
let (segment, generic_def) = match resolved { let (segment, generic_def) = match resolved {
ValueTyDefId::FunctionId(it) => (last, Some(it.into())), ValueTyDefId::FunctionId(it) => (last, Some(it.into())),
@ -553,7 +553,7 @@ impl<'a> TyLoweringContext<'a> {
segment: PathSegment<'_>, segment: PathSegment<'_>,
def_generic: Option<GenericDefId>, def_generic: Option<GenericDefId>,
infer_args: bool, infer_args: bool,
) -> Substs { ) -> Substitution {
let mut substs = Vec::new(); let mut substs = Vec::new();
let def_generics = def_generic.map(|def| generics(self.db.upcast(), def)); 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()) { for default_ty in defaults.iter().skip(substs.len()) {
// each default can depend on the previous parameters // 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)); substs.push(default_ty.clone().subst(&substs_so_far));
} }
} }
@ -614,7 +614,7 @@ impl<'a> TyLoweringContext<'a> {
} }
assert_eq!(substs.len(), total_len); assert_eq!(substs.len(), total_len);
Substs(substs.into()) Substitution(substs.into())
} }
fn lower_trait_ref_from_path( fn lower_trait_ref_from_path(
@ -656,7 +656,11 @@ impl<'a> TyLoweringContext<'a> {
self.lower_trait_ref_from_path(path, explicit_self_ty) 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) 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 { let trait_ref = TraitRef {
trait_: trait_id, trait_: trait_id,
substs: Substs::bound_vars(&generics, DebruijnIndex::INNERMOST), substs: Substitution::bound_vars(&generics, DebruijnIndex::INNERMOST),
}; };
traits_.push(trait_ref); traits_.push(trait_ref);
} }
@ -945,7 +949,7 @@ pub(crate) fn trait_environment_query(
// function default implementations (and hypothetical code // function default implementations (and hypothetical code
// inside consts or type aliases) // inside consts or type aliases)
cov_mark::hit!(trait_self_implements_self); 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 trait_ref = TraitRef { trait_: trait_id, substs };
let pred = GenericPredicate::Implemented(trait_ref); let pred = GenericPredicate::Implemented(trait_ref);
let program_clause: chalk_ir::ProgramClause<Interner> = let program_clause: chalk_ir::ProgramClause<Interner> =
@ -1033,7 +1037,7 @@ fn fn_sig_for_fn(db: &dyn HirDatabase, def: FunctionId) -> PolyFnSig {
/// function body. /// function body.
fn type_for_fn(db: &dyn HirDatabase, def: FunctionId) -> Binders<Ty> { fn type_for_fn(db: &dyn HirDatabase, def: FunctionId) -> Binders<Ty> {
let generics = generics(db.upcast(), 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( Binders::new(
substs.len(), substs.len(),
TyKind::FnDef(CallableDefId::FunctionId(def).to_chalk(db), substs).intern(&Interner), 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()); return type_for_adt(db, def.into());
} }
let generics = generics(db.upcast(), 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( Binders::new(
substs.len(), substs.len(),
TyKind::FnDef(CallableDefId::StructId(def).to_chalk(db), substs).intern(&Interner), 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()); return type_for_adt(db, def.parent.into());
} }
let generics = generics(db.upcast(), 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( Binders::new(
substs.len(), substs.len(),
TyKind::FnDef(CallableDefId::EnumVariantId(def).to_chalk(db), substs).intern(&Interner), 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> { fn type_for_adt(db: &dyn HirDatabase, adt: AdtId) -> Binders<Ty> {
let generics = generics(db.upcast(), adt.into()); 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)) 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 { if db.type_alias_data(t).is_extern {
Binders::new(0, TyKind::ForeignType(crate::to_foreign_def_id(t)).intern(&Interner)) Binders::new(0, TyKind::ForeignType(crate::to_foreign_def_id(t)).intern(&Interner))
} else { } 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 type_ref = &db.type_alias_data(t).type_ref;
let inner = ctx.lower_ty(type_ref.as_ref().unwrap_or(&TypeRef::Error)); let inner = ctx.lower_ty(type_ref.as_ref().unwrap_or(&TypeRef::Error));
Binders::new(substs.len(), inner) 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}, primitive::{self, FloatTy, IntTy, UintTy},
utils::all_super_traits, utils::all_super_traits,
AdtId, Canonical, DebruijnIndex, FnPointer, FnSig, ForeignDefId, InEnvironment, Interner, 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. /// This is used as a key for indexing impls.
@ -672,10 +672,10 @@ pub(crate) fn inherent_impl_substs(
db: &dyn HirDatabase, db: &dyn HirDatabase,
impl_id: ImplId, impl_id: ImplId,
self_ty: &Canonical<Ty>, self_ty: &Canonical<Ty>,
) -> Option<Substs> { ) -> Option<Substitution> {
// we create a var for each type parameter of the impl; we need to keep in // 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 // 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()) .fill_with_bound_vars(DebruijnIndex::INNERMOST, self_ty.kinds.len())
.build(); .build();
let self_ty_with_vars = db.impl_self_ty(impl_id).subst(&vars); 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 /// This replaces any 'free' Bound vars in `s` (i.e. those with indices past
/// num_vars_to_keep) by `TyKind::Unknown`. /// 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( s.fold_binders(
&mut |ty, binders| { &mut |ty, binders| {
if let TyKind::BoundVar(bound) = ty.interned(&Interner) { if let TyKind::BoundVar(bound) = ty.interned(&Interner) {
@ -716,13 +716,13 @@ fn transform_receiver_ty(
self_ty: &Canonical<Ty>, self_ty: &Canonical<Ty>,
) -> Option<Ty> { ) -> Option<Ty> {
let substs = match function_id.lookup(db.upcast()).container { 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()) .push(self_ty.value.clone())
.fill_with_unknown() .fill_with_unknown()
.build(), .build(),
AssocContainerId::ImplId(impl_id) => { AssocContainerId::ImplId(impl_id) => {
let impl_substs = inherent_impl_substs(db, impl_id, &self_ty)?; 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) .use_parent_substs(&impl_substs)
.fill_with_unknown() .fill_with_unknown()
.build() .build()
@ -768,7 +768,7 @@ fn generic_implements_goal(
self_ty: Canonical<Ty>, self_ty: Canonical<Ty>,
) -> Canonical<InEnvironment<super::Obligation>> { ) -> Canonical<InEnvironment<super::Obligation>> {
let mut kinds = self_ty.kinds.to_vec(); 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) .push(self_ty.value)
.fill_with_bound_vars(DebruijnIndex::INNERMOST, kinds.len()) .fill_with_bound_vars(DebruijnIndex::INNERMOST, kinds.len())
.build(); .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 hir_def::{lang_item::LangItemTarget, TraitId};
use stdx::panic_context; use stdx::panic_context;
use crate::{db::HirDatabase, DebruijnIndex, Substs}; use crate::{db::HirDatabase, DebruijnIndex, Substitution};
use super::{ use super::{
Canonical, GenericPredicate, HirDisplay, ProjectionTy, TraitRef, Ty, TyKind, TypeWalk, Canonical, GenericPredicate, HirDisplay, ProjectionTy, TraitRef, Ty, TyKind, TypeWalk,
@ -252,7 +252,7 @@ fn solution_from_chalk(
} }
#[derive(Clone, Debug, PartialEq, Eq)] #[derive(Clone, Debug, PartialEq, Eq)]
pub struct SolutionVariables(pub Canonical<Substs>); pub struct SolutionVariables(pub Canonical<Substitution>);
#[derive(Clone, Debug, PartialEq, Eq)] #[derive(Clone, Debug, PartialEq, Eq)]
/// A (possible) solution for a proposed goal. /// 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, to_assoc_type_id,
utils::generics, utils::generics,
BoundVar, CallableDefId, CallableSig, DebruijnIndex, FnDefId, GenericPredicate, BoundVar, CallableDefId, CallableSig, DebruijnIndex, FnDefId, GenericPredicate,
ProjectionPredicate, ProjectionTy, Substs, TraitRef, Ty, TyKind, ProjectionPredicate, ProjectionTy, Substitution, TraitRef, Ty, TyKind,
}; };
use mapping::{ use mapping::{
convert_where_clauses, generic_predicate_to_inline_bound, make_binders, TypeAliasAsValue, 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 { let impl_bound = GenericPredicate::Implemented(TraitRef {
trait_: future_trait, trait_: future_trait,
// Self type as the first parameter. // Self type as the first parameter.
substs: Substs::single( substs: Substitution::single(
TyKind::BoundVar(BoundVar { TyKind::BoundVar(BoundVar {
debruijn: DebruijnIndex::INNERMOST, debruijn: DebruijnIndex::INNERMOST,
index: 0, index: 0,
@ -236,7 +236,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
projection_ty: ProjectionTy { projection_ty: ProjectionTy {
associated_ty_id: to_assoc_type_id(future_output), associated_ty_id: to_assoc_type_id(future_output),
// Self type as the first parameter. // Self type as the first parameter.
substitution: Substs::single( substitution: Substitution::single(
TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0)) TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0))
.intern(&Interner), .intern(&Interner),
), ),
@ -313,7 +313,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
_closure_id: chalk_ir::ClosureId<Interner>, _closure_id: chalk_ir::ClosureId<Interner>,
_substs: &chalk_ir::Substitution<Interner>, _substs: &chalk_ir::Substitution<Interner>,
) -> 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 { 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` // 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 type_alias_data = db.type_alias_data(type_alias);
let generic_params = generics(db.upcast(), type_alias.into()); 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 resolver = hir_def::resolver::HasResolver::resolver(type_alias, db.upcast());
let ctx = crate::TyLoweringContext::new(db, &resolver) let ctx = crate::TyLoweringContext::new(db, &resolver)
.with_type_param_mode(crate::lower::TypeParamLoweringMode::Variable); .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_); let trait_data = db.trait_data(trait_);
debug!("trait {:?} = {:?}", trait_id, trait_data.name); debug!("trait {:?} = {:?}", trait_id, trait_data.name);
let generic_params = generics(db.upcast(), trait_.into()); 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 { let flags = rust_ir::TraitFlags {
auto: trait_data.is_auto, auto: trait_data.is_auto,
upstream: trait_.lookup(db.upcast()).container.krate() != krate, 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 upstream = adt_id.module(db.upcast()).krate() != krate;
let where_clauses = { let where_clauses = {
let generic_params = generics(db.upcast(), adt_id.into()); 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) convert_where_clauses(db, adt_id.into(), &bound_vars)
}; };
let flags = rust_ir::AdtFlags { let flags = rust_ir::AdtFlags {
@ -545,7 +545,7 @@ fn impl_def_datum(
let impl_data = db.impl_data(impl_id); let impl_data = db.impl_data(impl_id);
let generic_params = generics(db.upcast(), impl_id.into()); 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 trait_ = trait_ref.trait_;
let impl_type = if impl_id.lookup(db.upcast()).container.krate() == krate { let impl_type = if impl_id.lookup(db.upcast()).container.krate() == krate {
rust_ir::ImplType::Local 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 callable_def: CallableDefId = from_chalk(db, fn_def_id);
let generic_params = generics(db.upcast(), callable_def.into()); let generic_params = generics(db.upcast(), callable_def.into());
let sig = db.callable_item_signature(callable_def); 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 where_clauses = convert_where_clauses(db, callable_def.into(), &bound_vars);
let bound = rust_ir::FnDefDatumBound { 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 // 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, primitive::UintTy,
traits::{Canonical, Obligation}, traits::{Canonical, Obligation},
AliasTy, CallableDefId, FnPointer, GenericPredicate, InEnvironment, OpaqueTy, AliasTy, CallableDefId, FnPointer, GenericPredicate, InEnvironment, OpaqueTy,
ProjectionPredicate, ProjectionTy, Scalar, Substs, TraitRef, Ty, ProjectionPredicate, ProjectionTy, Scalar, Substitution, TraitRef, Ty,
}; };
use super::interner::*; use super::interner::*;
@ -134,7 +134,7 @@ impl ToChalk for Ty {
.. ..
}) => { }) => {
assert_eq!(num_binders, 0); assert_eq!(num_binders, 0);
let substs: Substs = from_chalk( let substs: Substitution = from_chalk(
db, db,
substitution.0.shifted_out(&Interner).expect("fn ptr should have no binders"), 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) chalk_ir::TyKind::Array(arg, const_).intern(&Interner)
} }
impl ToChalk for Substs { impl ToChalk for Substitution {
type Chalk = chalk_ir::Substitution<Interner>; type Chalk = chalk_ir::Substitution<Interner>;
fn to_chalk(self, db: &dyn HirDatabase) -> 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))) 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 let tys = parameters
.iter(&Interner) .iter(&Interner)
.map(|p| match p.ty(&Interner) { .map(|p| match p.ty(&Interner) {
@ -228,7 +231,7 @@ impl ToChalk for Substs {
None => unimplemented!(), None => unimplemented!(),
}) })
.collect(); .collect();
Substs(tys) Substitution(tys)
} }
} }
@ -489,7 +492,7 @@ where
pub(super) fn convert_where_clauses( pub(super) fn convert_where_clauses(
db: &dyn HirDatabase, db: &dyn HirDatabase,
def: GenericDefId, def: GenericDefId,
substs: &Substs, substs: &Substitution,
) -> Vec<chalk_ir::QuantifiedWhereClause<Interner>> { ) -> Vec<chalk_ir::QuantifiedWhereClause<Interner>> {
let generic_predicates = db.generic_predicates(def); let generic_predicates = db.generic_predicates(def);
let mut result = Vec::with_capacity(generic_predicates.len()); let mut result = Vec::with_capacity(generic_predicates.len());