From ce2cae45b5242d59b744018dd79bc2ab74670edc Mon Sep 17 00:00:00 2001 From: Florian Diebold Date: Mon, 15 Mar 2021 21:02:34 +0100 Subject: Rename Substs -> Substitution --- crates/hir_ty/src/infer/coerce.rs | 6 ++++-- crates/hir_ty/src/infer/expr.rs | 37 +++++++++++++++++++------------------ crates/hir_ty/src/infer/pat.rs | 12 +++++++----- crates/hir_ty/src/infer/path.rs | 20 ++++++++++---------- crates/hir_ty/src/infer/unify.rs | 16 ++++++++-------- 5 files changed, 48 insertions(+), 43 deletions(-) (limited to 'crates/hir_ty/src/infer') diff --git a/crates/hir_ty/src/infer/coerce.rs b/crates/hir_ty/src/infer/coerce.rs index 137419264..b1f98c507 100644 --- a/crates/hir_ty/src/infer/coerce.rs +++ b/crates/hir_ty/src/infer/coerce.rs @@ -7,7 +7,9 @@ use chalk_ir::{Mutability, TyVariableKind}; use hir_def::lang_item::LangItemTarget; -use crate::{autoderef, traits::Solution, Interner, Obligation, Substs, TraitRef, Ty, TyKind}; +use crate::{ + autoderef, traits::Solution, Interner, Obligation, Substitution, TraitRef, Ty, TyKind, +}; use super::{InEnvironment, InferenceContext}; @@ -134,7 +136,7 @@ impl<'a> InferenceContext<'a> { return None; } - let substs = Substs::build_for_generics(&generic_params) + let substs = Substitution::build_for_generics(&generic_params) .push(from_ty.clone()) .push(to_ty.clone()) .build(); diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs index f40dec17f..0be8c5a90 100644 --- a/crates/hir_ty/src/infer/expr.rs +++ b/crates/hir_ty/src/infer/expr.rs @@ -21,8 +21,8 @@ use crate::{ to_assoc_type_id, traits::{chalk::from_chalk, FnTrait, InEnvironment}, utils::{generics, variant_data, Generics}, - AdtId, Binders, CallableDefId, FnPointer, FnSig, Interner, Obligation, Rawness, Scalar, Substs, - TraitRef, Ty, TyKind, + AdtId, Binders, CallableDefId, FnPointer, FnSig, Interner, Obligation, Rawness, Scalar, + Substitution, TraitRef, Ty, TyKind, }; use super::{ @@ -77,7 +77,7 @@ impl<'a> InferenceContext<'a> { return None; } - let mut param_builder = Substs::builder(num_args); + let mut param_builder = Substitution::builder(num_args); let mut arg_tys = vec![]; for _ in 0..num_args { let arg = self.table.new_type_var(); @@ -87,7 +87,7 @@ impl<'a> InferenceContext<'a> { let parameters = param_builder.build(); let arg_ty = TyKind::Tuple(num_args, parameters).intern(&Interner); let substs = - Substs::build_for_generics(&generic_params).push(ty.clone()).push(arg_ty).build(); + Substitution::build_for_generics(&generic_params).push(ty.clone()).push(arg_ty).build(); let trait_env = Arc::clone(&self.trait_env); let implements_fn_trait = @@ -181,7 +181,7 @@ impl<'a> InferenceContext<'a> { let inner_ty = self.infer_expr(*body, &Expectation::none()); let impl_trait_id = crate::ImplTraitId::AsyncBlockTypeImplTrait(self.owner, *body); let opaque_ty_id = self.db.intern_impl_trait_id(impl_trait_id).into(); - TyKind::OpaqueType(opaque_ty_id, Substs::single(inner_ty)).intern(&Interner) + TyKind::OpaqueType(opaque_ty_id, Substitution::single(inner_ty)).intern(&Interner) } Expr::Loop { body, label } => { self.breakables.push(BreakableContext { @@ -262,12 +262,12 @@ impl<'a> InferenceContext<'a> { let sig_ty = TyKind::Function(FnPointer { num_args: sig_tys.len() - 1, sig: FnSig { abi: (), safety: chalk_ir::Safety::Safe, variadic: false }, - substs: Substs(sig_tys.clone().into()), + substs: Substitution(sig_tys.clone().into()), }) .intern(&Interner); let closure_id = self.db.intern_closure((self.owner, tgt_expr)).into(); let closure_ty = - TyKind::Closure(closure_id, Substs::single(sig_ty)).intern(&Interner); + TyKind::Closure(closure_id, Substitution::single(sig_ty)).intern(&Interner); // Eagerly try to relate the closure type with the expected // type, otherwise we often won't have enough information to @@ -402,7 +402,7 @@ impl<'a> InferenceContext<'a> { self.unify(&ty, &expected.ty); - let substs = ty.substs().cloned().unwrap_or_else(Substs::empty); + let substs = ty.substs().cloned().unwrap_or_else(Substitution::empty); let field_types = def_id.map(|it| self.db.field_types(it)).unwrap_or_default(); let variant_data = def_id.map(|it| variant_data(self.db.upcast(), it)); for field in fields.iter() { @@ -511,7 +511,8 @@ impl<'a> InferenceContext<'a> { Expr::Box { expr } => { let inner_ty = self.infer_expr_inner(*expr, &Expectation::none()); if let Some(box_) = self.resolve_boxed_box() { - let mut sb = Substs::builder(generics(self.db.upcast(), box_.into()).len()); + let mut sb = + Substitution::builder(generics(self.db.upcast(), box_.into()).len()); sb = sb.push(inner_ty); match self.db.generic_defaults(box_.into()).as_ref() { [_, alloc_ty, ..] if !alloc_ty.value.is_unknown() => { @@ -610,31 +611,31 @@ impl<'a> InferenceContext<'a> { let rhs_ty = rhs.map(|e| self.infer_expr(e, &rhs_expect)); match (range_type, lhs_ty, rhs_ty) { (RangeOp::Exclusive, None, None) => match self.resolve_range_full() { - Some(adt) => Ty::adt_ty(adt, Substs::empty()), + Some(adt) => Ty::adt_ty(adt, Substitution::empty()), None => self.err_ty(), }, (RangeOp::Exclusive, None, Some(ty)) => match self.resolve_range_to() { - Some(adt) => Ty::adt_ty(adt, Substs::single(ty)), + Some(adt) => Ty::adt_ty(adt, Substitution::single(ty)), None => self.err_ty(), }, (RangeOp::Inclusive, None, Some(ty)) => { match self.resolve_range_to_inclusive() { - Some(adt) => Ty::adt_ty(adt, Substs::single(ty)), + Some(adt) => Ty::adt_ty(adt, Substitution::single(ty)), None => self.err_ty(), } } (RangeOp::Exclusive, Some(_), Some(ty)) => match self.resolve_range() { - Some(adt) => Ty::adt_ty(adt, Substs::single(ty)), + Some(adt) => Ty::adt_ty(adt, Substitution::single(ty)), None => self.err_ty(), }, (RangeOp::Inclusive, Some(_), Some(ty)) => { match self.resolve_range_inclusive() { - Some(adt) => Ty::adt_ty(adt, Substs::single(ty)), + Some(adt) => Ty::adt_ty(adt, Substitution::single(ty)), None => self.err_ty(), } } (RangeOp::Exclusive, Some(ty), None) => match self.resolve_range_from() { - Some(adt) => Ty::adt_ty(adt, Substs::single(ty)), + Some(adt) => Ty::adt_ty(adt, Substitution::single(ty)), None => self.err_ty(), }, (RangeOp::Inclusive, _, None) => self.err_ty(), @@ -681,7 +682,7 @@ impl<'a> InferenceContext<'a> { self.infer_expr_coerce(*expr, &Expectation::has_type(ty.clone())); } - TyKind::Tuple(tys.len(), Substs(tys.into())).intern(&Interner) + TyKind::Tuple(tys.len(), Substitution(tys.into())).intern(&Interner) } Expr::Array(array) => { let elem_ty = match expected.ty.interned(&Interner) { @@ -887,7 +888,7 @@ impl<'a> InferenceContext<'a> { def_generics: Option, generic_args: Option<&GenericArgs>, receiver_ty: &Ty, - ) -> Substs { + ) -> Substitution { let (parent_params, self_params, type_params, impl_trait_params) = def_generics.as_ref().map_or((0, 0, 0, 0), |g| g.provenance_split()); assert_eq!(self_params, 0); // method shouldn't have another Self param @@ -926,7 +927,7 @@ impl<'a> InferenceContext<'a> { substs.push(self.err_ty()); } assert_eq!(substs.len(), total_len); - Substs(substs.into()) + Substitution(substs.into()) } fn register_obligations_for_call(&mut self, callable_ty: &Ty) { diff --git a/crates/hir_ty/src/infer/pat.rs b/crates/hir_ty/src/infer/pat.rs index 9e8ca18ef..befa0d69b 100644 --- a/crates/hir_ty/src/infer/pat.rs +++ b/crates/hir_ty/src/infer/pat.rs @@ -12,7 +12,9 @@ use hir_def::{ use hir_expand::name::Name; use super::{BindingMode, Expectation, InferenceContext}; -use crate::{lower::lower_to_chalk_mutability, utils::variant_data, Interner, Substs, Ty, TyKind}; +use crate::{ + lower::lower_to_chalk_mutability, utils::variant_data, Interner, Substitution, Ty, TyKind, +}; impl<'a> InferenceContext<'a> { fn infer_tuple_struct_pat( @@ -31,7 +33,7 @@ impl<'a> InferenceContext<'a> { } self.unify(&ty, expected); - let substs = ty.substs().cloned().unwrap_or_else(Substs::empty); + let substs = ty.substs().cloned().unwrap_or_else(Substitution::empty); let field_tys = def.map(|it| self.db.field_types(it)).unwrap_or_default(); let (pre, post) = match ellipsis { @@ -70,7 +72,7 @@ impl<'a> InferenceContext<'a> { self.unify(&ty, expected); - let substs = ty.substs().cloned().unwrap_or_else(Substs::empty); + let substs = ty.substs().cloned().unwrap_or_else(Substitution::empty); let field_tys = def.map(|it| self.db.field_types(it)).unwrap_or_default(); for subpat in subpats { @@ -138,7 +140,7 @@ impl<'a> InferenceContext<'a> { inner_tys.extend(expectations_iter.by_ref().take(n_uncovered_patterns).cloned()); inner_tys.extend(post.iter().zip(expectations_iter).map(infer_pat)); - TyKind::Tuple(inner_tys.len(), Substs(inner_tys.into())).intern(&Interner) + TyKind::Tuple(inner_tys.len(), Substitution(inner_tys.into())).intern(&Interner) } Pat::Or(ref pats) => { if let Some((first_pat, rest)) = pats.split_first() { @@ -237,7 +239,7 @@ impl<'a> InferenceContext<'a> { }; let inner_ty = self.infer_pat(*inner, &inner_expected, default_bm); - Ty::adt_ty(box_adt, Substs::single(inner_ty)) + Ty::adt_ty(box_adt, Substitution::single(inner_ty)) } None => self.err_ty(), }, diff --git a/crates/hir_ty/src/infer/path.rs b/crates/hir_ty/src/infer/path.rs index af108fb6c..ea01d6238 100644 --- a/crates/hir_ty/src/infer/path.rs +++ b/crates/hir_ty/src/infer/path.rs @@ -9,7 +9,7 @@ use hir_def::{ }; use hir_expand::name::Name; -use crate::{method_resolution, Interner, Substs, Ty, TyKind, ValueTyDefId}; +use crate::{method_resolution, Interner, Substitution, Ty, TyKind, ValueTyDefId}; use super::{ExprOrPatId, InferenceContext, TraitRef}; @@ -79,7 +79,7 @@ impl<'a> InferenceContext<'a> { } ValueNs::ImplSelf(impl_id) => { let generics = crate::utils::generics(self.db.upcast(), impl_id.into()); - let substs = Substs::type_params_for_generics(self.db, &generics); + let substs = Substitution::type_params_for_generics(self.db, &generics); let ty = self.db.impl_self_ty(impl_id).subst(&substs); if let Some((AdtId::StructId(struct_id), substs)) = ty.as_adt() { let ty = self.db.value_ty(struct_id.into()).subst(&substs); @@ -94,10 +94,10 @@ impl<'a> InferenceContext<'a> { let ty = self.db.value_ty(typable); // self_subst is just for the parent - let parent_substs = self_subst.unwrap_or_else(Substs::empty); + let parent_substs = self_subst.unwrap_or_else(Substitution::empty); let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver); let substs = ctx.substs_from_path(path, typable, true); - let full_substs = Substs::builder(substs.len()) + let full_substs = Substitution::builder(substs.len()) .use_parent_substs(&parent_substs) .fill(substs.0[parent_substs.len()..].iter().cloned()) .build(); @@ -111,7 +111,7 @@ impl<'a> InferenceContext<'a> { path: &Path, remaining_index: usize, id: ExprOrPatId, - ) -> Option<(ValueNs, Option)> { + ) -> Option<(ValueNs, Option)> { assert!(remaining_index < path.segments().len()); // there may be more intermediate segments between the resolved one and // the end. Only the last segment needs to be resolved to a value; from @@ -164,7 +164,7 @@ impl<'a> InferenceContext<'a> { trait_ref: TraitRef, segment: PathSegment<'_>, id: ExprOrPatId, - ) -> Option<(ValueNs, Option)> { + ) -> Option<(ValueNs, Option)> { let trait_ = trait_ref.trait_; let item = self.db.trait_data(trait_).items.iter().map(|(_name, id)| (*id)).find_map(|item| { @@ -208,7 +208,7 @@ impl<'a> InferenceContext<'a> { ty: Ty, name: &Name, id: ExprOrPatId, - ) -> Option<(ValueNs, Option)> { + ) -> Option<(ValueNs, Option)> { if let TyKind::Unknown = ty.interned(&Interner) { return None; } @@ -241,7 +241,7 @@ impl<'a> InferenceContext<'a> { }; let substs = match container { AssocContainerId::ImplId(impl_id) => { - let impl_substs = Substs::build_for_def(self.db, impl_id) + let impl_substs = Substitution::build_for_def(self.db, impl_id) .fill(iter::repeat_with(|| self.table.new_type_var())) .build(); let impl_self_ty = self.db.impl_self_ty(impl_id).subst(&impl_substs); @@ -250,7 +250,7 @@ impl<'a> InferenceContext<'a> { } AssocContainerId::TraitId(trait_) => { // we're picking this method - let trait_substs = Substs::build_for_def(self.db, trait_) + let trait_substs = Substitution::build_for_def(self.db, trait_) .push(ty.clone()) .fill(std::iter::repeat_with(|| self.table.new_type_var())) .build(); @@ -274,7 +274,7 @@ impl<'a> InferenceContext<'a> { ty: &Ty, name: &Name, id: ExprOrPatId, - ) -> Option<(ValueNs, Option)> { + ) -> Option<(ValueNs, Option)> { let (enum_id, subst) = match ty.as_adt() { Some((AdtId::EnumId(e), subst)) => (e, subst), _ => return None, diff --git a/crates/hir_ty/src/infer/unify.rs b/crates/hir_ty/src/infer/unify.rs index 7795f446f..b2d4f67b3 100644 --- a/crates/hir_ty/src/infer/unify.rs +++ b/crates/hir_ty/src/infer/unify.rs @@ -8,7 +8,7 @@ use ena::unify::{InPlaceUnificationTable, NoError, UnifyKey, UnifyValue}; use super::{InferenceContext, Obligation}; use crate::{ BoundVar, Canonical, DebruijnIndex, FnPointer, GenericPredicate, InEnvironment, InferenceVar, - Interner, Scalar, Substs, Ty, TyKind, TypeWalk, + Interner, Scalar, Substitution, Ty, TyKind, TypeWalk, }; impl<'a> InferenceContext<'a> { @@ -123,10 +123,10 @@ impl Canonicalized { pub(super) fn apply_solution( &self, ctx: &mut InferenceContext<'_>, - solution: Canonical, + solution: Canonical, ) { // the solution may contain new variables, which we need to convert to new inference vars - let new_vars = Substs( + let new_vars = Substitution( solution .kinds .iter() @@ -147,9 +147,9 @@ impl Canonicalized { } } -pub(crate) fn unify(tys: &Canonical<(Ty, Ty)>) -> Option { +pub(crate) fn unify(tys: &Canonical<(Ty, Ty)>) -> Option { let mut table = InferenceTable::new(); - let vars = Substs( + let vars = Substitution( tys.kinds .iter() // we always use type vars here because we want everything to @@ -173,7 +173,7 @@ pub(crate) fn unify(tys: &Canonical<(Ty, Ty)>) -> Option { } } Some( - Substs::builder(tys.kinds.len()) + Substitution::builder(tys.kinds.len()) .fill(vars.iter().map(|v| table.resolve_ty_completely(v.clone()))) .build(), ) @@ -264,8 +264,8 @@ impl InferenceTable { pub(crate) fn unify_substs( &mut self, - substs1: &Substs, - substs2: &Substs, + substs1: &Substitution, + substs2: &Substitution, depth: usize, ) -> bool { substs1.0.iter().zip(substs2.0.iter()).all(|(t1, t2)| self.unify_inner(t1, t2, depth)) -- cgit v1.2.3