mirror of
https://github.com/rust-lang/rust-analyzer
synced 2024-12-25 20:43:21 +00:00
Merge #3744
3744: Upgrade Chalk r=matklad a=flodiebold Co-authored-by: Florian Diebold <florian.diebold@freiheit.com> Co-authored-by: Florian Diebold <flodiebold@gmail.com>
This commit is contained in:
bors[bot]
GitHub
commit
a93a04fc9e
12 changed files with 306 additions and 157 deletions
35
Cargo.lock
generated
35
Cargo.lock
generated
|
|
@ -114,7 +114,7 @@ checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
|
|||
[[package]]
|
||||
name = "chalk-derive"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/rust-lang/chalk.git?rev=177d71340acc7a7204a33115fc63075d86452179#177d71340acc7a7204a33115fc63075d86452179"
|
||||
source = "git+https://github.com/rust-lang/chalk.git?rev=039fc904a05f8cb3d0c682c9a57a63dda7a35356#039fc904a05f8cb3d0c682c9a57a63dda7a35356"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
|
|
@ -124,7 +124,7 @@ dependencies = [
|
|||
[[package]]
|
||||
name = "chalk-engine"
|
||||
version = "0.9.0"
|
||||
source = "git+https://github.com/rust-lang/chalk.git?rev=177d71340acc7a7204a33115fc63075d86452179#177d71340acc7a7204a33115fc63075d86452179"
|
||||
source = "git+https://github.com/rust-lang/chalk.git?rev=039fc904a05f8cb3d0c682c9a57a63dda7a35356#039fc904a05f8cb3d0c682c9a57a63dda7a35356"
|
||||
dependencies = [
|
||||
"chalk-macros",
|
||||
"rustc-hash",
|
||||
|
|
@ -133,7 +133,7 @@ dependencies = [
|
|||
[[package]]
|
||||
name = "chalk-ir"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/rust-lang/chalk.git?rev=177d71340acc7a7204a33115fc63075d86452179#177d71340acc7a7204a33115fc63075d86452179"
|
||||
source = "git+https://github.com/rust-lang/chalk.git?rev=039fc904a05f8cb3d0c682c9a57a63dda7a35356#039fc904a05f8cb3d0c682c9a57a63dda7a35356"
|
||||
dependencies = [
|
||||
"chalk-derive",
|
||||
"chalk-engine",
|
||||
|
|
@ -143,7 +143,7 @@ dependencies = [
|
|||
[[package]]
|
||||
name = "chalk-macros"
|
||||
version = "0.1.1"
|
||||
source = "git+https://github.com/rust-lang/chalk.git?rev=177d71340acc7a7204a33115fc63075d86452179#177d71340acc7a7204a33115fc63075d86452179"
|
||||
source = "git+https://github.com/rust-lang/chalk.git?rev=039fc904a05f8cb3d0c682c9a57a63dda7a35356#039fc904a05f8cb3d0c682c9a57a63dda7a35356"
|
||||
dependencies = [
|
||||
"lazy_static",
|
||||
]
|
||||
|
|
@ -151,7 +151,7 @@ dependencies = [
|
|||
[[package]]
|
||||
name = "chalk-rust-ir"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/rust-lang/chalk.git?rev=177d71340acc7a7204a33115fc63075d86452179#177d71340acc7a7204a33115fc63075d86452179"
|
||||
source = "git+https://github.com/rust-lang/chalk.git?rev=039fc904a05f8cb3d0c682c9a57a63dda7a35356#039fc904a05f8cb3d0c682c9a57a63dda7a35356"
|
||||
dependencies = [
|
||||
"chalk-derive",
|
||||
"chalk-engine",
|
||||
|
|
@ -162,7 +162,7 @@ dependencies = [
|
|||
[[package]]
|
||||
name = "chalk-solve"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/rust-lang/chalk.git?rev=177d71340acc7a7204a33115fc63075d86452179#177d71340acc7a7204a33115fc63075d86452179"
|
||||
source = "git+https://github.com/rust-lang/chalk.git?rev=039fc904a05f8cb3d0c682c9a57a63dda7a35356#039fc904a05f8cb3d0c682c9a57a63dda7a35356"
|
||||
dependencies = [
|
||||
"chalk-derive",
|
||||
"chalk-engine",
|
||||
|
|
@ -170,7 +170,7 @@ dependencies = [
|
|||
"chalk-macros",
|
||||
"chalk-rust-ir",
|
||||
"ena",
|
||||
"itertools 0.8.2",
|
||||
"itertools",
|
||||
"petgraph",
|
||||
"rustc-hash",
|
||||
]
|
||||
|
|
@ -505,15 +505,6 @@ dependencies = [
|
|||
"libc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "itertools"
|
||||
version = "0.8.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f56a2d0bc861f9165be4eb3442afd3c236d8a98afd426f65d92324ae1091a484"
|
||||
dependencies = [
|
||||
"either",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "itertools"
|
||||
version = "0.9.0"
|
||||
|
|
@ -873,7 +864,7 @@ name = "ra_assists"
|
|||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"either",
|
||||
"itertools 0.9.0",
|
||||
"itertools",
|
||||
"ra_db",
|
||||
"ra_fmt",
|
||||
"ra_hir",
|
||||
|
|
@ -927,7 +918,7 @@ dependencies = [
|
|||
name = "ra_fmt"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"itertools 0.9.0",
|
||||
"itertools",
|
||||
"ra_syntax",
|
||||
]
|
||||
|
||||
|
|
@ -937,7 +928,7 @@ version = "0.1.0"
|
|||
dependencies = [
|
||||
"arrayvec",
|
||||
"either",
|
||||
"itertools 0.9.0",
|
||||
"itertools",
|
||||
"log",
|
||||
"ra_db",
|
||||
"ra_hir_def",
|
||||
|
|
@ -1015,7 +1006,7 @@ dependencies = [
|
|||
"either",
|
||||
"indexmap",
|
||||
"insta",
|
||||
"itertools 0.9.0",
|
||||
"itertools",
|
||||
"log",
|
||||
"ra_assists",
|
||||
"ra_cfg",
|
||||
|
|
@ -1127,7 +1118,7 @@ name = "ra_syntax"
|
|||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"arrayvec",
|
||||
"itertools 0.9.0",
|
||||
"itertools",
|
||||
"once_cell",
|
||||
"ra_parser",
|
||||
"ra_text_edit",
|
||||
|
|
@ -1305,7 +1296,7 @@ dependencies = [
|
|||
"crossbeam-channel",
|
||||
"env_logger",
|
||||
"globset",
|
||||
"itertools 0.9.0",
|
||||
"itertools",
|
||||
"jod-thread",
|
||||
"log",
|
||||
"lsp-server",
|
||||
|
|
|
|||
|
|
@ -23,9 +23,9 @@ ra_prof = { path = "../ra_prof" }
|
|||
ra_syntax = { path = "../ra_syntax" }
|
||||
test_utils = { path = "../test_utils" }
|
||||
|
||||
chalk-solve = { git = "https://github.com/rust-lang/chalk.git", rev = "177d71340acc7a7204a33115fc63075d86452179" }
|
||||
chalk-rust-ir = { git = "https://github.com/rust-lang/chalk.git", rev = "177d71340acc7a7204a33115fc63075d86452179" }
|
||||
chalk-ir = { git = "https://github.com/rust-lang/chalk.git", rev = "177d71340acc7a7204a33115fc63075d86452179" }
|
||||
chalk-solve = { git = "https://github.com/rust-lang/chalk.git", rev = "039fc904a05f8cb3d0c682c9a57a63dda7a35356" }
|
||||
chalk-rust-ir = { git = "https://github.com/rust-lang/chalk.git", rev = "039fc904a05f8cb3d0c682c9a57a63dda7a35356" }
|
||||
chalk-ir = { git = "https://github.com/rust-lang/chalk.git", rev = "039fc904a05f8cb3d0c682c9a57a63dda7a35356" }
|
||||
|
||||
[dev-dependencies]
|
||||
insta = "0.15.0"
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@ use crate::{
|
|||
db::HirDatabase,
|
||||
traits::{InEnvironment, Solution},
|
||||
utils::generics,
|
||||
Canonical, Substs, Ty, TypeWalk,
|
||||
BoundVar, Canonical, DebruijnIndex, Substs, Ty,
|
||||
};
|
||||
|
||||
const AUTODEREF_RECURSION_LIMIT: usize = 10;
|
||||
|
|
@ -61,14 +61,13 @@ fn deref_by_trait(
|
|||
return None;
|
||||
}
|
||||
|
||||
// FIXME make the Canonical handling nicer
|
||||
// FIXME make the Canonical / bound var handling nicer
|
||||
|
||||
let parameters = Substs::build_for_generics(&generic_params)
|
||||
.push(ty.value.value.clone().shift_bound_vars(1))
|
||||
.build();
|
||||
let parameters =
|
||||
Substs::build_for_generics(&generic_params).push(ty.value.value.clone()).build();
|
||||
|
||||
let projection = super::traits::ProjectionPredicate {
|
||||
ty: Ty::Bound(0),
|
||||
ty: Ty::Bound(BoundVar::new(DebruijnIndex::INNERMOST, ty.value.num_vars)),
|
||||
projection_ty: super::ProjectionTy { associated_ty: target, parameters },
|
||||
};
|
||||
|
||||
|
|
@ -93,12 +92,16 @@ fn deref_by_trait(
|
|||
// we have `impl<T> Deref for Foo<T> { Target = T }`, that should be
|
||||
// the case.
|
||||
for i in 1..vars.0.num_vars {
|
||||
if vars.0.value[i] != Ty::Bound((i - 1) as u32) {
|
||||
if vars.0.value[i - 1] != Ty::Bound(BoundVar::new(DebruijnIndex::INNERMOST, i - 1))
|
||||
{
|
||||
warn!("complex solution for derefing {:?}: {:?}, ignoring", ty.value, solution);
|
||||
return None;
|
||||
}
|
||||
}
|
||||
Some(Canonical { value: vars.0.value[0].clone(), num_vars: vars.0.num_vars })
|
||||
Some(Canonical {
|
||||
value: vars.0.value[vars.0.value.len() - 1].clone(),
|
||||
num_vars: vars.0.num_vars,
|
||||
})
|
||||
}
|
||||
Solution::Ambig(_) => {
|
||||
info!("Ambiguous solution for derefing {:?}: {:?}", ty.value, solution);
|
||||
|
|
|
|||
|
|
@ -311,7 +311,7 @@ impl HirDisplay for Ty {
|
|||
}
|
||||
}
|
||||
}
|
||||
Ty::Bound(idx) => write!(f, "?{}", idx)?,
|
||||
Ty::Bound(idx) => write!(f, "?{}.{}", idx.debruijn.depth(), idx.index)?,
|
||||
Ty::Dyn(predicates) | Ty::Opaque(predicates) => {
|
||||
match self {
|
||||
Ty::Dyn(_) => write!(f, "dyn ")?,
|
||||
|
|
|
|||
|
|
@ -7,7 +7,9 @@ use ena::unify::{InPlaceUnificationTable, NoError, UnifyKey, UnifyValue};
|
|||
use test_utils::tested_by;
|
||||
|
||||
use super::{InferenceContext, Obligation};
|
||||
use crate::{Canonical, InEnvironment, InferTy, Substs, Ty, TypeCtor, TypeWalk};
|
||||
use crate::{
|
||||
BoundVar, Canonical, DebruijnIndex, InEnvironment, InferTy, Substs, Ty, TypeCtor, TypeWalk,
|
||||
};
|
||||
|
||||
impl<'a> InferenceContext<'a> {
|
||||
pub(super) fn canonicalizer<'b>(&'b mut self) -> Canonicalizer<'a, 'b>
|
||||
|
|
@ -47,7 +49,7 @@ where
|
|||
})
|
||||
}
|
||||
|
||||
fn do_canonicalize<T: TypeWalk>(&mut self, t: T, binders: usize) -> T {
|
||||
fn do_canonicalize<T: TypeWalk>(&mut self, t: T, binders: DebruijnIndex) -> T {
|
||||
t.fold_binders(
|
||||
&mut |ty, binders| match ty {
|
||||
Ty::Infer(tv) => {
|
||||
|
|
@ -72,7 +74,7 @@ where
|
|||
InferTy::MaybeNeverTypeVar(_) => InferTy::MaybeNeverTypeVar(root),
|
||||
};
|
||||
let position = self.add(free_var);
|
||||
Ty::Bound((position + binders) as u32)
|
||||
Ty::Bound(BoundVar::new(binders, position))
|
||||
}
|
||||
}
|
||||
_ => ty,
|
||||
|
|
@ -89,7 +91,7 @@ where
|
|||
}
|
||||
|
||||
pub(crate) fn canonicalize_ty(mut self, ty: Ty) -> Canonicalized<Ty> {
|
||||
let result = self.do_canonicalize(ty, 0);
|
||||
let result = self.do_canonicalize(ty, DebruijnIndex::INNERMOST);
|
||||
self.into_canonicalized(result)
|
||||
}
|
||||
|
||||
|
|
@ -98,8 +100,12 @@ where
|
|||
obligation: InEnvironment<Obligation>,
|
||||
) -> Canonicalized<InEnvironment<Obligation>> {
|
||||
let result = match obligation.value {
|
||||
Obligation::Trait(tr) => Obligation::Trait(self.do_canonicalize(tr, 0)),
|
||||
Obligation::Projection(pr) => Obligation::Projection(self.do_canonicalize(pr, 0)),
|
||||
Obligation::Trait(tr) => {
|
||||
Obligation::Trait(self.do_canonicalize(tr, DebruijnIndex::INNERMOST))
|
||||
}
|
||||
Obligation::Projection(pr) => {
|
||||
Obligation::Projection(self.do_canonicalize(pr, DebruijnIndex::INNERMOST))
|
||||
}
|
||||
};
|
||||
self.into_canonicalized(InEnvironment {
|
||||
value: result,
|
||||
|
|
@ -112,13 +118,13 @@ impl<T> Canonicalized<T> {
|
|||
pub fn decanonicalize_ty(&self, mut ty: Ty) -> Ty {
|
||||
ty.walk_mut_binders(
|
||||
&mut |ty, binders| {
|
||||
if let &mut Ty::Bound(idx) = ty {
|
||||
if idx as usize >= binders && (idx as usize - binders) < self.free_vars.len() {
|
||||
*ty = Ty::Infer(self.free_vars[idx as usize - binders]);
|
||||
if let &mut Ty::Bound(bound) = ty {
|
||||
if bound.debruijn >= binders {
|
||||
*ty = Ty::Infer(self.free_vars[bound.index]);
|
||||
}
|
||||
}
|
||||
},
|
||||
0,
|
||||
DebruijnIndex::INNERMOST,
|
||||
);
|
||||
ty
|
||||
}
|
||||
|
|
@ -150,7 +156,7 @@ pub fn unify(ty1: &Canonical<Ty>, ty2: &Canonical<Ty>) -> Option<Substs> {
|
|||
// (kind of hacky)
|
||||
for (i, var) in vars.iter().enumerate() {
|
||||
if &*table.resolve_ty_shallow(var) == var {
|
||||
table.unify(var, &Ty::Bound(i as u32));
|
||||
table.unify(var, &Ty::Bound(BoundVar::new(DebruijnIndex::INNERMOST, i)));
|
||||
}
|
||||
}
|
||||
Some(
|
||||
|
|
|
|||
|
|
@ -64,6 +64,8 @@ pub use lower::{
|
|||
};
|
||||
pub use traits::{InEnvironment, Obligation, ProjectionPredicate, TraitEnvironment};
|
||||
|
||||
pub use chalk_ir::{BoundVar, DebruijnIndex};
|
||||
|
||||
/// 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
|
||||
/// tuples.
|
||||
|
|
@ -265,7 +267,11 @@ impl TypeWalk for ProjectionTy {
|
|||
self.parameters.walk(f);
|
||||
}
|
||||
|
||||
fn walk_mut_binders(&mut self, f: &mut impl FnMut(&mut Ty, usize), binders: usize) {
|
||||
fn walk_mut_binders(
|
||||
&mut self,
|
||||
f: &mut impl FnMut(&mut Ty, DebruijnIndex),
|
||||
binders: DebruijnIndex,
|
||||
) {
|
||||
self.parameters.walk_mut_binders(f, binders);
|
||||
}
|
||||
}
|
||||
|
|
@ -299,7 +305,7 @@ pub enum Ty {
|
|||
/// parameters get turned into variables; during trait resolution, inference
|
||||
/// variables get turned into bound variables and back; and in `Dyn` the
|
||||
/// `Self` type is represented with a bound variable as well.
|
||||
Bound(u32),
|
||||
Bound(BoundVar),
|
||||
|
||||
/// A type variable used during type checking.
|
||||
Infer(InferTy),
|
||||
|
|
@ -337,7 +343,11 @@ impl TypeWalk for Substs {
|
|||
}
|
||||
}
|
||||
|
||||
fn walk_mut_binders(&mut self, f: &mut impl FnMut(&mut Ty, usize), binders: usize) {
|
||||
fn walk_mut_binders(
|
||||
&mut self,
|
||||
f: &mut impl FnMut(&mut Ty, DebruijnIndex),
|
||||
binders: DebruijnIndex,
|
||||
) {
|
||||
for t in make_mut_slice(&mut self.0) {
|
||||
t.walk_mut_binders(f, binders);
|
||||
}
|
||||
|
|
@ -381,7 +391,13 @@ impl Substs {
|
|||
|
||||
/// Return Substs that replace each parameter by a bound variable.
|
||||
pub(crate) fn bound_vars(generic_params: &Generics) -> Substs {
|
||||
Substs(generic_params.iter().enumerate().map(|(idx, _)| Ty::Bound(idx as u32)).collect())
|
||||
Substs(
|
||||
generic_params
|
||||
.iter()
|
||||
.enumerate()
|
||||
.map(|(idx, _)| Ty::Bound(BoundVar::new(DebruijnIndex::INNERMOST, idx)))
|
||||
.collect(),
|
||||
)
|
||||
}
|
||||
|
||||
pub fn build_for_def(db: &dyn HirDatabase, def: impl Into<GenericDefId>) -> SubstsBuilder {
|
||||
|
|
@ -425,8 +441,8 @@ impl SubstsBuilder {
|
|||
self.param_count - self.vec.len()
|
||||
}
|
||||
|
||||
pub fn fill_with_bound_vars(self, starting_from: u32) -> Self {
|
||||
self.fill((starting_from..).map(Ty::Bound))
|
||||
pub fn fill_with_bound_vars(self, debruijn: DebruijnIndex, starting_from: usize) -> Self {
|
||||
self.fill((starting_from..).map(|idx| Ty::Bound(BoundVar::new(debruijn, idx))))
|
||||
}
|
||||
|
||||
pub fn fill_with_unknown(self) -> Self {
|
||||
|
|
@ -507,7 +523,11 @@ impl TypeWalk for TraitRef {
|
|||
self.substs.walk(f);
|
||||
}
|
||||
|
||||
fn walk_mut_binders(&mut self, f: &mut impl FnMut(&mut Ty, usize), binders: usize) {
|
||||
fn walk_mut_binders(
|
||||
&mut self,
|
||||
f: &mut impl FnMut(&mut Ty, DebruijnIndex),
|
||||
binders: DebruijnIndex,
|
||||
) {
|
||||
self.substs.walk_mut_binders(f, binders);
|
||||
}
|
||||
}
|
||||
|
|
@ -558,7 +578,11 @@ impl TypeWalk for GenericPredicate {
|
|||
}
|
||||
}
|
||||
|
||||
fn walk_mut_binders(&mut self, f: &mut impl FnMut(&mut Ty, usize), binders: usize) {
|
||||
fn walk_mut_binders(
|
||||
&mut self,
|
||||
f: &mut impl FnMut(&mut Ty, DebruijnIndex),
|
||||
binders: DebruijnIndex,
|
||||
) {
|
||||
match self {
|
||||
GenericPredicate::Implemented(trait_ref) => trait_ref.walk_mut_binders(f, binders),
|
||||
GenericPredicate::Projection(projection_pred) => {
|
||||
|
|
@ -616,7 +640,11 @@ impl TypeWalk for FnSig {
|
|||
}
|
||||
}
|
||||
|
||||
fn walk_mut_binders(&mut self, f: &mut impl FnMut(&mut Ty, usize), binders: usize) {
|
||||
fn walk_mut_binders(
|
||||
&mut self,
|
||||
f: &mut impl FnMut(&mut Ty, DebruijnIndex),
|
||||
binders: DebruijnIndex,
|
||||
) {
|
||||
for t in make_mut_slice(&mut self.params_and_return) {
|
||||
t.walk_mut_binders(f, binders);
|
||||
}
|
||||
|
|
@ -755,7 +783,7 @@ impl Ty {
|
|||
pub trait TypeWalk {
|
||||
fn walk(&self, f: &mut impl FnMut(&Ty));
|
||||
fn walk_mut(&mut self, f: &mut impl FnMut(&mut Ty)) {
|
||||
self.walk_mut_binders(&mut |ty, _binders| f(ty), 0);
|
||||
self.walk_mut_binders(&mut |ty, _binders| f(ty), DebruijnIndex::INNERMOST);
|
||||
}
|
||||
/// Walk the type, counting entered binders.
|
||||
///
|
||||
|
|
@ -767,9 +795,17 @@ pub trait TypeWalk {
|
|||
/// that. Currently, the only thing that introduces bound variables on our
|
||||
/// side are `Ty::Dyn` and `Ty::Opaque`, which each introduce a bound
|
||||
/// variable for the self type.
|
||||
fn walk_mut_binders(&mut self, f: &mut impl FnMut(&mut Ty, usize), binders: usize);
|
||||
fn walk_mut_binders(
|
||||
&mut self,
|
||||
f: &mut impl FnMut(&mut Ty, DebruijnIndex),
|
||||
binders: DebruijnIndex,
|
||||
);
|
||||
|
||||
fn fold_binders(mut self, f: &mut impl FnMut(Ty, usize) -> Ty, binders: usize) -> Self
|
||||
fn fold_binders(
|
||||
mut self,
|
||||
f: &mut impl FnMut(Ty, DebruijnIndex) -> Ty,
|
||||
binders: DebruijnIndex,
|
||||
) -> Self
|
||||
where
|
||||
Self: Sized,
|
||||
{
|
||||
|
|
@ -795,40 +831,43 @@ pub trait TypeWalk {
|
|||
}
|
||||
|
||||
/// Substitutes `Ty::Bound` vars with the given substitution.
|
||||
fn subst_bound_vars(mut self, substs: &Substs) -> Self
|
||||
fn subst_bound_vars(self, substs: &Substs) -> Self
|
||||
where
|
||||
Self: Sized,
|
||||
{
|
||||
self.subst_bound_vars_at_depth(substs, DebruijnIndex::INNERMOST)
|
||||
}
|
||||
|
||||
/// Substitutes `Ty::Bound` vars with the given substitution.
|
||||
fn subst_bound_vars_at_depth(mut self, substs: &Substs, depth: DebruijnIndex) -> Self
|
||||
where
|
||||
Self: Sized,
|
||||
{
|
||||
self.walk_mut_binders(
|
||||
&mut |ty, binders| {
|
||||
if let &mut Ty::Bound(idx) = ty {
|
||||
if idx as usize >= binders && (idx as usize - binders) < substs.len() {
|
||||
*ty = substs.0[idx as usize - binders].clone();
|
||||
} else if idx as usize >= binders + substs.len() {
|
||||
// shift free binders
|
||||
*ty = Ty::Bound(idx - substs.len() as u32);
|
||||
if let &mut Ty::Bound(bound) = ty {
|
||||
if bound.debruijn >= binders {
|
||||
*ty = substs.0[bound.index].clone();
|
||||
}
|
||||
}
|
||||
},
|
||||
0,
|
||||
depth,
|
||||
);
|
||||
self
|
||||
}
|
||||
|
||||
/// Shifts up `Ty::Bound` vars by `n`.
|
||||
fn shift_bound_vars(self, n: i32) -> Self
|
||||
// /// Shifts up debruijn indices of `Ty::Bound` vars by `n`.
|
||||
fn shift_bound_vars(self, n: DebruijnIndex) -> Self
|
||||
where
|
||||
Self: Sized,
|
||||
{
|
||||
self.fold_binders(
|
||||
&mut |ty, binders| match ty {
|
||||
Ty::Bound(idx) if idx as usize >= binders => {
|
||||
assert!(idx as i32 >= -n);
|
||||
Ty::Bound((idx as i32 + n) as u32)
|
||||
Ty::Bound(bound) if bound.debruijn >= binders => {
|
||||
Ty::Bound(bound.shifted_in_from(n))
|
||||
}
|
||||
ty => ty,
|
||||
},
|
||||
0,
|
||||
DebruijnIndex::INNERMOST,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
|
@ -856,7 +895,11 @@ impl TypeWalk for Ty {
|
|||
f(self);
|
||||
}
|
||||
|
||||
fn walk_mut_binders(&mut self, f: &mut impl FnMut(&mut Ty, usize), binders: usize) {
|
||||
fn walk_mut_binders(
|
||||
&mut self,
|
||||
f: &mut impl FnMut(&mut Ty, DebruijnIndex),
|
||||
binders: DebruijnIndex,
|
||||
) {
|
||||
match self {
|
||||
Ty::Apply(a_ty) => {
|
||||
a_ty.parameters.walk_mut_binders(f, binders);
|
||||
|
|
@ -866,7 +909,7 @@ impl TypeWalk for Ty {
|
|||
}
|
||||
Ty::Dyn(predicates) | Ty::Opaque(predicates) => {
|
||||
for p in make_mut_slice(predicates) {
|
||||
p.walk_mut_binders(f, binders + 1);
|
||||
p.walk_mut_binders(f, binders.shifted_in());
|
||||
}
|
||||
}
|
||||
Ty::Placeholder { .. } | Ty::Bound(_) | Ty::Infer(_) | Ty::Unknown => {}
|
||||
|
|
|
|||
|
|
@ -29,8 +29,8 @@ use crate::{
|
|||
all_super_traits, associated_type_by_name_including_super_traits, generics, make_mut_slice,
|
||||
variant_data,
|
||||
},
|
||||
Binders, FnSig, GenericPredicate, PolyFnSig, ProjectionPredicate, ProjectionTy, Substs,
|
||||
TraitEnvironment, TraitRef, Ty, TypeCtor,
|
||||
Binders, BoundVar, DebruijnIndex, FnSig, GenericPredicate, PolyFnSig, ProjectionPredicate,
|
||||
ProjectionTy, Substs, TraitEnvironment, TraitRef, Ty, TypeCtor,
|
||||
};
|
||||
|
||||
#[derive(Debug)]
|
||||
|
|
@ -131,7 +131,7 @@ impl Ty {
|
|||
Ty::apply(TypeCtor::FnPtr { num_args: sig.len() as u16 - 1 }, sig)
|
||||
}
|
||||
TypeRef::DynTrait(bounds) => {
|
||||
let self_ty = Ty::Bound(0);
|
||||
let self_ty = Ty::Bound(BoundVar::new(DebruijnIndex::INNERMOST, 0));
|
||||
let predicates = bounds
|
||||
.iter()
|
||||
.flat_map(|b| GenericPredicate::from_type_bound(ctx, b, self_ty.clone()))
|
||||
|
|
@ -141,7 +141,7 @@ impl Ty {
|
|||
TypeRef::ImplTrait(bounds) => {
|
||||
match ctx.impl_trait_mode {
|
||||
ImplTraitLoweringMode::Opaque => {
|
||||
let self_ty = Ty::Bound(0);
|
||||
let self_ty = Ty::Bound(BoundVar::new(DebruijnIndex::INNERMOST, 0));
|
||||
let predicates = bounds
|
||||
.iter()
|
||||
.flat_map(|b| {
|
||||
|
|
@ -177,12 +177,10 @@ impl Ty {
|
|||
} else {
|
||||
(0, 0, 0, 0)
|
||||
};
|
||||
Ty::Bound(
|
||||
idx as u32
|
||||
+ parent_params as u32
|
||||
+ self_params as u32
|
||||
+ list_params as u32,
|
||||
)
|
||||
Ty::Bound(BoundVar::new(
|
||||
DebruijnIndex::INNERMOST,
|
||||
idx as usize + parent_params + self_params + list_params,
|
||||
))
|
||||
}
|
||||
ImplTraitLoweringMode::Disallowed => {
|
||||
// FIXME: report error
|
||||
|
|
@ -249,7 +247,11 @@ impl Ty {
|
|||
let ty = match resolution {
|
||||
TypeNs::TraitId(trait_) => {
|
||||
// if this is a bare dyn Trait, we'll directly put the required ^0 for the self type in there
|
||||
let self_ty = if remaining_segments.len() == 0 { Some(Ty::Bound(0)) } else { None };
|
||||
let self_ty = if remaining_segments.len() == 0 {
|
||||
Some(Ty::Bound(BoundVar::new(DebruijnIndex::INNERMOST, 0)))
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let trait_ref =
|
||||
TraitRef::from_resolved_path(ctx, trait_, resolved_segment, self_ty);
|
||||
let ty = if remaining_segments.len() == 1 {
|
||||
|
|
@ -289,7 +291,7 @@ impl Ty {
|
|||
TypeParamLoweringMode::Placeholder => Ty::Placeholder(param_id),
|
||||
TypeParamLoweringMode::Variable => {
|
||||
let idx = generics.param_idx(param_id).expect("matching generics");
|
||||
Ty::Bound(idx)
|
||||
Ty::Bound(BoundVar::new(DebruijnIndex::INNERMOST, idx))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -558,7 +560,7 @@ impl GenericPredicate {
|
|||
TypeParamLoweringMode::Placeholder => Ty::Placeholder(param_id),
|
||||
TypeParamLoweringMode::Variable => {
|
||||
let idx = generics.param_idx(param_id).expect("matching generics");
|
||||
Ty::Bound(idx)
|
||||
Ty::Bound(BoundVar::new(DebruijnIndex::INNERMOST, idx))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -20,7 +20,8 @@ use crate::{
|
|||
db::HirDatabase,
|
||||
primitive::{FloatBitness, Uncertain},
|
||||
utils::all_super_traits,
|
||||
ApplicationTy, Canonical, InEnvironment, TraitEnvironment, TraitRef, Ty, TypeCtor, TypeWalk,
|
||||
ApplicationTy, Canonical, DebruijnIndex, InEnvironment, TraitEnvironment, TraitRef, Ty,
|
||||
TypeCtor, TypeWalk,
|
||||
};
|
||||
|
||||
/// This is used as a key for indexing impls.
|
||||
|
|
@ -507,8 +508,9 @@ pub(crate) fn inherent_impl_substs(
|
|||
) -> Option<Substs> {
|
||||
// we create a var for each type parameter of the impl; we need to keep in
|
||||
// mind here that `self_ty` might have vars of its own
|
||||
let vars =
|
||||
Substs::build_for_def(db, impl_id).fill_with_bound_vars(self_ty.num_vars as u32).build();
|
||||
let vars = Substs::build_for_def(db, impl_id)
|
||||
.fill_with_bound_vars(DebruijnIndex::INNERMOST, self_ty.num_vars)
|
||||
.build();
|
||||
let self_ty_with_vars = db.impl_self_ty(impl_id).subst(&vars);
|
||||
let self_ty_with_vars =
|
||||
Canonical { num_vars: vars.len() + self_ty.num_vars, value: self_ty_with_vars };
|
||||
|
|
@ -526,8 +528,8 @@ pub(crate) fn inherent_impl_substs(
|
|||
fn fallback_bound_vars(s: Substs, num_vars_to_keep: usize) -> Substs {
|
||||
s.fold_binders(
|
||||
&mut |ty, binders| {
|
||||
if let Ty::Bound(idx) = &ty {
|
||||
if *idx >= binders as u32 {
|
||||
if let Ty::Bound(bound) = &ty {
|
||||
if bound.index >= num_vars_to_keep && bound.debruijn >= binders {
|
||||
Ty::Unknown
|
||||
} else {
|
||||
ty
|
||||
|
|
@ -536,7 +538,7 @@ fn fallback_bound_vars(s: Substs, num_vars_to_keep: usize) -> Substs {
|
|||
ty
|
||||
}
|
||||
},
|
||||
num_vars_to_keep,
|
||||
DebruijnIndex::INNERMOST,
|
||||
)
|
||||
}
|
||||
|
||||
|
|
@ -586,7 +588,7 @@ fn generic_implements_goal(
|
|||
let num_vars = self_ty.num_vars;
|
||||
let substs = super::Substs::build_for_def(db, trait_)
|
||||
.push(self_ty.value)
|
||||
.fill_with_bound_vars(num_vars as u32)
|
||||
.fill_with_bound_vars(DebruijnIndex::INNERMOST, num_vars)
|
||||
.build();
|
||||
let num_vars = substs.len() - 1 + self_ty.num_vars;
|
||||
let trait_ref = TraitRef { trait_, substs };
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ use ra_db::{impl_intern_key, salsa, CrateId};
|
|||
use ra_prof::profile;
|
||||
use rustc_hash::FxHashSet;
|
||||
|
||||
use crate::db::HirDatabase;
|
||||
use crate::{db::HirDatabase, DebruijnIndex};
|
||||
|
||||
use super::{Canonical, GenericPredicate, HirDisplay, ProjectionTy, TraitRef, Ty, TypeWalk};
|
||||
|
||||
|
|
@ -128,7 +128,11 @@ impl TypeWalk for ProjectionPredicate {
|
|||
self.ty.walk(f);
|
||||
}
|
||||
|
||||
fn walk_mut_binders(&mut self, f: &mut impl FnMut(&mut Ty, usize), binders: usize) {
|
||||
fn walk_mut_binders(
|
||||
&mut self,
|
||||
f: &mut impl FnMut(&mut Ty, DebruijnIndex),
|
||||
binders: DebruijnIndex,
|
||||
) {
|
||||
self.projection_ty.walk_mut_binders(f, binders);
|
||||
self.ty.walk_mut_binders(f, binders);
|
||||
}
|
||||
|
|
@ -144,7 +148,7 @@ pub(crate) fn trait_solve_query(
|
|||
Obligation::Trait(it) => db.trait_data(it.trait_).name.to_string(),
|
||||
Obligation::Projection(_) => "projection".to_string(),
|
||||
});
|
||||
log::debug!("trait_solve_query({})", goal.value.value.display(db));
|
||||
eprintln!("trait_solve_query({})", goal.value.value.display(db));
|
||||
|
||||
if let Obligation::Projection(pred) = &goal.value.value {
|
||||
if let Ty::Bound(_) = &pred.projection_ty.parameters[0] {
|
||||
|
|
@ -153,7 +157,7 @@ pub(crate) fn trait_solve_query(
|
|||
}
|
||||
}
|
||||
|
||||
let canonical = goal.to_chalk(db).cast();
|
||||
let canonical = goal.to_chalk(db).cast(&Interner);
|
||||
|
||||
// We currently don't deal with universes (I think / hope they're not yet
|
||||
// relevant for our use cases?)
|
||||
|
|
@ -194,8 +198,8 @@ fn solution_from_chalk(
|
|||
let convert_subst = |subst: chalk_ir::Canonical<chalk_ir::Substitution<Interner>>| {
|
||||
let value = subst
|
||||
.value
|
||||
.into_iter()
|
||||
.map(|p| match p.ty() {
|
||||
.iter(&Interner)
|
||||
.map(|p| match p.ty(&Interner) {
|
||||
Some(ty) => from_chalk(db, ty.clone()),
|
||||
None => unimplemented!(),
|
||||
})
|
||||
|
|
|
|||
|
|
@ -8,7 +8,8 @@ use super::{AssocTyValue, Impl, UnsizeToSuperTraitObjectData};
|
|||
use crate::{
|
||||
db::HirDatabase,
|
||||
utils::{all_super_traits, generics},
|
||||
ApplicationTy, Binders, GenericPredicate, Substs, TraitRef, Ty, TypeCtor,
|
||||
ApplicationTy, Binders, BoundVar, DebruijnIndex, GenericPredicate, Substs, TraitRef, Ty,
|
||||
TypeCtor, TypeWalk,
|
||||
};
|
||||
|
||||
pub(super) struct BuiltinImplData {
|
||||
|
|
@ -164,11 +165,15 @@ fn closure_fn_trait_impl_datum(
|
|||
|
||||
let arg_ty = Ty::apply(
|
||||
TypeCtor::Tuple { cardinality: num_args },
|
||||
Substs::builder(num_args as usize).fill_with_bound_vars(0).build(),
|
||||
Substs::builder(num_args as usize)
|
||||
.fill_with_bound_vars(DebruijnIndex::INNERMOST, 0)
|
||||
.build(),
|
||||
);
|
||||
let sig_ty = Ty::apply(
|
||||
TypeCtor::FnPtr { num_args },
|
||||
Substs::builder(num_args as usize + 1).fill_with_bound_vars(0).build(),
|
||||
Substs::builder(num_args as usize + 1)
|
||||
.fill_with_bound_vars(DebruijnIndex::INNERMOST, 0)
|
||||
.build(),
|
||||
);
|
||||
|
||||
let self_ty = Ty::apply_one(TypeCtor::Closure { def: data.def, expr: data.expr }, sig_ty);
|
||||
|
|
@ -203,7 +208,7 @@ fn closure_fn_trait_output_assoc_ty_value(
|
|||
}
|
||||
};
|
||||
|
||||
let output_ty = Ty::Bound(num_args.into());
|
||||
let output_ty = Ty::Bound(BoundVar::new(DebruijnIndex::INNERMOST, num_args.into()));
|
||||
|
||||
let fn_once_trait =
|
||||
get_fn_trait(db, krate, super::FnTrait::FnOnce).expect("assoc ty value should not exist");
|
||||
|
|
@ -241,7 +246,7 @@ fn array_unsize_impl_datum(db: &dyn HirDatabase, krate: CrateId) -> BuiltinImplD
|
|||
// the existence of the Unsize trait has been checked before
|
||||
.expect("Unsize trait missing");
|
||||
|
||||
let var = Ty::Bound(0);
|
||||
let var = Ty::Bound(BoundVar::new(DebruijnIndex::INNERMOST, 0));
|
||||
let substs = Substs::builder(2)
|
||||
.push(Ty::apply_one(TypeCtor::Array, var.clone()))
|
||||
.push(Ty::apply_one(TypeCtor::Slice, var))
|
||||
|
|
@ -270,19 +275,18 @@ fn trait_object_unsize_impl_datum(
|
|||
// the existence of the Unsize trait has been checked before
|
||||
.expect("Unsize trait missing");
|
||||
|
||||
let self_ty = Ty::Bound(0);
|
||||
let self_ty = Ty::Bound(BoundVar::new(DebruijnIndex::INNERMOST, 0));
|
||||
|
||||
let target_substs = Substs::build_for_def(db, trait_)
|
||||
.push(Ty::Bound(0))
|
||||
// starting from ^2 because we want to start with ^1 outside of the
|
||||
// `dyn`, which is ^2 inside
|
||||
.fill_with_bound_vars(2)
|
||||
.push(Ty::Bound(BoundVar::new(DebruijnIndex::INNERMOST, 0)))
|
||||
.fill_with_bound_vars(DebruijnIndex::ONE, 1)
|
||||
.build();
|
||||
let num_vars = target_substs.len();
|
||||
let target_trait_ref = TraitRef { trait_, substs: target_substs };
|
||||
let target_bounds = vec![GenericPredicate::Implemented(target_trait_ref)];
|
||||
|
||||
let self_substs = Substs::build_for_def(db, trait_).fill_with_bound_vars(0).build();
|
||||
let self_substs =
|
||||
Substs::build_for_def(db, trait_).fill_with_bound_vars(DebruijnIndex::INNERMOST, 0).build();
|
||||
let self_trait_ref = TraitRef { trait_, substs: self_substs };
|
||||
let where_clauses = vec![GenericPredicate::Implemented(self_trait_ref)];
|
||||
|
||||
|
|
@ -305,24 +309,26 @@ fn super_trait_object_unsize_impl_datum(
|
|||
// the existence of the Unsize trait has been checked before
|
||||
.expect("Unsize trait missing");
|
||||
|
||||
let self_substs = Substs::build_for_def(db, data.trait_).fill_with_bound_vars(0).build();
|
||||
let self_substs = Substs::build_for_def(db, data.trait_)
|
||||
.fill_with_bound_vars(DebruijnIndex::INNERMOST, 0)
|
||||
.build();
|
||||
let self_trait_ref = TraitRef { trait_: data.trait_, substs: self_substs.clone() };
|
||||
|
||||
let num_vars = self_substs.len() - 1;
|
||||
|
||||
let self_trait_ref = TraitRef { trait_: data.trait_, substs: self_substs.clone() };
|
||||
let self_bounds = vec![GenericPredicate::Implemented(self_trait_ref.clone())];
|
||||
|
||||
// we need to go from our trait to the super trait, substituting type parameters
|
||||
let path = crate::utils::find_super_trait_path(db.upcast(), data.trait_, data.super_trait);
|
||||
|
||||
let mut current_trait_ref = self_trait_ref;
|
||||
let mut current_trait_ref = self_trait_ref.clone();
|
||||
for t in path.into_iter().skip(1) {
|
||||
let bounds = db.generic_predicates(current_trait_ref.trait_.into());
|
||||
let super_trait_ref = bounds
|
||||
.iter()
|
||||
.find_map(|b| match &b.value {
|
||||
GenericPredicate::Implemented(tr)
|
||||
if tr.trait_ == t && tr.substs[0] == Ty::Bound(0) =>
|
||||
if tr.trait_ == t
|
||||
&& tr.substs[0]
|
||||
== Ty::Bound(BoundVar::new(DebruijnIndex::INNERMOST, 0)) =>
|
||||
{
|
||||
Some(Binders { value: tr, num_binders: b.num_binders })
|
||||
}
|
||||
|
|
@ -332,7 +338,18 @@ fn super_trait_object_unsize_impl_datum(
|
|||
current_trait_ref = super_trait_ref.cloned().subst(¤t_trait_ref.substs);
|
||||
}
|
||||
|
||||
let super_bounds = vec![GenericPredicate::Implemented(current_trait_ref)];
|
||||
// We need to renumber the variables a bit now: from ^0.0, ^0.1, ^0.2, ...
|
||||
// to ^0.0, ^1.0, ^1.1. The reason for this is that the first variable comes
|
||||
// from the dyn Trait binder, while the other variables come from the impl.
|
||||
let new_substs = Substs::builder(num_vars + 1)
|
||||
.push(Ty::Bound(BoundVar::new(DebruijnIndex::INNERMOST, 0)))
|
||||
.fill_with_bound_vars(DebruijnIndex::ONE, 0)
|
||||
.build();
|
||||
|
||||
let self_bounds =
|
||||
vec![GenericPredicate::Implemented(self_trait_ref.subst_bound_vars(&new_substs))];
|
||||
let super_bounds =
|
||||
vec![GenericPredicate::Implemented(current_trait_ref.subst_bound_vars(&new_substs))];
|
||||
|
||||
let substs = Substs::builder(2)
|
||||
.push(Ty::Dyn(self_bounds.into()))
|
||||
|
|
|
|||
|
|
@ -3,7 +3,10 @@ use std::{fmt, sync::Arc};
|
|||
|
||||
use log::debug;
|
||||
|
||||
use chalk_ir::{cast::Cast, Goal, GoalData, Parameter, PlaceholderIndex, TypeName, UniverseIndex};
|
||||
use chalk_ir::{
|
||||
cast::Cast, fold::shift::Shift, Goal, GoalData, Parameter, PlaceholderIndex, TypeName,
|
||||
UniverseIndex,
|
||||
};
|
||||
|
||||
use hir_def::{AssocContainerId, AssocItemId, GenericDefId, HasModule, Lookup, TypeAliasId};
|
||||
use ra_db::{
|
||||
|
|
@ -59,53 +62,126 @@ impl chalk_ir::interner::Interner for Interner {
|
|||
None
|
||||
}
|
||||
|
||||
fn debug_ty(_ty: &chalk_ir::Ty<Self>, _fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
|
||||
None
|
||||
}
|
||||
|
||||
fn debug_lifetime(
|
||||
_lifetime: &chalk_ir::Lifetime<Self>,
|
||||
_fmt: &mut fmt::Formatter<'_>,
|
||||
) -> Option<fmt::Result> {
|
||||
None
|
||||
}
|
||||
|
||||
fn debug_parameter(
|
||||
_parameter: &Parameter<Self>,
|
||||
_fmt: &mut fmt::Formatter<'_>,
|
||||
) -> Option<fmt::Result> {
|
||||
None
|
||||
}
|
||||
|
||||
fn debug_goal(_goal: &Goal<Self>, _fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
|
||||
None
|
||||
}
|
||||
|
||||
fn debug_goals(
|
||||
_goals: &chalk_ir::Goals<Self>,
|
||||
_fmt: &mut fmt::Formatter<'_>,
|
||||
) -> Option<fmt::Result> {
|
||||
None
|
||||
}
|
||||
|
||||
fn debug_program_clause_implication(
|
||||
_pci: &chalk_ir::ProgramClauseImplication<Self>,
|
||||
_fmt: &mut fmt::Formatter<'_>,
|
||||
) -> Option<fmt::Result> {
|
||||
None
|
||||
}
|
||||
|
||||
fn debug_application_ty(
|
||||
_application_ty: &chalk_ir::ApplicationTy<Self>,
|
||||
_fmt: &mut fmt::Formatter<'_>,
|
||||
) -> Option<fmt::Result> {
|
||||
None
|
||||
}
|
||||
|
||||
fn debug_substitution(
|
||||
_substitution: &chalk_ir::Substitution<Self>,
|
||||
_fmt: &mut fmt::Formatter<'_>,
|
||||
) -> Option<fmt::Result> {
|
||||
None
|
||||
}
|
||||
|
||||
fn debug_separator_trait_ref(
|
||||
_separator_trait_ref: &chalk_ir::SeparatorTraitRef<Self>,
|
||||
_fmt: &mut fmt::Formatter<'_>,
|
||||
) -> Option<fmt::Result> {
|
||||
None
|
||||
}
|
||||
|
||||
fn intern_ty(&self, ty: chalk_ir::TyData<Self>) -> Box<chalk_ir::TyData<Self>> {
|
||||
Box::new(ty)
|
||||
}
|
||||
|
||||
fn ty_data(ty: &Box<chalk_ir::TyData<Self>>) -> &chalk_ir::TyData<Self> {
|
||||
fn ty_data<'a>(&self, ty: &'a Box<chalk_ir::TyData<Self>>) -> &'a chalk_ir::TyData<Self> {
|
||||
ty
|
||||
}
|
||||
|
||||
fn intern_lifetime(lifetime: chalk_ir::LifetimeData<Self>) -> chalk_ir::LifetimeData<Self> {
|
||||
fn intern_lifetime(
|
||||
&self,
|
||||
lifetime: chalk_ir::LifetimeData<Self>,
|
||||
) -> chalk_ir::LifetimeData<Self> {
|
||||
lifetime
|
||||
}
|
||||
|
||||
fn lifetime_data(lifetime: &chalk_ir::LifetimeData<Self>) -> &chalk_ir::LifetimeData<Self> {
|
||||
fn lifetime_data<'a>(
|
||||
&self,
|
||||
lifetime: &'a chalk_ir::LifetimeData<Self>,
|
||||
) -> &'a chalk_ir::LifetimeData<Self> {
|
||||
lifetime
|
||||
}
|
||||
|
||||
fn intern_parameter(parameter: chalk_ir::ParameterData<Self>) -> chalk_ir::ParameterData<Self> {
|
||||
fn intern_parameter(
|
||||
&self,
|
||||
parameter: chalk_ir::ParameterData<Self>,
|
||||
) -> chalk_ir::ParameterData<Self> {
|
||||
parameter
|
||||
}
|
||||
|
||||
fn parameter_data(parameter: &chalk_ir::ParameterData<Self>) -> &chalk_ir::ParameterData<Self> {
|
||||
fn parameter_data<'a>(
|
||||
&self,
|
||||
parameter: &'a chalk_ir::ParameterData<Self>,
|
||||
) -> &'a chalk_ir::ParameterData<Self> {
|
||||
parameter
|
||||
}
|
||||
|
||||
fn intern_goal(goal: GoalData<Self>) -> Arc<GoalData<Self>> {
|
||||
fn intern_goal(&self, goal: GoalData<Self>) -> Arc<GoalData<Self>> {
|
||||
Arc::new(goal)
|
||||
}
|
||||
|
||||
fn intern_goals(data: impl IntoIterator<Item = Goal<Self>>) -> Self::InternedGoals {
|
||||
fn intern_goals(&self, data: impl IntoIterator<Item = Goal<Self>>) -> Self::InternedGoals {
|
||||
data.into_iter().collect()
|
||||
}
|
||||
|
||||
fn goal_data(goal: &Arc<GoalData<Self>>) -> &GoalData<Self> {
|
||||
fn goal_data<'a>(&self, goal: &'a Arc<GoalData<Self>>) -> &'a GoalData<Self> {
|
||||
goal
|
||||
}
|
||||
|
||||
fn goals_data(goals: &Vec<Goal<Interner>>) -> &[Goal<Interner>] {
|
||||
fn goals_data<'a>(&self, goals: &'a Vec<Goal<Interner>>) -> &'a [Goal<Interner>] {
|
||||
goals
|
||||
}
|
||||
|
||||
fn intern_substitution<E>(
|
||||
&self,
|
||||
data: impl IntoIterator<Item = Result<Parameter<Self>, E>>,
|
||||
) -> Result<Vec<Parameter<Self>>, E> {
|
||||
data.into_iter().collect()
|
||||
}
|
||||
|
||||
fn substitution_data(substitution: &Vec<Parameter<Self>>) -> &[Parameter<Self>] {
|
||||
fn substitution_data<'a>(
|
||||
&self,
|
||||
substitution: &'a Vec<Parameter<Self>>,
|
||||
) -> &'a [Parameter<Self>] {
|
||||
substitution
|
||||
}
|
||||
}
|
||||
|
|
@ -145,12 +221,14 @@ impl ToChalk for Ty {
|
|||
Ty::Apply(apply_ty) => {
|
||||
let name = apply_ty.ctor.to_chalk(db);
|
||||
let substitution = apply_ty.parameters.to_chalk(db);
|
||||
chalk_ir::ApplicationTy { name, substitution }.cast().intern(&Interner)
|
||||
chalk_ir::ApplicationTy { name, substitution }.cast(&Interner).intern(&Interner)
|
||||
}
|
||||
Ty::Projection(proj_ty) => {
|
||||
let associated_ty_id = proj_ty.associated_ty.to_chalk(db);
|
||||
let substitution = proj_ty.parameters.to_chalk(db);
|
||||
chalk_ir::AliasTy { associated_ty_id, substitution }.cast().intern(&Interner)
|
||||
chalk_ir::AliasTy { associated_ty_id, substitution }
|
||||
.cast(&Interner)
|
||||
.intern(&Interner)
|
||||
}
|
||||
Ty::Placeholder(id) => {
|
||||
let interned_id = db.intern_type_param_id(id);
|
||||
|
|
@ -160,7 +238,7 @@ impl ToChalk for Ty {
|
|||
}
|
||||
.to_ty::<Interner>(&Interner)
|
||||
}
|
||||
Ty::Bound(idx) => chalk_ir::TyData::BoundVar(idx as usize).intern(&Interner),
|
||||
Ty::Bound(idx) => chalk_ir::TyData::BoundVar(idx).intern(&Interner),
|
||||
Ty::Infer(_infer_ty) => panic!("uncanonicalized infer ty"),
|
||||
Ty::Dyn(predicates) => {
|
||||
let where_clauses = predicates
|
||||
|
|
@ -173,14 +251,14 @@ impl ToChalk for Ty {
|
|||
chalk_ir::TyData::Dyn(bounded_ty).intern(&Interner)
|
||||
}
|
||||
Ty::Opaque(_) | Ty::Unknown => {
|
||||
let substitution = chalk_ir::Substitution::empty();
|
||||
let substitution = chalk_ir::Substitution::empty(&Interner);
|
||||
let name = TypeName::Error;
|
||||
chalk_ir::ApplicationTy { name, substitution }.cast().intern(&Interner)
|
||||
chalk_ir::ApplicationTy { name, substitution }.cast(&Interner).intern(&Interner)
|
||||
}
|
||||
}
|
||||
}
|
||||
fn from_chalk(db: &dyn HirDatabase, chalk: chalk_ir::Ty<Interner>) -> Self {
|
||||
match chalk.data().clone() {
|
||||
match chalk.data(&Interner).clone() {
|
||||
chalk_ir::TyData::Apply(apply_ty) => match apply_ty.name {
|
||||
TypeName::Error => Ty::Unknown,
|
||||
_ => {
|
||||
|
|
@ -202,7 +280,7 @@ impl ToChalk for Ty {
|
|||
Ty::Projection(ProjectionTy { associated_ty, parameters })
|
||||
}
|
||||
chalk_ir::TyData::Function(_) => unimplemented!(),
|
||||
chalk_ir::TyData::BoundVar(idx) => Ty::Bound(idx as u32),
|
||||
chalk_ir::TyData::BoundVar(idx) => Ty::Bound(idx),
|
||||
chalk_ir::TyData::InferenceVar(_iv) => Ty::Unknown,
|
||||
chalk_ir::TyData::Dyn(where_clauses) => {
|
||||
assert_eq!(where_clauses.bounds.binders.len(), 1);
|
||||
|
|
@ -218,13 +296,13 @@ impl ToChalk for Substs {
|
|||
type Chalk = chalk_ir::Substitution<Interner>;
|
||||
|
||||
fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::Substitution<Interner> {
|
||||
chalk_ir::Substitution::from(self.iter().map(|ty| ty.clone().to_chalk(db)))
|
||||
chalk_ir::Substitution::from(&Interner, self.iter().map(|ty| ty.clone().to_chalk(db)))
|
||||
}
|
||||
|
||||
fn from_chalk(db: &dyn HirDatabase, parameters: chalk_ir::Substitution<Interner>) -> Substs {
|
||||
let tys = parameters
|
||||
.into_iter()
|
||||
.map(|p| match p.ty() {
|
||||
.iter(&Interner)
|
||||
.map(|p| match p.ty(&Interner) {
|
||||
Some(ty) => from_chalk(db, ty.clone()),
|
||||
None => unimplemented!(),
|
||||
})
|
||||
|
|
@ -332,15 +410,15 @@ impl ToChalk for GenericPredicate {
|
|||
fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::QuantifiedWhereClause<Interner> {
|
||||
match self {
|
||||
GenericPredicate::Implemented(trait_ref) => {
|
||||
make_binders(chalk_ir::WhereClause::Implemented(trait_ref.to_chalk(db)), 0)
|
||||
let chalk_trait_ref = trait_ref.to_chalk(db);
|
||||
let chalk_trait_ref = chalk_trait_ref.shifted_in(&Interner);
|
||||
make_binders(chalk_ir::WhereClause::Implemented(chalk_trait_ref), 0)
|
||||
}
|
||||
GenericPredicate::Projection(projection_pred) => {
|
||||
let ty = projection_pred.ty.to_chalk(db).shifted_in(&Interner);
|
||||
let alias = projection_pred.projection_ty.to_chalk(db).shifted_in(&Interner);
|
||||
make_binders(chalk_ir::WhereClause::AliasEq(chalk_ir::AliasEq { alias, ty }), 0)
|
||||
}
|
||||
GenericPredicate::Projection(projection_pred) => make_binders(
|
||||
chalk_ir::WhereClause::AliasEq(chalk_ir::AliasEq {
|
||||
alias: projection_pred.projection_ty.to_chalk(db),
|
||||
ty: projection_pred.ty.to_chalk(db),
|
||||
}),
|
||||
0,
|
||||
),
|
||||
GenericPredicate::Error => panic!("tried passing GenericPredicate::Error to Chalk"),
|
||||
}
|
||||
}
|
||||
|
|
@ -400,8 +478,8 @@ impl ToChalk for Obligation {
|
|||
|
||||
fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::DomainGoal<Interner> {
|
||||
match self {
|
||||
Obligation::Trait(tr) => tr.to_chalk(db).cast(),
|
||||
Obligation::Projection(pr) => pr.to_chalk(db).cast(),
|
||||
Obligation::Trait(tr) => tr.to_chalk(db).cast(&Interner),
|
||||
Obligation::Projection(pr) => pr.to_chalk(db).cast(&Interner),
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -438,8 +516,8 @@ impl ToChalk for Arc<super::TraitEnvironment> {
|
|||
continue;
|
||||
}
|
||||
let program_clause: chalk_ir::ProgramClause<Interner> =
|
||||
pred.clone().to_chalk(db).cast();
|
||||
clauses.push(program_clause.into_from_env_clause());
|
||||
pred.clone().to_chalk(db).cast(&Interner);
|
||||
clauses.push(program_clause.into_from_env_clause(&Interner));
|
||||
}
|
||||
chalk_ir::Environment::new().add_clauses(clauses)
|
||||
}
|
||||
|
|
@ -504,7 +582,8 @@ impl ToChalk for builtin::BuiltinImplAssocTyValueData {
|
|||
type Chalk = AssociatedTyValue;
|
||||
|
||||
fn to_chalk(self, db: &dyn HirDatabase) -> AssociatedTyValue {
|
||||
let value_bound = chalk_rust_ir::AssociatedTyValueBound { ty: self.value.to_chalk(db) };
|
||||
let ty = self.value.to_chalk(db);
|
||||
let value_bound = chalk_rust_ir::AssociatedTyValueBound { ty };
|
||||
|
||||
chalk_rust_ir::AssociatedTyValue {
|
||||
associated_ty_id: self.assoc_ty_id.to_chalk(db),
|
||||
|
|
@ -578,9 +657,9 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
|
|||
.map(|impl_| impl_.to_chalk(self.db))
|
||||
.collect();
|
||||
|
||||
let ty: Ty = from_chalk(self.db, parameters[0].assert_ty_ref().clone());
|
||||
let ty: Ty = from_chalk(self.db, parameters[0].assert_ty_ref(&Interner).clone());
|
||||
let arg: Option<Ty> =
|
||||
parameters.get(1).map(|p| from_chalk(self.db, p.assert_ty_ref().clone()));
|
||||
parameters.get(1).map(|p| from_chalk(self.db, p.assert_ty_ref(&Interner).clone()));
|
||||
|
||||
builtin::get_builtin_impls(self.db, self.krate, &ty, &arg, trait_, |i| {
|
||||
result.push(i.to_chalk(self.db))
|
||||
|
|
@ -663,11 +742,13 @@ pub(crate) fn trait_datum_query(
|
|||
let associated_ty_ids =
|
||||
trait_data.associated_types().map(|type_alias| type_alias.to_chalk(db)).collect();
|
||||
let trait_datum_bound = chalk_rust_ir::TraitDatumBound { where_clauses };
|
||||
let well_known = None; // FIXME set this (depending on lang items)
|
||||
let trait_datum = TraitDatum {
|
||||
id: trait_id,
|
||||
binders: make_binders(trait_datum_bound, bound_vars.len()),
|
||||
flags,
|
||||
associated_ty_ids,
|
||||
well_known,
|
||||
};
|
||||
Arc::new(trait_datum)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -201,11 +201,11 @@ impl Generics {
|
|||
(parent, self_params, list_params, impl_trait_params)
|
||||
}
|
||||
|
||||
pub(crate) fn param_idx(&self, param: TypeParamId) -> Option<u32> {
|
||||
pub(crate) fn param_idx(&self, param: TypeParamId) -> Option<usize> {
|
||||
Some(self.find_param(param)?.0)
|
||||
}
|
||||
|
||||
fn find_param(&self, param: TypeParamId) -> Option<(u32, &TypeParamData)> {
|
||||
fn find_param(&self, param: TypeParamId) -> Option<(usize, &TypeParamData)> {
|
||||
if param.parent == self.def {
|
||||
let (idx, (_local_id, data)) = self
|
||||
.params
|
||||
|
|
@ -215,7 +215,7 @@ impl Generics {
|
|||
.find(|(_, (idx, _))| *idx == param.local_id)
|
||||
.unwrap();
|
||||
let (_total, parent_len, _child) = self.len_split();
|
||||
Some(((parent_len + idx) as u32, data))
|
||||
Some((parent_len + idx, data))
|
||||
} else {
|
||||
self.parent_generics.as_ref().and_then(|g| g.find_param(param))
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue