mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Unify normalize and implements to simplify code

Browse Source
This commit is contained in:
Florian Diebold 2019-07-08 21:43:52 +02:00
parent 15862fc041
commit 9afbf2dff4
9 changed files with 67 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
crates/ra_hir/src/db.rs
View File

@ -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<chalk_rust_ir::ImplDatum>;
#[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<crate::ty::InEnvironment<crate::ty::TraitRef>>,
) -> Option<crate::ty::traits::Solution>;
#[salsa::invoke(crate::ty::traits::normalize_query)]
fn normalize(
&self,
krate: Crate,
goal: crate::ty::Canonical<crate::ty::InEnvironment<crate::ty::ProjectionPredicate>>,
goal: crate::ty::Canonical<crate::ty::InEnvironment<crate::ty::Obligation>>,
) -> Option<crate::ty::traits::Solution>;
}

2
crates/ra_hir/src/ty.rs
View File

@ -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

6
crates/ra_hir/src/ty/autoderef.rs
View File

@ -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) => {

64
crates/ra_hir/src/ty/infer.rs
View File

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

32
crates/ra_hir/src/ty/infer/unify.rs
View File

@ -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<Ty> {
pub(crate) fn canonicalize_ty(mut self, ty: Ty) -> Canonicalized<Ty> {
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<TraitRef>,
) -> Canonicalized<InEnvironment<TraitRef>> {
let result = self.do_canonicalize_trait_ref(trait_ref_in_env.value);
// FIXME canonicalize env
obligation: InEnvironment<Obligation>,
) -> Canonicalized<InEnvironment<Obligation>> {
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: trait_ref_in_env.environment,
})
}
pub fn canonicalize_projection(
mut self,
projection: InEnvironment<ProjectionPredicate>,
) -> Canonicalized<InEnvironment<ProjectionPredicate>> {
let result = self.do_canonicalize_projection_predicate(projection.value);
// FIXME canonicalize env
self.into_canonicalized(InEnvironment {
value: result,
environment: projection.environment,
environment: obligation.environment,
})
}
}

16
crates/ra_hir/src/ty/method_resolution.rs
View File

@ -211,8 +211,8 @@ fn iterate_trait_method_candidates<T>(
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<Environment>,
trait_: Trait,
self_ty: Canonical<Ty>,
) -> Canonical<InEnvironment<TraitRef>> {
) -> Canonical<InEnvironment<super::Obligation>> {
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) }
}

21
crates/ra_hir/src/ty/traits.rs
View File

@ -93,7 +93,7 @@ impl<T> InEnvironment<T> {
/// 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<InEnvironment<TraitRef>>,
trait_ref: Canonical<InEnvironment<Obligation>>,
) -> Option<Solution> {
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<InEnvironment<ProjectionPredicate>>,
) -> Option<Solution> {
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<chalk_ir::Substitution>| {
let value = subst

17
crates/ra_hir/src/ty/traits/chalk.rs
View File

@ -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<T> ToChalk for Canonical<T>
where
T: ToChalk,

3
crates/ra_ide_api/src/change.rs
View File

@ -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