From 9afbf2dff43dee3227358f10162d4c77d192ce7a Mon Sep 17 00:00:00 2001 From: Florian Diebold Date: Mon, 8 Jul 2019 21:43:52 +0200 Subject: Unify `normalize` and `implements` to simplify code --- crates/ra_hir/src/db.rs | 13 ++----- crates/ra_hir/src/ty.rs | 2 +- crates/ra_hir/src/ty/autoderef.rs | 6 ++- crates/ra_hir/src/ty/infer.rs | 64 +++++++++---------------------- crates/ra_hir/src/ty/infer/unify.rs | 32 ++++++---------- crates/ra_hir/src/ty/method_resolution.rs | 16 ++++---- crates/ra_hir/src/ty/traits.rs | 21 ++-------- crates/ra_hir/src/ty/traits/chalk.rs | 17 +++++++- crates/ra_ide_api/src/change.rs | 3 +- 9 files changed, 67 insertions(+), 107 deletions(-) (limited to 'crates') diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs index e0a37e13d..b0c027631 100644 --- a/crates/ra_hir/src/db.rs +++ b/crates/ra_hir/src/db.rs @@ -213,18 +213,11 @@ pub trait HirDatabase: DefDatabase + AstDatabase { #[salsa::invoke(crate::ty::traits::chalk::impl_datum_query)] fn impl_datum(&self, krate: Crate, impl_id: chalk_ir::ImplId) -> Arc; - #[salsa::invoke(crate::ty::traits::implements_query)] - fn implements( + #[salsa::invoke(crate::ty::traits::solve_query)] + fn solve( &self, krate: Crate, - goal: crate::ty::Canonical>, - ) -> Option; - - #[salsa::invoke(crate::ty::traits::normalize_query)] - fn normalize( - &self, - krate: Crate, - goal: crate::ty::Canonical>, + goal: crate::ty::Canonical>, ) -> Option; } diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs index b45a188d1..9accffcbc 100644 --- a/crates/ra_hir/src/ty.rs +++ b/crates/ra_hir/src/ty.rs @@ -26,7 +26,7 @@ pub(crate) use lower::{ callable_item_sig, generic_defaults_query, generic_predicates_query, type_for_def, type_for_field, TypableDef, }; -pub(crate) use traits::{Environment, InEnvironment, ProjectionPredicate}; +pub(crate) use traits::{Environment, InEnvironment, Obligation, ProjectionPredicate}; /// A type constructor or type name: this might be something like the primitive /// type `bool`, a struct like `Vec`, or things like function pointers or diff --git a/crates/ra_hir/src/ty/autoderef.rs b/crates/ra_hir/src/ty/autoderef.rs index 214aa7d03..c26513871 100644 --- a/crates/ra_hir/src/ty/autoderef.rs +++ b/crates/ra_hir/src/ty/autoderef.rs @@ -62,11 +62,13 @@ fn deref_by_trait( }, }; - let in_env = super::traits::InEnvironment { value: projection, environment: env }; + let obligation = super::Obligation::Projection(projection); + + let in_env = super::traits::InEnvironment { value: obligation, environment: env }; let canonical = super::Canonical { num_vars: 1 + ty.num_vars, value: in_env }; - let solution = db.normalize(krate, canonical)?; + let solution = db.solve(krate, canonical)?; match &solution { Solution::Unique(vars) => { diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs index f6cf61ad2..1f74108a4 100644 --- a/crates/ra_hir/src/ty/infer.rs +++ b/crates/ra_hir/src/ty/infer.rs @@ -331,53 +331,25 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { fn resolve_obligations_as_possible(&mut self) { let obligations = mem::replace(&mut self.obligations, Vec::new()); for obligation in obligations { - match &obligation { - Obligation::Trait(tr) => { - let in_env = InEnvironment::new(self.trait_env.clone(), tr.clone()); - let canonicalized = self.canonicalizer().canonicalize_trait_ref(in_env); - let solution = self - .db - .implements(self.resolver.krate().unwrap(), canonicalized.value.clone()); - match solution { - Some(Solution::Unique(substs)) => { - canonicalized.apply_solution(self, substs.0); - } - Some(Solution::Ambig(Guidance::Definite(substs))) => { - canonicalized.apply_solution(self, substs.0); - self.obligations.push(obligation); - } - Some(_) => { - // FIXME use this when trying to resolve everything at the end - self.obligations.push(obligation); - } - None => { - // FIXME obligation cannot be fulfilled => diagnostic - } - }; + let in_env = InEnvironment::new(self.trait_env.clone(), obligation.clone()); + let canonicalized = self.canonicalizer().canonicalize_obligation(in_env); + let solution = + self.db.solve(self.resolver.krate().unwrap(), canonicalized.value.clone()); + + match solution { + Some(Solution::Unique(substs)) => { + canonicalized.apply_solution(self, substs.0); } - Obligation::Projection(pr) => { - let in_env = InEnvironment::new(self.trait_env.clone(), pr.clone()); - let canonicalized = self.canonicalizer().canonicalize_projection(in_env); - let solution = self - .db - .normalize(self.resolver.krate().unwrap(), canonicalized.value.clone()); - - match solution { - Some(Solution::Unique(substs)) => { - canonicalized.apply_solution(self, substs.0); - } - Some(Solution::Ambig(Guidance::Definite(substs))) => { - canonicalized.apply_solution(self, substs.0); - self.obligations.push(obligation); - } - Some(_) => { - // FIXME use this when trying to resolve everything at the end - self.obligations.push(obligation); - } - None => { - // FIXME obligation cannot be fulfilled => diagnostic - } - }; + Some(Solution::Ambig(Guidance::Definite(substs))) => { + canonicalized.apply_solution(self, substs.0); + self.obligations.push(obligation); + } + Some(_) => { + // FIXME use this when trying to resolve everything at the end + self.obligations.push(obligation); + } + None => { + // FIXME obligation cannot be fulfilled => diagnostic } }; } diff --git a/crates/ra_hir/src/ty/infer/unify.rs b/crates/ra_hir/src/ty/infer/unify.rs index 2ed326cd5..e7e8825d1 100644 --- a/crates/ra_hir/src/ty/infer/unify.rs +++ b/crates/ra_hir/src/ty/infer/unify.rs @@ -1,6 +1,6 @@ //! Unification and canonicalization logic. -use super::InferenceContext; +use super::{InferenceContext, Obligation}; use crate::db::HirDatabase; use crate::ty::{ Canonical, InEnvironment, InferTy, ProjectionPredicate, ProjectionTy, TraitRef, Ty, @@ -110,32 +110,24 @@ where // FIXME: add some point, we need to introduce a `Fold` trait that abstracts // over all the things that can be canonicalized (like Chalk and rustc have) - pub fn canonicalize_ty(mut self, ty: Ty) -> Canonicalized { + pub(crate) fn canonicalize_ty(mut self, ty: Ty) -> Canonicalized { let result = self.do_canonicalize_ty(ty); self.into_canonicalized(result) } - pub fn canonicalize_trait_ref( + pub(crate) fn canonicalize_obligation( mut self, - trait_ref_in_env: InEnvironment, - ) -> Canonicalized> { - let result = self.do_canonicalize_trait_ref(trait_ref_in_env.value); - // FIXME canonicalize env - self.into_canonicalized(InEnvironment { - value: result, - environment: trait_ref_in_env.environment, - }) - } - - pub fn canonicalize_projection( - mut self, - projection: InEnvironment, - ) -> Canonicalized> { - let result = self.do_canonicalize_projection_predicate(projection.value); - // FIXME canonicalize env + obligation: InEnvironment, + ) -> Canonicalized> { + let result = match obligation.value { + Obligation::Trait(tr) => Obligation::Trait(self.do_canonicalize_trait_ref(tr)), + Obligation::Projection(pr) => { + Obligation::Projection(self.do_canonicalize_projection_predicate(pr)) + } + }; self.into_canonicalized(InEnvironment { value: result, - environment: projection.environment, + environment: obligation.environment, }) } } diff --git a/crates/ra_hir/src/ty/method_resolution.rs b/crates/ra_hir/src/ty/method_resolution.rs index 40f5eabf0..e214bf1af 100644 --- a/crates/ra_hir/src/ty/method_resolution.rs +++ b/crates/ra_hir/src/ty/method_resolution.rs @@ -211,8 +211,8 @@ fn iterate_trait_method_candidates( let data = m.data(db); if name.map_or(true, |name| data.name() == name) && data.has_self_param() { if !known_implemented { - let trait_ref = canonical_trait_ref(db, env.clone(), t, ty.clone()); - if db.implements(krate, trait_ref).is_none() { + let goal = generic_implements_goal(db, env.clone(), t, ty.clone()); + if db.solve(krate, goal).is_none() { continue 'traits; } } @@ -279,12 +279,12 @@ impl Ty { /// This creates Substs for a trait with the given Self type and type variables /// for all other parameters, to query Chalk with it. -fn canonical_trait_ref( +fn generic_implements_goal( db: &impl HirDatabase, env: Arc, trait_: Trait, self_ty: Canonical, -) -> Canonical> { +) -> Canonical> { let mut substs = Vec::new(); let generics = trait_.generic_params(db); let num_vars = self_ty.num_vars; @@ -297,8 +297,8 @@ fn canonical_trait_ref( .enumerate() .map(|(i, _p)| Ty::Bound((i + num_vars) as u32)), ); - Canonical { - num_vars: substs.len() - 1 + self_ty.num_vars, - value: InEnvironment::new(env, TraitRef { trait_, substs: substs.into() }), - } + let num_vars = substs.len() - 1 + self_ty.num_vars; + let trait_ref = TraitRef { trait_, substs: substs.into() }; + let obligation = super::Obligation::Trait(trait_ref); + Canonical { num_vars, value: InEnvironment::new(env, obligation) } } diff --git a/crates/ra_hir/src/ty/traits.rs b/crates/ra_hir/src/ty/traits.rs index 01f350bc1..d99843319 100644 --- a/crates/ra_hir/src/ty/traits.rs +++ b/crates/ra_hir/src/ty/traits.rs @@ -93,7 +93,7 @@ impl InEnvironment { /// Something that needs to be proven (by Chalk) during type checking, e.g. that /// a certain type implements a certain trait. Proving the Obligation might /// result in additional information about inference variables. -#[derive(Clone, Debug, PartialEq, Eq)] +#[derive(Clone, Debug, PartialEq, Eq, Hash)] pub enum Obligation { /// Prove that a certain type implements a trait (the type is the `Self` type /// parameter to the `TraitRef`). @@ -116,11 +116,11 @@ pub struct ProjectionPredicate { pub ty: Ty, } -/// Check using Chalk whether trait is implemented for given parameters including `Self` type. -pub(crate) fn implements_query( +/// Solve a trait goal using Chalk. +pub(crate) fn solve_query( db: &impl HirDatabase, krate: Crate, - trait_ref: Canonical>, + trait_ref: Canonical>, ) -> Option { let _p = profile("implements_query"); let canonical = trait_ref.to_chalk(db).cast(); @@ -131,19 +131,6 @@ pub(crate) fn implements_query( solution.map(|solution| solution_from_chalk(db, solution)) } -pub(crate) fn normalize_query( - db: &impl HirDatabase, - krate: Crate, - projection: Canonical>, -) -> Option { - let canonical = projection.to_chalk(db).cast(); - // We currently don't deal with universes (I think / hope they're not yet - // relevant for our use cases?) - let u_canonical = chalk_ir::UCanonical { canonical, universes: 1 }; - let solution = solve(db, krate, &u_canonical); - solution.map(|solution| solution_from_chalk(db, solution)) -} - fn solution_from_chalk(db: &impl HirDatabase, solution: chalk_solve::Solution) -> Solution { let convert_subst = |subst: chalk_ir::Canonical| { let value = subst diff --git a/crates/ra_hir/src/ty/traits/chalk.rs b/crates/ra_hir/src/ty/traits/chalk.rs index 32a45731d..2df4dd13f 100644 --- a/crates/ra_hir/src/ty/traits/chalk.rs +++ b/crates/ra_hir/src/ty/traits/chalk.rs @@ -12,7 +12,7 @@ use chalk_rust_ir::{AssociatedTyDatum, ImplDatum, StructDatum, TraitDatum}; use ra_db::salsa::{InternId, InternKey}; use test_utils::tested_by; -use super::{Canonical, ChalkContext}; +use super::{Canonical, ChalkContext, Obligation}; use crate::{ db::HirDatabase, generics::GenericDef, @@ -233,6 +233,21 @@ impl ToChalk for super::ProjectionPredicate { } } +impl ToChalk for Obligation { + type Chalk = chalk_ir::DomainGoal; + + fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::DomainGoal { + match self { + Obligation::Trait(tr) => tr.to_chalk(db).cast(), + Obligation::Projection(pr) => pr.to_chalk(db).cast(), + } + } + + fn from_chalk(_db: &impl HirDatabase, _goal: chalk_ir::DomainGoal) -> Self { + unimplemented!() + } +} + impl ToChalk for Canonical where T: ToChalk, diff --git a/crates/ra_ide_api/src/change.rs b/crates/ra_ide_api/src/change.rs index 2a1af0a0a..efc9a92de 100644 --- a/crates/ra_ide_api/src/change.rs +++ b/crates/ra_ide_api/src/change.rs @@ -295,8 +295,7 @@ impl RootDatabase { hir::db::TraitDatumQuery hir::db::StructDatumQuery hir::db::ImplDatumQuery - hir::db::ImplementsQuery - hir::db::NormalizeQuery + hir::db::SolveQuery ]; acc.sort_by_key(|it| std::cmp::Reverse(it.1)); acc -- cgit v1.2.3