Merge #8041

8041: Rename Substs -> Substitution r=flodiebold a=flodiebold



Co-authored-by: Florian Diebold <[email protected]>

Author: bors[bot]

crates/hir/src/display.rs

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

crates/hir/src/lib.rs

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

crates/hir/src/source_analyzer.rs

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

crates/hir_ty/src/autoderef.rs

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

crates/hir_ty/src/display.rs

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

crates/hir_ty/src/infer.rs

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

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();

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<Generics>,
         generic_args: Option<&GenericArgs>,
         receiver_ty: &Ty,
-    ) -> Substs {
+    ) -> Substitution {
         let (parent_params, self_params, type_params, impl_trait_params) =
             def_generics.as_ref().map_or((0, 0, 0, 0), |g| g.provenance_split());
         assert_eq!(self_params, 0); // method shouldn't have another Self param
@@ -926,7 +927,7 @@ impl<'a> InferenceContext<'a> {
             substs.push(self.err_ty());
         }
         assert_eq!(substs.len(), total_len);
-        Substs(substs.into())
+        Substitution(substs.into())
     }
 
     fn register_obligations_for_call(&mut self, callable_ty: &Ty) {

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(),
             },