From 96ddf2962c3d26c256ab2d1ab725d8dcdc5956e0 Mon Sep 17 00:00:00 2001 From: Florian Diebold Date: Fri, 17 Jan 2020 22:12:15 +0100 Subject: Upgrade Chalk --- crates/ra_hir_ty/src/traits/chalk.rs | 108 +++++++++++++++++------------------ 1 file changed, 53 insertions(+), 55 deletions(-) (limited to 'crates/ra_hir_ty/src/traits/chalk.rs') diff --git a/crates/ra_hir_ty/src/traits/chalk.rs b/crates/ra_hir_ty/src/traits/chalk.rs index 555930c9b..fe9cb556c 100644 --- a/crates/ra_hir_ty/src/traits/chalk.rs +++ b/crates/ra_hir_ty/src/traits/chalk.rs @@ -3,7 +3,7 @@ use std::{fmt, sync::Arc}; use log::debug; -use chalk_ir::{cast::Cast, Parameter, PlaceholderIndex, TypeName, UniverseIndex}; +use chalk_ir::{cast::Cast, GoalData, Parameter, PlaceholderIndex, TypeName, UniverseIndex}; use hir_def::{AssocContainerId, AssocItemId, GenericDefId, HasModule, Lookup, TypeAliasId}; use ra_db::{ @@ -24,6 +24,8 @@ impl chalk_ir::family::TypeFamily for TypeFamily { type InternedType = Box>; type InternedLifetime = chalk_ir::LifetimeData; type InternedParameter = chalk_ir::ParameterData; + type InternedGoal = Arc>; + type InternedSubstitution = Vec>; type DefId = InternId; // FIXME: implement these @@ -48,8 +50,8 @@ impl chalk_ir::family::TypeFamily for TypeFamily { None } - fn debug_projection( - _projection: &chalk_ir::ProjectionTy, + fn debug_alias( + _projection: &chalk_ir::AliasTy, _fmt: &mut fmt::Formatter<'_>, ) -> Option { None @@ -78,6 +80,24 @@ impl chalk_ir::family::TypeFamily for TypeFamily { fn parameter_data(parameter: &chalk_ir::ParameterData) -> &chalk_ir::ParameterData { parameter } + + fn intern_goal(goal: GoalData) -> Arc> { + Arc::new(goal) + } + + fn goal_data(goal: &Arc>) -> &GoalData { + goal + } + + fn intern_substitution( + data: impl IntoIterator, E>>, + ) -> Result>, E> { + data.into_iter().collect() + } + + fn substitution_data(substitution: &Vec>) -> &[Parameter] { + substitution + } } impl chalk_ir::family::HasTypeFamily for TypeFamily { @@ -114,13 +134,13 @@ impl ToChalk for Ty { match self { Ty::Apply(apply_ty) => { let name = apply_ty.ctor.to_chalk(db); - let parameters = apply_ty.parameters.to_chalk(db); - chalk_ir::ApplicationTy { name, parameters }.cast().intern() + let substitution = apply_ty.parameters.to_chalk(db); + chalk_ir::ApplicationTy { name, substitution }.cast().intern() } Ty::Projection(proj_ty) => { let associated_ty_id = proj_ty.associated_ty.to_chalk(db); - let parameters = proj_ty.parameters.to_chalk(db); - chalk_ir::ProjectionTy { associated_ty_id, parameters }.cast().intern() + let substitution = proj_ty.parameters.to_chalk(db); + chalk_ir::AliasTy { associated_ty_id, substitution }.cast().intern() } Ty::Param { idx, .. } => { PlaceholderIndex { ui: UniverseIndex::ROOT, idx: idx as usize } @@ -135,23 +155,13 @@ impl ToChalk for Ty { .cloned() .map(|p| p.to_chalk(db)) .collect(); - let bounded_ty = chalk_ir::BoundedTy { bounds: make_binders(where_clauses, 1) }; + let bounded_ty = chalk_ir::DynTy { bounds: make_binders(where_clauses, 1) }; chalk_ir::TyData::Dyn(bounded_ty).intern() } - Ty::Opaque(predicates) => { - let where_clauses = predicates - .iter() - .filter(|p| !p.is_error()) - .cloned() - .map(|p| p.to_chalk(db)) - .collect(); - let bounded_ty = chalk_ir::BoundedTy { bounds: make_binders(where_clauses, 1) }; - chalk_ir::TyData::Opaque(bounded_ty).intern() - } - Ty::Unknown => { - let parameters = Vec::new(); + Ty::Opaque(_) | Ty::Unknown => { + let substitution = chalk_ir::Substitution::empty(); let name = TypeName::Error; - chalk_ir::ApplicationTy { name, parameters }.cast().intern() + chalk_ir::ApplicationTy { name, substitution }.cast().intern() } } } @@ -161,7 +171,7 @@ impl ToChalk for Ty { TypeName::Error => Ty::Unknown, _ => { let ctor = from_chalk(db, apply_ty.name); - let parameters = from_chalk(db, apply_ty.parameters); + let parameters = from_chalk(db, apply_ty.substitution); Ty::Apply(ApplicationTy { ctor, parameters }) } }, @@ -169,12 +179,12 @@ impl ToChalk for Ty { assert_eq!(idx.ui, UniverseIndex::ROOT); Ty::Param { idx: idx.idx as u32, name: crate::Name::missing() } } - chalk_ir::TyData::Projection(proj) => { + chalk_ir::TyData::Alias(proj) => { let associated_ty = from_chalk(db, proj.associated_ty_id); - let parameters = from_chalk(db, proj.parameters); + let parameters = from_chalk(db, proj.substitution); Ty::Projection(ProjectionTy { associated_ty, parameters }) } - chalk_ir::TyData::ForAll(_) => unimplemented!(), + chalk_ir::TyData::Function(_) => unimplemented!(), chalk_ir::TyData::BoundVar(idx) => Ty::Bound(idx as u32), chalk_ir::TyData::InferenceVar(_iv) => Ty::Unknown, chalk_ir::TyData::Dyn(where_clauses) => { @@ -183,27 +193,18 @@ impl ToChalk for Ty { where_clauses.bounds.value.into_iter().map(|c| from_chalk(db, c)).collect(); Ty::Dyn(predicates) } - chalk_ir::TyData::Opaque(where_clauses) => { - assert_eq!(where_clauses.bounds.binders.len(), 1); - let predicates = - where_clauses.bounds.value.into_iter().map(|c| from_chalk(db, c)).collect(); - Ty::Opaque(predicates) - } } } } impl ToChalk for Substs { - type Chalk = Vec>; + type Chalk = chalk_ir::Substitution; - fn to_chalk(self, db: &impl HirDatabase) -> Vec> { - self.iter().map(|ty| ty.clone().to_chalk(db).cast()).collect() + fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::Substitution { + chalk_ir::Substitution::from(self.iter().map(|ty| ty.clone().to_chalk(db))) } - fn from_chalk( - db: &impl HirDatabase, - parameters: Vec>, - ) -> Substs { + fn from_chalk(db: &impl HirDatabase, parameters: chalk_ir::Substitution) -> Substs { let tys = parameters .into_iter() .map(|p| match p.ty() { @@ -220,13 +221,13 @@ impl ToChalk for TraitRef { fn to_chalk(self: TraitRef, db: &impl HirDatabase) -> chalk_ir::TraitRef { let trait_id = self.trait_.to_chalk(db); - let parameters = self.substs.to_chalk(db); - chalk_ir::TraitRef { trait_id, parameters } + let substitution = self.substs.to_chalk(db); + chalk_ir::TraitRef { trait_id, substitution } } fn from_chalk(db: &impl HirDatabase, trait_ref: chalk_ir::TraitRef) -> Self { let trait_ = from_chalk(db, trait_ref.trait_id); - let substs = from_chalk(db, trait_ref.parameters); + let substs = from_chalk(db, trait_ref.substitution); TraitRef { trait_, substs } } } @@ -317,8 +318,8 @@ impl ToChalk for GenericPredicate { make_binders(chalk_ir::WhereClause::Implemented(trait_ref.to_chalk(db)), 0) } GenericPredicate::Projection(projection_pred) => make_binders( - chalk_ir::WhereClause::ProjectionEq(chalk_ir::ProjectionEq { - projection: projection_pred.projection_ty.to_chalk(db), + chalk_ir::WhereClause::AliasEq(chalk_ir::AliasEq { + alias: projection_pred.projection_ty.to_chalk(db), ty: projection_pred.ty.to_chalk(db), }), 0, @@ -335,8 +336,8 @@ impl ToChalk for GenericPredicate { chalk_ir::WhereClause::Implemented(tr) => { GenericPredicate::Implemented(from_chalk(db, tr)) } - chalk_ir::WhereClause::ProjectionEq(projection_eq) => { - let projection_ty = from_chalk(db, projection_eq.projection); + chalk_ir::WhereClause::AliasEq(projection_eq) => { + let projection_ty = from_chalk(db, projection_eq.alias); let ty = from_chalk(db, projection_eq.ty); GenericPredicate::Projection(super::ProjectionPredicate { projection_ty, ty }) } @@ -345,22 +346,22 @@ impl ToChalk for GenericPredicate { } impl ToChalk for ProjectionTy { - type Chalk = chalk_ir::ProjectionTy; + type Chalk = chalk_ir::AliasTy; - fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::ProjectionTy { - chalk_ir::ProjectionTy { + fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::AliasTy { + chalk_ir::AliasTy { associated_ty_id: self.associated_ty.to_chalk(db), - parameters: self.parameters.to_chalk(db), + substitution: self.parameters.to_chalk(db), } } fn from_chalk( db: &impl HirDatabase, - projection_ty: chalk_ir::ProjectionTy, + projection_ty: chalk_ir::AliasTy, ) -> ProjectionTy { ProjectionTy { associated_ty: from_chalk(db, projection_ty.associated_ty_id), - parameters: from_chalk(db, projection_ty.parameters), + parameters: from_chalk(db, projection_ty.substitution), } } } @@ -369,10 +370,7 @@ impl ToChalk for super::ProjectionPredicate { type Chalk = chalk_ir::Normalize; fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::Normalize { - chalk_ir::Normalize { - projection: self.projection_ty.to_chalk(db), - ty: self.ty.to_chalk(db), - } + chalk_ir::Normalize { alias: self.projection_ty.to_chalk(db), ty: self.ty.to_chalk(db) } } fn from_chalk(_db: &impl HirDatabase, _normalize: chalk_ir::Normalize) -> Self { -- cgit v1.2.3 From ed25cf70d5e0df9c7a33deb503ea14c2d97bd7a7 Mon Sep 17 00:00:00 2001 From: Florian Diebold Date: Fri, 31 Jan 2020 16:52:43 +0100 Subject: Change Ty::Param to contain param ID --- crates/ra_hir_ty/src/traits/chalk.rs | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) (limited to 'crates/ra_hir_ty/src/traits/chalk.rs') diff --git a/crates/ra_hir_ty/src/traits/chalk.rs b/crates/ra_hir_ty/src/traits/chalk.rs index fe9cb556c..6e97f7dd2 100644 --- a/crates/ra_hir_ty/src/traits/chalk.rs +++ b/crates/ra_hir_ty/src/traits/chalk.rs @@ -142,8 +142,9 @@ impl ToChalk for Ty { let substitution = proj_ty.parameters.to_chalk(db); chalk_ir::AliasTy { associated_ty_id, substitution }.cast().intern() } - Ty::Param { idx, .. } => { - PlaceholderIndex { ui: UniverseIndex::ROOT, idx: idx as usize } + Ty::Param(id) => { + let interned_id = db.intern_type_param_id(id); + PlaceholderIndex { ui: UniverseIndex::ROOT, idx: interned_id.as_intern_id().as_usize() } .to_ty::() } Ty::Bound(idx) => chalk_ir::TyData::BoundVar(idx as usize).intern(), @@ -177,7 +178,8 @@ impl ToChalk for Ty { }, chalk_ir::TyData::Placeholder(idx) => { assert_eq!(idx.ui, UniverseIndex::ROOT); - Ty::Param { idx: idx.idx as u32, name: crate::Name::missing() } + let interned_id = crate::db::GlobalTypeParamId::from_intern_id(crate::salsa::InternId::from(idx.idx)); + Ty::Param(db.lookup_intern_type_param_id(interned_id)) } chalk_ir::TyData::Alias(proj) => { let associated_ty = from_chalk(db, proj.associated_ty_id); @@ -524,7 +526,7 @@ fn convert_where_clauses( // skip errored predicates completely continue; } - result.push(pred.clone().subst(substs).to_chalk(db)); + result.push(pred.clone().subst_type_params(db, def, substs).to_chalk(db)); } result } @@ -709,12 +711,12 @@ fn impl_block_datum( let trait_ref = db .impl_trait(impl_id) // ImplIds for impls where the trait ref can't be resolved should never reach Chalk - .expect("invalid impl passed to Chalk"); + .expect("invalid impl passed to Chalk") + .value; let impl_data = db.impl_data(impl_id); let generic_params = generics(db, impl_id.into()); let bound_vars = Substs::bound_vars(&generic_params); - let trait_ref = trait_ref.subst(&bound_vars); let trait_ = trait_ref.trait_; let impl_type = if impl_id.lookup(db).container.module(db).krate == krate { chalk_rust_ir::ImplType::Local @@ -789,20 +791,18 @@ fn type_alias_associated_ty_value( _ => panic!("assoc ty value should be in impl"), }; - let trait_ref = db.impl_trait(impl_id).expect("assoc ty value should not exist"); // we don't return any assoc ty values if the impl'd trait can't be resolved + let trait_ref = db.impl_trait(impl_id).expect("assoc ty value should not exist").value; // we don't return any assoc ty values if the impl'd trait can't be resolved let assoc_ty = db .trait_data(trait_ref.trait_) .associated_type_by_name(&type_alias_data.name) .expect("assoc ty value should not exist"); // validated when building the impl data as well - let generic_params = generics(db, impl_id.into()); - let bound_vars = Substs::bound_vars(&generic_params); - let ty = db.ty(type_alias.into()).subst(&bound_vars); - let value_bound = chalk_rust_ir::AssociatedTyValueBound { ty: ty.to_chalk(db) }; + let ty = db.ty(type_alias.into()); + let value_bound = chalk_rust_ir::AssociatedTyValueBound { ty: ty.value.to_chalk(db) }; let value = chalk_rust_ir::AssociatedTyValue { impl_id: Impl::ImplBlock(impl_id.into()).to_chalk(db), associated_ty_id: assoc_ty.to_chalk(db), - value: make_binders(value_bound, bound_vars.len()), + value: make_binders(value_bound, ty.num_binders), }; Arc::new(value) } -- cgit v1.2.3 From a3d8cffde39bfb0d50b87a8ded5e0534adec4cd5 Mon Sep 17 00:00:00 2001 From: Florian Diebold Date: Sun, 2 Feb 2020 17:11:54 +0100 Subject: Use variables in predicates as well --- crates/ra_hir_ty/src/traits/chalk.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'crates/ra_hir_ty/src/traits/chalk.rs') diff --git a/crates/ra_hir_ty/src/traits/chalk.rs b/crates/ra_hir_ty/src/traits/chalk.rs index 6e97f7dd2..8260bd157 100644 --- a/crates/ra_hir_ty/src/traits/chalk.rs +++ b/crates/ra_hir_ty/src/traits/chalk.rs @@ -14,7 +14,7 @@ use ra_db::{ use super::{builtin, AssocTyValue, Canonical, ChalkContext, Impl, Obligation}; use crate::{ db::HirDatabase, display::HirDisplay, utils::generics, ApplicationTy, GenericPredicate, - ProjectionTy, Substs, TraitRef, Ty, TypeCtor, TypeWalk, + ProjectionTy, Substs, TraitRef, Ty, TypeCtor, }; #[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)] @@ -522,11 +522,11 @@ fn convert_where_clauses( let generic_predicates = db.generic_predicates(def); let mut result = Vec::with_capacity(generic_predicates.len()); for pred in generic_predicates.iter() { - if pred.is_error() { + if pred.value.is_error() { // skip errored predicates completely continue; } - result.push(pred.clone().subst_type_params(db, def, substs).to_chalk(db)); + result.push(pred.clone().subst(substs).to_chalk(db)); } result } -- cgit v1.2.3 From dded90a748737c3661aad043524f2248e324c867 Mon Sep 17 00:00:00 2001 From: Florian Diebold Date: Fri, 7 Feb 2020 15:13:15 +0100 Subject: Formatting --- crates/ra_hir_ty/src/traits/chalk.rs | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) (limited to 'crates/ra_hir_ty/src/traits/chalk.rs') diff --git a/crates/ra_hir_ty/src/traits/chalk.rs b/crates/ra_hir_ty/src/traits/chalk.rs index 8260bd157..4974c565b 100644 --- a/crates/ra_hir_ty/src/traits/chalk.rs +++ b/crates/ra_hir_ty/src/traits/chalk.rs @@ -144,8 +144,11 @@ impl ToChalk for Ty { } Ty::Param(id) => { let interned_id = db.intern_type_param_id(id); - PlaceholderIndex { ui: UniverseIndex::ROOT, idx: interned_id.as_intern_id().as_usize() } - .to_ty::() + PlaceholderIndex { + ui: UniverseIndex::ROOT, + idx: interned_id.as_intern_id().as_usize(), + } + .to_ty::() } Ty::Bound(idx) => chalk_ir::TyData::BoundVar(idx as usize).intern(), Ty::Infer(_infer_ty) => panic!("uncanonicalized infer ty"), @@ -178,7 +181,9 @@ impl ToChalk for Ty { }, chalk_ir::TyData::Placeholder(idx) => { assert_eq!(idx.ui, UniverseIndex::ROOT); - let interned_id = crate::db::GlobalTypeParamId::from_intern_id(crate::salsa::InternId::from(idx.idx)); + let interned_id = crate::db::GlobalTypeParamId::from_intern_id( + crate::salsa::InternId::from(idx.idx), + ); Ty::Param(db.lookup_intern_type_param_id(interned_id)) } chalk_ir::TyData::Alias(proj) => { -- cgit v1.2.3