Mirrors/rust-analyzer
2
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer synced 2024-12-27 05:23:24 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge #2636

Browse source 
2636: Chalk update and refactoring r=flodiebold a=flodiebold

This updates the Chalk integration to https://github.com/rust-lang/chalk/pull/311, which will presumably get merged soon, and refactors it some more, most notably introducing our own `TypeFamily` instead of reusing `ChalkIr`. It's still mostly the same as `ChalkIr` though, except for using Salsa `InternId`s directly.

Co-authored-by: Florian Diebold <flodiebold@gmail.com>
This commit is contained in:
bors[bot] 2019-12-23 10:58:06 +00:00 committed by GitHub
commit ce07a2daa9
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
8 changed files with 354 additions and 306 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

56
Cargo.lock generated
View file

@ -128,7 +128,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]] [[package]]
name = "chalk-derive" name = "chalk-derive"
version = "0.1.0" version = "0.1.0"
source = "git+https://github.com/rust-lang/chalk.git?rev=151949dece8117d180b5d197a7afa968c3ba14bb#151949dece8117d180b5d197a7afa968c3ba14bb" source = "git+https://github.com/rust-lang/chalk.git?rev=ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5#ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5"
dependencies = [ dependencies = [
"proc-macro2 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)", "proc-macro2 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
"quote 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)", "quote 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
@ -138,27 +138,27 @@ dependencies = [
[[package]] [[package]]
name = "chalk-engine" name = "chalk-engine"
version = "0.9.0" version = "0.9.0"
source = "git+https://github.com/rust-lang/chalk.git?rev=151949dece8117d180b5d197a7afa968c3ba14bb#151949dece8117d180b5d197a7afa968c3ba14bb" source = "git+https://github.com/rust-lang/chalk.git?rev=ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5#ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5"
dependencies = [ dependencies = [
"chalk-macros 0.1.1 (git+https://github.com/rust-lang/chalk.git?rev=151949dece8117d180b5d197a7afa968c3ba14bb)", "chalk-macros 0.1.1 (git+https://github.com/rust-lang/chalk.git?rev=ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5)",
"rustc-hash 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)", "rustc-hash 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
] ]
[[package]] [[package]]
name = "chalk-ir" name = "chalk-ir"
version = "0.1.0" version = "0.1.0"
source = "git+https://github.com/rust-lang/chalk.git?rev=151949dece8117d180b5d197a7afa968c3ba14bb#151949dece8117d180b5d197a7afa968c3ba14bb" source = "git+https://github.com/rust-lang/chalk.git?rev=ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5#ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5"
dependencies = [ dependencies = [
"chalk-derive 0.1.0 (git+https://github.com/rust-lang/chalk.git?rev=151949dece8117d180b5d197a7afa968c3ba14bb)", "chalk-derive 0.1.0 (git+https://github.com/rust-lang/chalk.git?rev=ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5)",
"chalk-engine 0.9.0 (git+https://github.com/rust-lang/chalk.git?rev=151949dece8117d180b5d197a7afa968c3ba14bb)", "chalk-engine 0.9.0 (git+https://github.com/rust-lang/chalk.git?rev=ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5)",
"chalk-macros 0.1.1 (git+https://github.com/rust-lang/chalk.git?rev=151949dece8117d180b5d197a7afa968c3ba14bb)", "chalk-macros 0.1.1 (git+https://github.com/rust-lang/chalk.git?rev=ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5)",
"lalrpop-intern 0.15.1 (registry+https://github.com/rust-lang/crates.io-index)", "lalrpop-intern 0.15.1 (registry+https://github.com/rust-lang/crates.io-index)",
] ]
[[package]] [[package]]
name = "chalk-macros" name = "chalk-macros"
version = "0.1.1" version = "0.1.1"
source = "git+https://github.com/rust-lang/chalk.git?rev=151949dece8117d180b5d197a7afa968c3ba14bb#151949dece8117d180b5d197a7afa968c3ba14bb" source = "git+https://github.com/rust-lang/chalk.git?rev=ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5#ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5"
dependencies = [ dependencies = [
"lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)", "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
] ]
@ -166,24 +166,24 @@ dependencies = [
[[package]] [[package]]
name = "chalk-rust-ir" name = "chalk-rust-ir"
version = "0.1.0" version = "0.1.0"
source = "git+https://github.com/rust-lang/chalk.git?rev=151949dece8117d180b5d197a7afa968c3ba14bb#151949dece8117d180b5d197a7afa968c3ba14bb" source = "git+https://github.com/rust-lang/chalk.git?rev=ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5#ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5"
dependencies = [ dependencies = [
"chalk-derive 0.1.0 (git+https://github.com/rust-lang/chalk.git?rev=151949dece8117d180b5d197a7afa968c3ba14bb)", "chalk-derive 0.1.0 (git+https://github.com/rust-lang/chalk.git?rev=ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5)",
"chalk-engine 0.9.0 (git+https://github.com/rust-lang/chalk.git?rev=151949dece8117d180b5d197a7afa968c3ba14bb)", "chalk-engine 0.9.0 (git+https://github.com/rust-lang/chalk.git?rev=ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5)",
"chalk-ir 0.1.0 (git+https://github.com/rust-lang/chalk.git?rev=151949dece8117d180b5d197a7afa968c3ba14bb)", "chalk-ir 0.1.0 (git+https://github.com/rust-lang/chalk.git?rev=ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5)",
"chalk-macros 0.1.1 (git+https://github.com/rust-lang/chalk.git?rev=151949dece8117d180b5d197a7afa968c3ba14bb)", "chalk-macros 0.1.1 (git+https://github.com/rust-lang/chalk.git?rev=ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5)",
] ]
[[package]] [[package]]
name = "chalk-solve" name = "chalk-solve"
version = "0.1.0" version = "0.1.0"
source = "git+https://github.com/rust-lang/chalk.git?rev=151949dece8117d180b5d197a7afa968c3ba14bb#151949dece8117d180b5d197a7afa968c3ba14bb" source = "git+https://github.com/rust-lang/chalk.git?rev=ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5#ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5"
dependencies = [ dependencies = [
"chalk-derive 0.1.0 (git+https://github.com/rust-lang/chalk.git?rev=151949dece8117d180b5d197a7afa968c3ba14bb)", "chalk-derive 0.1.0 (git+https://github.com/rust-lang/chalk.git?rev=ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5)",
"chalk-engine 0.9.0 (git+https://github.com/rust-lang/chalk.git?rev=151949dece8117d180b5d197a7afa968c3ba14bb)", "chalk-engine 0.9.0 (git+https://github.com/rust-lang/chalk.git?rev=ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5)",
"chalk-ir 0.1.0 (git+https://github.com/rust-lang/chalk.git?rev=151949dece8117d180b5d197a7afa968c3ba14bb)", "chalk-ir 0.1.0 (git+https://github.com/rust-lang/chalk.git?rev=ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5)",
"chalk-macros 0.1.1 (git+https://github.com/rust-lang/chalk.git?rev=151949dece8117d180b5d197a7afa968c3ba14bb)", "chalk-macros 0.1.1 (git+https://github.com/rust-lang/chalk.git?rev=ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5)",
"chalk-rust-ir 0.1.0 (git+https://github.com/rust-lang/chalk.git?rev=151949dece8117d180b5d197a7afa968c3ba14bb)", "chalk-rust-ir 0.1.0 (git+https://github.com/rust-lang/chalk.git?rev=ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5)",
"ena 0.13.1 (registry+https://github.com/rust-lang/crates.io-index)", "ena 0.13.1 (registry+https://github.com/rust-lang/crates.io-index)",
"itertools 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)", "itertools 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)",
"petgraph 0.4.13 (registry+https://github.com/rust-lang/crates.io-index)", "petgraph 0.4.13 (registry+https://github.com/rust-lang/crates.io-index)",
@ -995,9 +995,9 @@ name = "ra_hir_ty"
version = "0.1.0" version = "0.1.0"
dependencies = [ dependencies = [
"arrayvec 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)", "arrayvec 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
"chalk-ir 0.1.0 (git+https://github.com/rust-lang/chalk.git?rev=151949dece8117d180b5d197a7afa968c3ba14bb)", "chalk-ir 0.1.0 (git+https://github.com/rust-lang/chalk.git?rev=ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5)",
"chalk-rust-ir 0.1.0 (git+https://github.com/rust-lang/chalk.git?rev=151949dece8117d180b5d197a7afa968c3ba14bb)", "chalk-rust-ir 0.1.0 (git+https://github.com/rust-lang/chalk.git?rev=ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5)",
"chalk-solve 0.1.0 (git+https://github.com/rust-lang/chalk.git?rev=151949dece8117d180b5d197a7afa968c3ba14bb)", "chalk-solve 0.1.0 (git+https://github.com/rust-lang/chalk.git?rev=ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5)",
"ena 0.13.1 (registry+https://github.com/rust-lang/crates.io-index)", "ena 0.13.1 (registry+https://github.com/rust-lang/crates.io-index)",
"insta 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)", "insta 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)",
"lalrpop-intern 0.15.1 (registry+https://github.com/rust-lang/crates.io-index)", "lalrpop-intern 0.15.1 (registry+https://github.com/rust-lang/crates.io-index)",
@ -1782,12 +1782,12 @@ dependencies = [
"checksum cargo_metadata 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)" = "46e3374c604fb39d1a2f35ed5e4a4e30e60d01fab49446e08f1b3e9a90aef202" "checksum cargo_metadata 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)" = "46e3374c604fb39d1a2f35ed5e4a4e30e60d01fab49446e08f1b3e9a90aef202"
"checksum cc 1.0.48 (registry+https://github.com/rust-lang/crates.io-index)" = "f52a465a666ca3d838ebbf08b241383421412fe7ebb463527bba275526d89f76" "checksum cc 1.0.48 (registry+https://github.com/rust-lang/crates.io-index)" = "f52a465a666ca3d838ebbf08b241383421412fe7ebb463527bba275526d89f76"
"checksum cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)" = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822" "checksum cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)" = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
"checksum chalk-derive 0.1.0 (git+https://github.com/rust-lang/chalk.git?rev=151949dece8117d180b5d197a7afa968c3ba14bb)" = "<none>" "checksum chalk-derive 0.1.0 (git+https://github.com/rust-lang/chalk.git?rev=ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5)" = "<none>"
"checksum chalk-engine 0.9.0 (git+https://github.com/rust-lang/chalk.git?rev=151949dece8117d180b5d197a7afa968c3ba14bb)" = "<none>" "checksum chalk-engine 0.9.0 (git+https://github.com/rust-lang/chalk.git?rev=ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5)" = "<none>"
"checksum chalk-ir 0.1.0 (git+https://github.com/rust-lang/chalk.git?rev=151949dece8117d180b5d197a7afa968c3ba14bb)" = "<none>" "checksum chalk-ir 0.1.0 (git+https://github.com/rust-lang/chalk.git?rev=ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5)" = "<none>"
"checksum chalk-macros 0.1.1 (git+https://github.com/rust-lang/chalk.git?rev=151949dece8117d180b5d197a7afa968c3ba14bb)" = "<none>" "checksum chalk-macros 0.1.1 (git+https://github.com/rust-lang/chalk.git?rev=ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5)" = "<none>"
"checksum chalk-rust-ir 0.1.0 (git+https://github.com/rust-lang/chalk.git?rev=151949dece8117d180b5d197a7afa968c3ba14bb)" = "<none>" "checksum chalk-rust-ir 0.1.0 (git+https://github.com/rust-lang/chalk.git?rev=ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5)" = "<none>"
"checksum chalk-solve 0.1.0 (git+https://github.com/rust-lang/chalk.git?rev=151949dece8117d180b5d197a7afa968c3ba14bb)" = "<none>" "checksum chalk-solve 0.1.0 (git+https://github.com/rust-lang/chalk.git?rev=ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5)" = "<none>"
"checksum clicolors-control 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "90082ee5dcdd64dc4e9e0d37fbf3ee325419e39c0092191e0393df65518f741e" "checksum clicolors-control 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "90082ee5dcdd64dc4e9e0d37fbf3ee325419e39c0092191e0393df65518f741e"
"checksum cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "ddfc5b9aa5d4507acaf872de71051dfd0e309860e88966e1051e462a077aac4f" "checksum cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "ddfc5b9aa5d4507acaf872de71051dfd0e309860e88966e1051e462a077aac4f"
"checksum console 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)" = "f5d540c2d34ac9dd0deb5f3b5f54c36c79efa78f6b3ad19106a554d07a7b5d9f" "checksum console 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)" = "f5d540c2d34ac9dd0deb5f3b5f54c36c79efa78f6b3ad19106a554d07a7b5d9f"

7
crates/ra_hir_ty/Cargo.toml
View file

@ -21,10 +21,9 @@ ra_prof = { path = "../ra_prof" }
ra_syntax = { path = "../ra_syntax" } ra_syntax = { path = "../ra_syntax" }
test_utils = { path = "../test_utils" } test_utils = { path = "../test_utils" }
# https://github.com/rust-lang/chalk/pull/294 chalk-solve = { git = "https://github.com/rust-lang/chalk.git", rev = "ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5" }
chalk-solve = { git = "https://github.com/rust-lang/chalk.git", rev = "151949dece8117d180b5d197a7afa968c3ba14bb" } chalk-rust-ir = { git = "https://github.com/rust-lang/chalk.git", rev = "ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5" }
chalk-rust-ir = { git = "https://github.com/rust-lang/chalk.git", rev = "151949dece8117d180b5d197a7afa968c3ba14bb" } chalk-ir = { git = "https://github.com/rust-lang/chalk.git", rev = "ff65b5ac9860f3c36bd892c865ab23d5ff0bbae5" }
chalk-ir = { git = "https://github.com/rust-lang/chalk.git", rev = "151949dece8117d180b5d197a7afa968c3ba14bb" }
lalrpop-intern = "0.15.1" lalrpop-intern = "0.15.1"

35
crates/ra_hir_ty/src/db.rs
View file

@ -10,7 +10,7 @@ use ra_db::{salsa, CrateId};
use crate::{ use crate::{
method_resolution::CrateImplBlocks, method_resolution::CrateImplBlocks,
traits::{AssocTyValue, Impl}, traits::{chalk, AssocTyValue, Impl},
CallableDef, FnSig, GenericPredicate, InferenceResult, Substs, TraitRef, Ty, TyDefId, TypeCtor, CallableDef, FnSig, GenericPredicate, InferenceResult, Substs, TraitRef, Ty, TyDefId, TypeCtor,
ValueTyDefId, ValueTyDefId,
}; };
@ -77,39 +77,24 @@ pub trait HirDatabase: DefDatabase {
#[salsa::interned] #[salsa::interned]
fn intern_assoc_ty_value(&self, assoc_ty_value: AssocTyValue) -> crate::traits::AssocTyValueId; fn intern_assoc_ty_value(&self, assoc_ty_value: AssocTyValue) -> crate::traits::AssocTyValueId;
#[salsa::invoke(crate::traits::chalk::associated_ty_data_query)] #[salsa::invoke(chalk::associated_ty_data_query)]
fn associated_ty_data( fn associated_ty_data(&self, id: chalk::AssocTypeId) -> Arc<chalk::AssociatedTyDatum>;
&self,
id: chalk_ir::TypeId,
) -> Arc<chalk_rust_ir::AssociatedTyDatum<chalk_ir::family::ChalkIr>>;
#[salsa::invoke(crate::traits::chalk::trait_datum_query)] #[salsa::invoke(chalk::trait_datum_query)]
fn trait_datum( fn trait_datum(&self, krate: CrateId, trait_id: chalk::TraitId) -> Arc<chalk::TraitDatum>;
&self,
krate: CrateId,
trait_id: chalk_ir::TraitId,
) -> Arc<chalk_rust_ir::TraitDatum<chalk_ir::family::ChalkIr>>;
#[salsa::invoke(crate::traits::chalk::struct_datum_query)] #[salsa::invoke(chalk::struct_datum_query)]
fn struct_datum( fn struct_datum(&self, krate: CrateId, struct_id: chalk::StructId) -> Arc<chalk::StructDatum>;
&self,
krate: CrateId,
struct_id: chalk_ir::StructId,
) -> Arc<chalk_rust_ir::StructDatum<chalk_ir::family::ChalkIr>>;
#[salsa::invoke(crate::traits::chalk::impl_datum_query)] #[salsa::invoke(crate::traits::chalk::impl_datum_query)]
fn impl_datum( fn impl_datum(&self, krate: CrateId, impl_id: chalk::ImplId) -> Arc<chalk::ImplDatum>;
&self,
krate: CrateId,
impl_id: chalk_ir::ImplId,
) -> Arc<chalk_rust_ir::ImplDatum<chalk_ir::family::ChalkIr>>;
#[salsa::invoke(crate::traits::chalk::associated_ty_value_query)] #[salsa::invoke(crate::traits::chalk::associated_ty_value_query)]
fn associated_ty_value( fn associated_ty_value(
&self, &self,
krate: CrateId, krate: CrateId,
id: chalk_rust_ir::AssociatedTyValueId, id: chalk::AssociatedTyValueId,
) -> Arc<chalk_rust_ir::AssociatedTyValue<chalk_ir::family::ChalkIr>>; ) -> Arc<chalk::AssociatedTyValue>;
#[salsa::invoke(crate::traits::trait_solve_query)] #[salsa::invoke(crate::traits::trait_solve_query)]
fn trait_solve( fn trait_solve(

4
crates/ra_hir_ty/src/tests/method_resolution.rs
View file

@ -865,7 +865,7 @@ mod foo {
#[test] #[test]
fn method_resolution_where_clause_for_unknown_trait() { fn method_resolution_where_clause_for_unknown_trait() {
// The blanket impl shouldn't apply because we can't even resolve UnknownTrait // The blanket impl currently applies because we ignore the unresolved where clause
let t = type_at( let t = type_at(
r#" r#"
//- /main.rs //- /main.rs
@ -875,7 +875,7 @@ impl<T> Trait for T where T: UnknownTrait {}
fn test() { (&S).foo()<|>; } fn test() { (&S).foo()<|>; }
"#, "#,
); );
assert_eq!(t, "{unknown}"); assert_eq!(t, "u128");
} }
#[test] #[test]

17
crates/ra_hir_ty/src/tests/traits.rs
View file

@ -958,6 +958,23 @@ fn test() {
); );
} }
#[test]
fn error_bound_chalk() {
let t = type_at(
r#"
//- /main.rs
trait Trait {
fn foo(&self) -> u32 {}
}
fn test(x: (impl Trait + UnknownTrait)) {
x.foo()<|>;
}
"#,
);
assert_eq!(t, "u32");
}
#[test] #[test]
fn assoc_type_bindings() { fn assoc_type_bindings() {
assert_snapshot!( assert_snapshot!(

24
crates/ra_hir_ty/src/traits.rs
View file

@ -1,7 +1,7 @@
//! Trait solving using Chalk. //! Trait solving using Chalk.
use std::sync::{Arc, Mutex}; use std::sync::{Arc, Mutex};
use chalk_ir::{cast::Cast, family::ChalkIr}; use chalk_ir::cast::Cast;
use hir_def::{expr::ExprId, DefWithBodyId, ImplId, TraitId, TypeAliasId}; use hir_def::{expr::ExprId, DefWithBodyId, ImplId, TraitId, TypeAliasId};
use log::debug; use log::debug;
use ra_db::{impl_intern_key, salsa, CrateId}; use ra_db::{impl_intern_key, salsa, CrateId};
@ -12,7 +12,7 @@ use crate::db::HirDatabase;
use super::{Canonical, GenericPredicate, HirDisplay, ProjectionTy, TraitRef, Ty, TypeWalk}; use super::{Canonical, GenericPredicate, HirDisplay, ProjectionTy, TraitRef, Ty, TypeWalk};
use self::chalk::{from_chalk, ToChalk}; use self::chalk::{from_chalk, ToChalk, TypeFamily};
pub(crate) mod chalk; pub(crate) mod chalk;
mod builtin; mod builtin;
@ -20,7 +20,7 @@ mod builtin;
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub struct TraitSolver { pub struct TraitSolver {
krate: CrateId, krate: CrateId,
inner: Arc<Mutex<chalk_solve::Solver<ChalkIr>>>, inner: Arc<Mutex<chalk_solve::Solver<TypeFamily>>>,
} }
/// We need eq for salsa /// We need eq for salsa
@ -36,8 +36,8 @@ impl TraitSolver {
fn solve( fn solve(
&self, &self,
db: &impl HirDatabase, db: &impl HirDatabase,
goal: &chalk_ir::UCanonical<chalk_ir::InEnvironment<chalk_ir::Goal<ChalkIr>>>, goal: &chalk_ir::UCanonical<chalk_ir::InEnvironment<chalk_ir::Goal<TypeFamily>>>,
) -> Option<chalk_solve::Solution<ChalkIr>> { ) -> Option<chalk_solve::Solution<TypeFamily>> {
let context = ChalkContext { db, krate: self.krate }; let context = ChalkContext { db, krate: self.krate };
debug!("solve goal: {:?}", goal); debug!("solve goal: {:?}", goal);
let mut solver = match self.inner.lock() { let mut solver = match self.inner.lock() {
@ -201,17 +201,17 @@ pub(crate) fn trait_solve_query(
fn solution_from_chalk( fn solution_from_chalk(
db: &impl HirDatabase, db: &impl HirDatabase,
solution: chalk_solve::Solution<ChalkIr>, solution: chalk_solve::Solution<TypeFamily>,
) -> Solution { ) -> Solution {
let convert_subst = |subst: chalk_ir::Canonical<chalk_ir::Substitution<ChalkIr>>| { let convert_subst = |subst: chalk_ir::Canonical<chalk_ir::Substitution<TypeFamily>>| {
let value = subst let value = subst
.value .value
.parameters .parameters
.into_iter() .into_iter()
.map(|p| { .map(|p| {
let ty = match p { let ty = match p.ty() {
chalk_ir::Parameter(chalk_ir::ParameterKind::Ty(ty)) => from_chalk(db, ty), Some(ty) => from_chalk(db, ty.clone()),
chalk_ir::Parameter(chalk_ir::ParameterKind::Lifetime(_)) => unimplemented!(), None => unimplemented!(),
}; };
ty ty
}) })
@ -291,7 +291,7 @@ impl FnTrait {
} }
} }
#[derive(Debug, Clone, PartialEq, Eq, Hash)] #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct ClosureFnTraitImplData { pub struct ClosureFnTraitImplData {
def: DefWithBodyId, def: DefWithBodyId,
expr: ExprId, expr: ExprId,
@ -300,7 +300,7 @@ pub struct ClosureFnTraitImplData {
/// An impl. Usually this comes from an impl block, but some built-in types get /// An impl. Usually this comes from an impl block, but some built-in types get
/// synthetic impls. /// synthetic impls.
#[derive(Debug, Clone, PartialEq, Eq, Hash)] #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Impl { pub enum Impl {
/// A normal impl from an impl block. /// A normal impl from an impl block.
ImplBlock(ImplId), ImplBlock(ImplId),

47
crates/ra_hir_ty/src/traits/builtin.rs
View file

@ -28,24 +28,24 @@ pub(super) fn get_builtin_impls(
trait_: TraitId, trait_: TraitId,
mut callback: impl FnMut(Impl), mut callback: impl FnMut(Impl),
) { ) {
// Note: since impl_datum needs to be infallible, we need to make sure here
// that we have all prerequisites to build the respective impls.
if let Ty::Apply(ApplicationTy { ctor: TypeCtor::Closure { def, expr }, .. }) = ty { if let Ty::Apply(ApplicationTy { ctor: TypeCtor::Closure { def, expr }, .. }) = ty {
for &fn_trait in [super::FnTrait::FnOnce, super::FnTrait::FnMut, super::FnTrait::Fn].iter() for &fn_trait in [super::FnTrait::FnOnce, super::FnTrait::FnMut, super::FnTrait::Fn].iter()
{ {
if let Some(actual_trait) = get_fn_trait(db, krate, fn_trait) { if let Some(actual_trait) = get_fn_trait(db, krate, fn_trait) {
if trait_ == actual_trait { if trait_ == actual_trait {
let impl_ = super::ClosureFnTraitImplData { def: *def, expr: *expr, fn_trait }; let impl_ = super::ClosureFnTraitImplData { def: *def, expr: *expr, fn_trait };
if check_closure_fn_trait_impl_prerequisites(db, krate, impl_) {
callback(Impl::ClosureFnTraitImpl(impl_)); callback(Impl::ClosureFnTraitImpl(impl_));
} }
} }
} }
} }
} }
}
pub(super) fn impl_datum( pub(super) fn impl_datum(db: &impl HirDatabase, krate: CrateId, impl_: Impl) -> BuiltinImplData {
db: &impl HirDatabase,
krate: CrateId,
impl_: Impl,
) -> Option<BuiltinImplData> {
match impl_ { match impl_ {
Impl::ImplBlock(_) => unreachable!(), Impl::ImplBlock(_) => unreachable!(),
Impl::ClosureFnTraitImpl(data) => closure_fn_trait_impl_datum(db, krate, data), Impl::ClosureFnTraitImpl(data) => closure_fn_trait_impl_datum(db, krate, data),
@ -65,21 +65,38 @@ pub(super) fn associated_ty_value(
} }
} }
fn check_closure_fn_trait_impl_prerequisites(
db: &impl HirDatabase,
krate: CrateId,
data: super::ClosureFnTraitImplData,
) -> bool {
// the respective Fn/FnOnce/FnMut trait needs to exist
if get_fn_trait(db, krate, data.fn_trait).is_none() {
return false;
}
// FIXME: there are more assumptions that we should probably check here:
// the traits having no type params, FnOnce being a supertrait
// the FnOnce trait needs to exist and have an assoc type named Output
let fn_once_trait = match get_fn_trait(db, krate, super::FnTrait::FnOnce) {
Some(t) => t,
None => return false,
};
db.trait_data(fn_once_trait).associated_type_by_name(&name![Output]).is_some()
}
fn closure_fn_trait_impl_datum( fn closure_fn_trait_impl_datum(
db: &impl HirDatabase, db: &impl HirDatabase,
krate: CrateId, krate: CrateId,
data: super::ClosureFnTraitImplData, data: super::ClosureFnTraitImplData,
) -> Option<BuiltinImplData> { ) -> BuiltinImplData {
// for some closure |X, Y| -> Z: // for some closure |X, Y| -> Z:
// impl<T, U, V> Fn<(T, U)> for closure<fn(T, U) -> V> { Output = V } // impl<T, U, V> Fn<(T, U)> for closure<fn(T, U) -> V> { Output = V }
let trait_ = get_fn_trait(db, krate, data.fn_trait)?; // get corresponding fn trait let trait_ = get_fn_trait(db, krate, data.fn_trait) // get corresponding fn trait
// the existence of the Fn trait has been checked before
// validate FnOnce trait, since we need it in the assoc ty value definition .expect("fn trait for closure impl missing");
// and don't want to return a valid value only to find out later that FnOnce
// is broken
let fn_once_trait = get_fn_trait(db, krate, super::FnTrait::FnOnce)?;
let _output = db.trait_data(fn_once_trait).associated_type_by_name(&name![Output])?;
let num_args: u16 = match &db.body(data.def.into())[data.expr] { let num_args: u16 = match &db.body(data.def.into())[data.expr] {
Expr::Lambda { args, .. } => args.len() as u16, Expr::Lambda { args, .. } => args.len() as u16,
@ -107,12 +124,12 @@ fn closure_fn_trait_impl_datum(
let output_ty_id = AssocTyValue::ClosureFnTraitImplOutput(data.clone()); let output_ty_id = AssocTyValue::ClosureFnTraitImplOutput(data.clone());
Some(BuiltinImplData { BuiltinImplData {
num_vars: num_args as usize + 1, num_vars: num_args as usize + 1,
trait_ref, trait_ref,
where_clauses: Vec::new(), where_clauses: Vec::new(),
assoc_ty_values: vec![output_ty_id], assoc_ty_values: vec![output_ty_id],
}) }
} }
fn closure_fn_trait_output_assoc_ty_value( fn closure_fn_trait_output_assoc_ty_value(

464
crates/ra_hir_ty/src/traits/chalk.rs
View file

@ -1,17 +1,11 @@
//! Conversion code from/to Chalk. //! Conversion code from/to Chalk.
use std::sync::Arc; use std::{fmt, sync::Arc};
use log::debug; use log::debug;
use chalk_ir::{ use chalk_ir::{cast::Cast, Parameter, PlaceholderIndex, TypeName, UniverseIndex};
cast::Cast, family::ChalkIr, Identifier, Parameter, PlaceholderIndex, TypeId, TypeKindId,
TypeName, UniverseIndex,
};
use chalk_rust_ir::{AssociatedTyDatum, AssociatedTyValue, ImplDatum, StructDatum, TraitDatum};
use hir_def::{ use hir_def::{AssocContainerId, AssocItemId, GenericDefId, HasModule, Lookup, TypeAliasId};
AssocContainerId, AssocItemId, GenericDefId, HasModule, ImplId, Lookup, TraitId, TypeAliasId,
};
use ra_db::{ use ra_db::{
salsa::{InternId, InternKey}, salsa::{InternId, InternKey},
CrateId, CrateId,
@ -23,9 +17,83 @@ use crate::{
ProjectionTy, Substs, TraitRef, Ty, TypeCtor, TypeWalk, ProjectionTy, Substs, TraitRef, Ty, TypeCtor, TypeWalk,
}; };
/// This represents a trait whose name we could not resolve. #[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
const UNKNOWN_TRAIT: chalk_ir::TraitId = pub struct TypeFamily {}
chalk_ir::TraitId(chalk_ir::RawId { index: u32::max_value() });
impl chalk_ir::family::TypeFamily for TypeFamily {
type InternedType = Box<chalk_ir::TyData<Self>>;
type InternedLifetime = chalk_ir::LifetimeData<Self>;
type InternedParameter = chalk_ir::ParameterData<Self>;
type DefId = InternId;
// FIXME: implement these
fn debug_struct_id(
_type_kind_id: chalk_ir::StructId<Self>,
_fmt: &mut fmt::Formatter<'_>,
) -> Option<fmt::Result> {
None
}
fn debug_trait_id(
_type_kind_id: chalk_ir::TraitId<Self>,
_fmt: &mut fmt::Formatter<'_>,
) -> Option<fmt::Result> {
None
}
fn debug_assoc_type_id(
_id: chalk_ir::AssocTypeId<Self>,
_fmt: &mut fmt::Formatter<'_>,
) -> Option<fmt::Result> {
None
}
fn debug_projection(
_projection: &chalk_ir::ProjectionTy<Self>,
_fmt: &mut fmt::Formatter<'_>,
) -> Option<fmt::Result> {
None
}
fn intern_ty(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> {
ty
}
fn intern_lifetime(lifetime: chalk_ir::LifetimeData<Self>) -> chalk_ir::LifetimeData<Self> {
lifetime
}
fn lifetime_data(lifetime: &chalk_ir::LifetimeData<Self>) -> &chalk_ir::LifetimeData<Self> {
lifetime
}
fn intern_parameter(parameter: chalk_ir::ParameterData<Self>) -> chalk_ir::ParameterData<Self> {
parameter
}
fn parameter_data(parameter: &chalk_ir::ParameterData<Self>) -> &chalk_ir::ParameterData<Self> {
parameter
}
}
impl chalk_ir::family::HasTypeFamily for TypeFamily {
type TypeFamily = Self;
}
pub type AssocTypeId = chalk_ir::AssocTypeId<TypeFamily>;
pub type AssociatedTyDatum = chalk_rust_ir::AssociatedTyDatum<TypeFamily>;
pub type TraitId = chalk_ir::TraitId<TypeFamily>;
pub type TraitDatum = chalk_rust_ir::TraitDatum<TypeFamily>;
pub type StructId = chalk_ir::StructId<TypeFamily>;
pub type StructDatum = chalk_rust_ir::StructDatum<TypeFamily>;
pub type ImplId = chalk_ir::ImplId<TypeFamily>;
pub type ImplDatum = chalk_rust_ir::ImplDatum<TypeFamily>;
pub type AssociatedTyValueId = chalk_rust_ir::AssociatedTyValueId;
pub type AssociatedTyValue = chalk_rust_ir::AssociatedTyValue<TypeFamily>;
pub(super) trait ToChalk { pub(super) trait ToChalk {
type Chalk; type Chalk;
@ -41,21 +109,11 @@ where
} }
impl ToChalk for Ty { impl ToChalk for Ty {
type Chalk = chalk_ir::Ty<ChalkIr>; type Chalk = chalk_ir::Ty<TypeFamily>;
fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::Ty<ChalkIr> { fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::Ty<TypeFamily> {
match self { match self {
Ty::Apply(apply_ty) => { Ty::Apply(apply_ty) => {
let name = match apply_ty.ctor { let name = apply_ty.ctor.to_chalk(db);
TypeCtor::AssociatedType(type_alias) => {
let type_id = type_alias.to_chalk(db);
TypeName::AssociatedType(type_id)
}
_ => {
// other TypeCtors get interned and turned into a chalk StructId
let struct_id = apply_ty.ctor.to_chalk(db);
TypeName::TypeKindId(struct_id.into())
}
};
let parameters = apply_ty.parameters.to_chalk(db); let parameters = apply_ty.parameters.to_chalk(db);
chalk_ir::ApplicationTy { name, parameters }.cast().intern() chalk_ir::ApplicationTy { name, parameters }.cast().intern()
} }
@ -65,17 +123,30 @@ impl ToChalk for Ty {
chalk_ir::ProjectionTy { associated_ty_id, parameters }.cast().intern() chalk_ir::ProjectionTy { associated_ty_id, parameters }.cast().intern()
} }
Ty::Param { idx, .. } => { Ty::Param { idx, .. } => {
PlaceholderIndex { ui: UniverseIndex::ROOT, idx: idx as usize }.to_ty::<ChalkIr>() PlaceholderIndex { ui: UniverseIndex::ROOT, idx: idx as usize }
.to_ty::<TypeFamily>()
} }
Ty::Bound(idx) => chalk_ir::TyData::BoundVar(idx as usize).intern(), Ty::Bound(idx) => chalk_ir::TyData::BoundVar(idx as usize).intern(),
Ty::Infer(_infer_ty) => panic!("uncanonicalized infer ty"), Ty::Infer(_infer_ty) => panic!("uncanonicalized infer ty"),
Ty::Dyn(predicates) => { Ty::Dyn(predicates) => {
let where_clauses = predicates.iter().cloned().map(|p| p.to_chalk(db)).collect(); let where_clauses = predicates
chalk_ir::TyData::Dyn(make_binders(where_clauses, 1)).intern() .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::Dyn(bounded_ty).intern()
} }
Ty::Opaque(predicates) => { Ty::Opaque(predicates) => {
let where_clauses = predicates.iter().cloned().map(|p| p.to_chalk(db)).collect(); let where_clauses = predicates
chalk_ir::TyData::Opaque(make_binders(where_clauses, 1)).intern() .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 => { Ty::Unknown => {
let parameters = Vec::new(); let parameters = Vec::new();
@ -84,31 +155,20 @@ impl ToChalk for Ty {
} }
} }
} }
fn from_chalk(db: &impl HirDatabase, chalk: chalk_ir::Ty<ChalkIr>) -> Self { fn from_chalk(db: &impl HirDatabase, chalk: chalk_ir::Ty<TypeFamily>) -> Self {
match chalk.data().clone() { match chalk.data().clone() {
chalk_ir::TyData::Apply(apply_ty) => { chalk_ir::TyData::Apply(apply_ty) => match apply_ty.name {
// FIXME this is kind of hacky due to the fact that
// TypeName::Placeholder is a Ty::Param on our side
match apply_ty.name {
TypeName::TypeKindId(TypeKindId::StructId(struct_id)) => {
let ctor = from_chalk(db, struct_id);
let parameters = from_chalk(db, apply_ty.parameters);
Ty::Apply(ApplicationTy { ctor, parameters })
}
TypeName::AssociatedType(type_id) => {
let ctor = TypeCtor::AssociatedType(from_chalk(db, type_id));
let parameters = from_chalk(db, apply_ty.parameters);
Ty::Apply(ApplicationTy { ctor, parameters })
}
TypeName::Error => Ty::Unknown, TypeName::Error => Ty::Unknown,
// FIXME handle TypeKindId::Trait/Type here _ => {
TypeName::TypeKindId(_) => unimplemented!(), let ctor = from_chalk(db, apply_ty.name);
TypeName::Placeholder(idx) => { let parameters = from_chalk(db, apply_ty.parameters);
Ty::Apply(ApplicationTy { ctor, parameters })
}
},
chalk_ir::TyData::Placeholder(idx) => {
assert_eq!(idx.ui, UniverseIndex::ROOT); assert_eq!(idx.ui, UniverseIndex::ROOT);
Ty::Param { idx: idx.idx as u32, name: crate::Name::missing() } Ty::Param { idx: idx.idx as u32, name: crate::Name::missing() }
} }
}
}
chalk_ir::TyData::Projection(proj) => { chalk_ir::TyData::Projection(proj) => {
let associated_ty = from_chalk(db, proj.associated_ty_id); let associated_ty = from_chalk(db, proj.associated_ty_id);
let parameters = from_chalk(db, proj.parameters); let parameters = from_chalk(db, proj.parameters);
@ -118,15 +178,15 @@ impl ToChalk for Ty {
chalk_ir::TyData::BoundVar(idx) => Ty::Bound(idx as u32), chalk_ir::TyData::BoundVar(idx) => Ty::Bound(idx as u32),
chalk_ir::TyData::InferenceVar(_iv) => Ty::Unknown, chalk_ir::TyData::InferenceVar(_iv) => Ty::Unknown,
chalk_ir::TyData::Dyn(where_clauses) => { chalk_ir::TyData::Dyn(where_clauses) => {
assert_eq!(where_clauses.binders.len(), 1); assert_eq!(where_clauses.bounds.binders.len(), 1);
let predicates = let predicates =
where_clauses.value.into_iter().map(|c| from_chalk(db, c)).collect(); where_clauses.bounds.value.into_iter().map(|c| from_chalk(db, c)).collect();
Ty::Dyn(predicates) Ty::Dyn(predicates)
} }
chalk_ir::TyData::Opaque(where_clauses) => { chalk_ir::TyData::Opaque(where_clauses) => {
assert_eq!(where_clauses.binders.len(), 1); assert_eq!(where_clauses.bounds.binders.len(), 1);
let predicates = let predicates =
where_clauses.value.into_iter().map(|c| from_chalk(db, c)).collect(); where_clauses.bounds.value.into_iter().map(|c| from_chalk(db, c)).collect();
Ty::Opaque(predicates) Ty::Opaque(predicates)
} }
} }
@ -134,18 +194,21 @@ impl ToChalk for Ty {
} }
impl ToChalk for Substs { impl ToChalk for Substs {
type Chalk = Vec<chalk_ir::Parameter<ChalkIr>>; type Chalk = Vec<chalk_ir::Parameter<TypeFamily>>;
fn to_chalk(self, db: &impl HirDatabase) -> Vec<Parameter<ChalkIr>> { fn to_chalk(self, db: &impl HirDatabase) -> Vec<Parameter<TypeFamily>> {
self.iter().map(|ty| ty.clone().to_chalk(db).cast()).collect() self.iter().map(|ty| ty.clone().to_chalk(db).cast()).collect()
} }
fn from_chalk(db: &impl HirDatabase, parameters: Vec<chalk_ir::Parameter<ChalkIr>>) -> Substs { fn from_chalk(
db: &impl HirDatabase,
parameters: Vec<chalk_ir::Parameter<TypeFamily>>,
) -> Substs {
let tys = parameters let tys = parameters
.into_iter() .into_iter()
.map(|p| match p { .map(|p| match p.ty() {
chalk_ir::Parameter(chalk_ir::ParameterKind::Ty(ty)) => from_chalk(db, ty), Some(ty) => from_chalk(db, ty.clone()),
chalk_ir::Parameter(chalk_ir::ParameterKind::Lifetime(_)) => unimplemented!(), None => unimplemented!(),
}) })
.collect(); .collect();
Substs(tys) Substs(tys)
@ -153,88 +216,102 @@ impl ToChalk for Substs {
} }
impl ToChalk for TraitRef { impl ToChalk for TraitRef {
type Chalk = chalk_ir::TraitRef<ChalkIr>; type Chalk = chalk_ir::TraitRef<TypeFamily>;
fn to_chalk(self: TraitRef, db: &impl HirDatabase) -> chalk_ir::TraitRef<ChalkIr> { fn to_chalk(self: TraitRef, db: &impl HirDatabase) -> chalk_ir::TraitRef<TypeFamily> {
let trait_id = self.trait_.to_chalk(db); let trait_id = self.trait_.to_chalk(db);
let parameters = self.substs.to_chalk(db); let parameters = self.substs.to_chalk(db);
chalk_ir::TraitRef { trait_id, parameters } chalk_ir::TraitRef { trait_id, parameters }
} }
fn from_chalk(db: &impl HirDatabase, trait_ref: chalk_ir::TraitRef<ChalkIr>) -> Self { fn from_chalk(db: &impl HirDatabase, trait_ref: chalk_ir::TraitRef<TypeFamily>) -> Self {
let trait_ = from_chalk(db, trait_ref.trait_id); let trait_ = from_chalk(db, trait_ref.trait_id);
let substs = from_chalk(db, trait_ref.parameters); let substs = from_chalk(db, trait_ref.parameters);
TraitRef { trait_, substs } TraitRef { trait_, substs }
} }
} }
impl ToChalk for TraitId { impl ToChalk for hir_def::TraitId {
type Chalk = chalk_ir::TraitId; type Chalk = TraitId;
fn to_chalk(self, _db: &impl HirDatabase) -> chalk_ir::TraitId { fn to_chalk(self, _db: &impl HirDatabase) -> TraitId {
chalk_ir::TraitId(id_to_chalk(self)) chalk_ir::TraitId(self.as_intern_id())
} }
fn from_chalk(_db: &impl HirDatabase, trait_id: chalk_ir::TraitId) -> TraitId { fn from_chalk(_db: &impl HirDatabase, trait_id: TraitId) -> hir_def::TraitId {
id_from_chalk(trait_id.0) InternKey::from_intern_id(trait_id.0)
} }
} }
impl ToChalk for TypeCtor { impl ToChalk for TypeCtor {
type Chalk = chalk_ir::StructId; type Chalk = TypeName<TypeFamily>;
fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::StructId { fn to_chalk(self, db: &impl HirDatabase) -> TypeName<TypeFamily> {
db.intern_type_ctor(self).into() match self {
TypeCtor::AssociatedType(type_alias) => {
let type_id = type_alias.to_chalk(db);
TypeName::AssociatedType(type_id)
}
_ => {
// other TypeCtors get interned and turned into a chalk StructId
let struct_id = db.intern_type_ctor(self).into();
TypeName::Struct(struct_id)
}
}
} }
fn from_chalk(db: &impl HirDatabase, struct_id: chalk_ir::StructId) -> TypeCtor { fn from_chalk(db: &impl HirDatabase, type_name: TypeName<TypeFamily>) -> TypeCtor {
db.lookup_intern_type_ctor(struct_id.into()) match type_name {
TypeName::Struct(struct_id) => db.lookup_intern_type_ctor(struct_id.into()),
TypeName::AssociatedType(type_id) => TypeCtor::AssociatedType(from_chalk(db, type_id)),
TypeName::Error => {
// this should not be reached, since we don't represent TypeName::Error with TypeCtor
unreachable!()
}
}
} }
} }
impl ToChalk for Impl { impl ToChalk for Impl {
type Chalk = chalk_ir::ImplId; type Chalk = ImplId;
fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::ImplId { fn to_chalk(self, db: &impl HirDatabase) -> ImplId {
db.intern_chalk_impl(self).into() db.intern_chalk_impl(self).into()
} }
fn from_chalk(db: &impl HirDatabase, impl_id: chalk_ir::ImplId) -> Impl { fn from_chalk(db: &impl HirDatabase, impl_id: ImplId) -> Impl {
db.lookup_intern_chalk_impl(impl_id.into()) db.lookup_intern_chalk_impl(impl_id.into())
} }
} }
impl ToChalk for TypeAliasId { impl ToChalk for TypeAliasId {
type Chalk = chalk_ir::TypeId; type Chalk = AssocTypeId;
fn to_chalk(self, _db: &impl HirDatabase) -> chalk_ir::TypeId { fn to_chalk(self, _db: &impl HirDatabase) -> AssocTypeId {
chalk_ir::TypeId(id_to_chalk(self)) chalk_ir::AssocTypeId(self.as_intern_id())
} }
fn from_chalk(_db: &impl HirDatabase, type_alias_id: chalk_ir::TypeId) -> TypeAliasId { fn from_chalk(_db: &impl HirDatabase, type_alias_id: AssocTypeId) -> TypeAliasId {
id_from_chalk(type_alias_id.0) InternKey::from_intern_id(type_alias_id.0)
} }
} }
impl ToChalk for AssocTyValue { impl ToChalk for AssocTyValue {
type Chalk = chalk_rust_ir::AssociatedTyValueId; type Chalk = AssociatedTyValueId;
fn to_chalk(self, db: &impl HirDatabase) -> chalk_rust_ir::AssociatedTyValueId { fn to_chalk(self, db: &impl HirDatabase) -> AssociatedTyValueId {
db.intern_assoc_ty_value(self).into() db.intern_assoc_ty_value(self).into()
} }
fn from_chalk( fn from_chalk(db: &impl HirDatabase, assoc_ty_value_id: AssociatedTyValueId) -> AssocTyValue {
db: &impl HirDatabase,
assoc_ty_value_id: chalk_rust_ir::AssociatedTyValueId,
) -> AssocTyValue {
db.lookup_intern_assoc_ty_value(assoc_ty_value_id.into()) db.lookup_intern_assoc_ty_value(assoc_ty_value_id.into())
} }
} }
impl ToChalk for GenericPredicate { impl ToChalk for GenericPredicate {
type Chalk = chalk_ir::QuantifiedWhereClause<ChalkIr>; type Chalk = chalk_ir::QuantifiedWhereClause<TypeFamily>;
fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::QuantifiedWhereClause<ChalkIr> { fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::QuantifiedWhereClause<TypeFamily> {
match self { match self {
GenericPredicate::Implemented(trait_ref) => { GenericPredicate::Implemented(trait_ref) => {
make_binders(chalk_ir::WhereClause::Implemented(trait_ref.to_chalk(db)), 0) make_binders(chalk_ir::WhereClause::Implemented(trait_ref.to_chalk(db)), 0)
@ -246,26 +323,16 @@ impl ToChalk for GenericPredicate {
}), }),
0, 0,
), ),
GenericPredicate::Error => { GenericPredicate::Error => panic!("tried passing GenericPredicate::Error to Chalk"),
let impossible_trait_ref = chalk_ir::TraitRef {
trait_id: UNKNOWN_TRAIT,
parameters: vec![Ty::Unknown.to_chalk(db).cast()],
};
make_binders(chalk_ir::WhereClause::Implemented(impossible_trait_ref), 0)
}
} }
} }
fn from_chalk( fn from_chalk(
db: &impl HirDatabase, db: &impl HirDatabase,
where_clause: chalk_ir::QuantifiedWhereClause<ChalkIr>, where_clause: chalk_ir::QuantifiedWhereClause<TypeFamily>,
) -> GenericPredicate { ) -> GenericPredicate {
match where_clause.value { match where_clause.value {
chalk_ir::WhereClause::Implemented(tr) => { chalk_ir::WhereClause::Implemented(tr) => {
if tr.trait_id == UNKNOWN_TRAIT {
// FIXME we need an Error enum on the Chalk side to avoid this
return GenericPredicate::Error;
}
GenericPredicate::Implemented(from_chalk(db, tr)) GenericPredicate::Implemented(from_chalk(db, tr))
} }
chalk_ir::WhereClause::ProjectionEq(projection_eq) => { chalk_ir::WhereClause::ProjectionEq(projection_eq) => {
@ -278,9 +345,9 @@ impl ToChalk for GenericPredicate {
} }
impl ToChalk for ProjectionTy { impl ToChalk for ProjectionTy {
type Chalk = chalk_ir::ProjectionTy<ChalkIr>; type Chalk = chalk_ir::ProjectionTy<TypeFamily>;
fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::ProjectionTy<ChalkIr> { fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::ProjectionTy<TypeFamily> {
chalk_ir::ProjectionTy { chalk_ir::ProjectionTy {
associated_ty_id: self.associated_ty.to_chalk(db), associated_ty_id: self.associated_ty.to_chalk(db),
parameters: self.parameters.to_chalk(db), parameters: self.parameters.to_chalk(db),
@ -289,7 +356,7 @@ impl ToChalk for ProjectionTy {
fn from_chalk( fn from_chalk(
db: &impl HirDatabase, db: &impl HirDatabase,
projection_ty: chalk_ir::ProjectionTy<ChalkIr>, projection_ty: chalk_ir::ProjectionTy<TypeFamily>,
) -> ProjectionTy { ) -> ProjectionTy {
ProjectionTy { ProjectionTy {
associated_ty: from_chalk(db, projection_ty.associated_ty_id), associated_ty: from_chalk(db, projection_ty.associated_ty_id),
@ -299,31 +366,31 @@ impl ToChalk for ProjectionTy {
} }
impl ToChalk for super::ProjectionPredicate { impl ToChalk for super::ProjectionPredicate {
type Chalk = chalk_ir::Normalize<ChalkIr>; type Chalk = chalk_ir::Normalize<TypeFamily>;
fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::Normalize<ChalkIr> { fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::Normalize<TypeFamily> {
chalk_ir::Normalize { chalk_ir::Normalize {
projection: self.projection_ty.to_chalk(db), projection: self.projection_ty.to_chalk(db),
ty: self.ty.to_chalk(db), ty: self.ty.to_chalk(db),
} }
} }
fn from_chalk(_db: &impl HirDatabase, _normalize: chalk_ir::Normalize<ChalkIr>) -> Self { fn from_chalk(_db: &impl HirDatabase, _normalize: chalk_ir::Normalize<TypeFamily>) -> Self {
unimplemented!() unimplemented!()
} }
} }
impl ToChalk for Obligation { impl ToChalk for Obligation {
type Chalk = chalk_ir::DomainGoal<ChalkIr>; type Chalk = chalk_ir::DomainGoal<TypeFamily>;
fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::DomainGoal<ChalkIr> { fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::DomainGoal<TypeFamily> {
match self { match self {
Obligation::Trait(tr) => tr.to_chalk(db).cast(), Obligation::Trait(tr) => tr.to_chalk(db).cast(),
Obligation::Projection(pr) => pr.to_chalk(db).cast(), Obligation::Projection(pr) => pr.to_chalk(db).cast(),
} }
} }
fn from_chalk(_db: &impl HirDatabase, _goal: chalk_ir::DomainGoal<ChalkIr>) -> Self { fn from_chalk(_db: &impl HirDatabase, _goal: chalk_ir::DomainGoal<TypeFamily>) -> Self {
unimplemented!() unimplemented!()
} }
} }
@ -347,16 +414,17 @@ where
} }
impl ToChalk for Arc<super::TraitEnvironment> { impl ToChalk for Arc<super::TraitEnvironment> {
type Chalk = chalk_ir::Environment<ChalkIr>; type Chalk = chalk_ir::Environment<TypeFamily>;
fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::Environment<ChalkIr> { fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::Environment<TypeFamily> {
let mut clauses = Vec::new(); let mut clauses = Vec::new();
for pred in &self.predicates { for pred in &self.predicates {
if pred.is_error() { if pred.is_error() {
// for env, we just ignore errors // for env, we just ignore errors
continue; continue;
} }
let program_clause: chalk_ir::ProgramClause<ChalkIr> = pred.clone().to_chalk(db).cast(); let program_clause: chalk_ir::ProgramClause<TypeFamily> =
pred.clone().to_chalk(db).cast();
clauses.push(program_clause.into_from_env_clause()); clauses.push(program_clause.into_from_env_clause());
} }
chalk_ir::Environment::new().add_clauses(clauses) chalk_ir::Environment::new().add_clauses(clauses)
@ -364,7 +432,7 @@ impl ToChalk for Arc<super::TraitEnvironment> {
fn from_chalk( fn from_chalk(
_db: &impl HirDatabase, _db: &impl HirDatabase,
_env: chalk_ir::Environment<ChalkIr>, _env: chalk_ir::Environment<TypeFamily>,
) -> Arc<super::TraitEnvironment> { ) -> Arc<super::TraitEnvironment> {
unimplemented!() unimplemented!()
} }
@ -372,7 +440,7 @@ impl ToChalk for Arc<super::TraitEnvironment> {
impl<T: ToChalk> ToChalk for super::InEnvironment<T> impl<T: ToChalk> ToChalk for super::InEnvironment<T>
where where
T::Chalk: chalk_ir::family::HasTypeFamily<TypeFamily = ChalkIr>, T::Chalk: chalk_ir::family::HasTypeFamily<TypeFamily = TypeFamily>,
{ {
type Chalk = chalk_ir::InEnvironment<T::Chalk>; type Chalk = chalk_ir::InEnvironment<T::Chalk>;
@ -395,9 +463,9 @@ where
} }
impl ToChalk for builtin::BuiltinImplData { impl ToChalk for builtin::BuiltinImplData {
type Chalk = chalk_rust_ir::ImplDatum<ChalkIr>; type Chalk = ImplDatum;
fn to_chalk(self, db: &impl HirDatabase) -> chalk_rust_ir::ImplDatum<ChalkIr> { fn to_chalk(self, db: &impl HirDatabase) -> ImplDatum {
let impl_type = chalk_rust_ir::ImplType::External; let impl_type = chalk_rust_ir::ImplType::External;
let where_clauses = self.where_clauses.into_iter().map(|w| w.to_chalk(db)).collect(); let where_clauses = self.where_clauses.into_iter().map(|w| w.to_chalk(db)).collect();
@ -413,15 +481,15 @@ impl ToChalk for builtin::BuiltinImplData {
} }
} }
fn from_chalk(_db: &impl HirDatabase, _data: chalk_rust_ir::ImplDatum<ChalkIr>) -> Self { fn from_chalk(_db: &impl HirDatabase, _data: ImplDatum) -> Self {
unimplemented!() unimplemented!()
} }
} }
impl ToChalk for builtin::BuiltinImplAssocTyValueData { impl ToChalk for builtin::BuiltinImplAssocTyValueData {
type Chalk = chalk_rust_ir::AssociatedTyValue<ChalkIr>; type Chalk = AssociatedTyValue;
fn to_chalk(self, db: &impl HirDatabase) -> chalk_rust_ir::AssociatedTyValue<ChalkIr> { fn to_chalk(self, db: &impl HirDatabase) -> AssociatedTyValue {
let value_bound = chalk_rust_ir::AssociatedTyValueBound { ty: self.value.to_chalk(db) }; let value_bound = chalk_rust_ir::AssociatedTyValueBound { ty: self.value.to_chalk(db) };
chalk_rust_ir::AssociatedTyValue { chalk_rust_ir::AssociatedTyValue {
@ -433,7 +501,7 @@ impl ToChalk for builtin::BuiltinImplAssocTyValueData {
fn from_chalk( fn from_chalk(
_db: &impl HirDatabase, _db: &impl HirDatabase,
_data: chalk_rust_ir::AssociatedTyValue<ChalkIr>, _data: AssociatedTyValue,
) -> builtin::BuiltinImplAssocTyValueData { ) -> builtin::BuiltinImplAssocTyValueData {
unimplemented!() unimplemented!()
} }
@ -450,46 +518,46 @@ fn convert_where_clauses(
db: &impl HirDatabase, db: &impl HirDatabase,
def: GenericDefId, def: GenericDefId,
substs: &Substs, substs: &Substs,
) -> Vec<chalk_ir::QuantifiedWhereClause<ChalkIr>> { ) -> Vec<chalk_ir::QuantifiedWhereClause<TypeFamily>> {
let generic_predicates = db.generic_predicates(def); let generic_predicates = db.generic_predicates(def);
let mut result = Vec::with_capacity(generic_predicates.len()); let mut result = Vec::with_capacity(generic_predicates.len());
for pred in generic_predicates.iter() { for pred in generic_predicates.iter() {
if pred.is_error() { if pred.is_error() {
// HACK: Return just the single predicate (which is always false // skip errored predicates completely
// anyway), otherwise Chalk can easily get into slow situations continue;
return vec![pred.clone().subst(substs).to_chalk(db)];
} }
result.push(pred.clone().subst(substs).to_chalk(db)); result.push(pred.clone().subst(substs).to_chalk(db));
} }
result result
} }
impl<'a, DB> chalk_solve::RustIrDatabase<ChalkIr> for ChalkContext<'a, DB> impl<'a, DB> chalk_solve::RustIrDatabase<TypeFamily> for ChalkContext<'a, DB>
where where
DB: HirDatabase, DB: HirDatabase,
{ {
fn associated_ty_data(&self, id: TypeId) -> Arc<AssociatedTyDatum<ChalkIr>> { fn associated_ty_data(&self, id: AssocTypeId) -> Arc<AssociatedTyDatum> {
self.db.associated_ty_data(id) self.db.associated_ty_data(id)
} }
fn trait_datum(&self, trait_id: chalk_ir::TraitId) -> Arc<TraitDatum<ChalkIr>> { fn trait_datum(&self, trait_id: TraitId) -> Arc<TraitDatum> {
self.db.trait_datum(self.krate, trait_id) self.db.trait_datum(self.krate, trait_id)
} }
fn struct_datum(&self, struct_id: chalk_ir::StructId) -> Arc<StructDatum<ChalkIr>> { fn struct_datum(&self, struct_id: StructId) -> Arc<StructDatum> {
self.db.struct_datum(self.krate, struct_id) self.db.struct_datum(self.krate, struct_id)
} }
fn impl_datum(&self, impl_id: chalk_ir::ImplId) -> Arc<ImplDatum<ChalkIr>> { fn impl_datum(&self, impl_id: ImplId) -> Arc<ImplDatum> {
self.db.impl_datum(self.krate, impl_id) self.db.impl_datum(self.krate, impl_id)
} }
fn impls_for_trait( fn impls_for_trait(
&self, &self,
trait_id: chalk_ir::TraitId, trait_id: TraitId,
parameters: &[Parameter<ChalkIr>], parameters: &[Parameter<TypeFamily>],
) -> Vec<chalk_ir::ImplId> { ) -> Vec<ImplId> {
debug!("impls_for_trait {:?}", trait_id); debug!("impls_for_trait {:?}", trait_id);
if trait_id == UNKNOWN_TRAIT { let trait_: hir_def::TraitId = from_chalk(self.db, trait_id);
return Vec::new();
} // Note: Since we're using impls_for_trait, only impls where the trait
let trait_: TraitId = from_chalk(self.db, trait_id); // can be resolved should ever reach Chalk. `impl_datum` relies on that
// and will panic if the trait can't be resolved.
let mut result: Vec<_> = self let mut result: Vec<_> = self
.db .db
.impls_for_trait(self.krate, trait_.into()) .impls_for_trait(self.krate, trait_.into())
@ -508,39 +576,32 @@ where
debug!("impls_for_trait returned {} impls", result.len()); debug!("impls_for_trait returned {} impls", result.len());
result result
} }
fn impl_provided_for( fn impl_provided_for(&self, auto_trait_id: TraitId, struct_id: StructId) -> bool {
&self,
auto_trait_id: chalk_ir::TraitId,
struct_id: chalk_ir::StructId,
) -> bool {
debug!("impl_provided_for {:?}, {:?}", auto_trait_id, struct_id); debug!("impl_provided_for {:?}, {:?}", auto_trait_id, struct_id);
false // FIXME false // FIXME
} }
fn type_name(&self, _id: TypeKindId) -> Identifier { fn associated_ty_value(&self, id: AssociatedTyValueId) -> Arc<AssociatedTyValue> {
unimplemented!()
}
fn associated_ty_value(
&self,
id: chalk_rust_ir::AssociatedTyValueId,
) -> Arc<AssociatedTyValue<ChalkIr>> {
self.db.associated_ty_value(self.krate.into(), id) self.db.associated_ty_value(self.krate.into(), id)
} }
fn custom_clauses(&self) -> Vec<chalk_ir::ProgramClause<ChalkIr>> { fn custom_clauses(&self) -> Vec<chalk_ir::ProgramClause<TypeFamily>> {
vec![] vec![]
} }
fn local_impls_to_coherence_check( fn local_impls_to_coherence_check(&self, _trait_id: TraitId) -> Vec<ImplId> {
&self,
_trait_id: chalk_ir::TraitId,
) -> Vec<chalk_ir::ImplId> {
// We don't do coherence checking (yet) // We don't do coherence checking (yet)
unimplemented!() unimplemented!()
} }
fn as_struct_id(&self, id: &TypeName<TypeFamily>) -> Option<StructId> {
match id {
TypeName::Struct(struct_id) => Some(*struct_id),
_ => None,
}
}
} }
pub(crate) fn associated_ty_data_query( pub(crate) fn associated_ty_data_query(
db: &impl HirDatabase, db: &impl HirDatabase,
id: TypeId, id: AssocTypeId,
) -> Arc<AssociatedTyDatum<ChalkIr>> { ) -> Arc<AssociatedTyDatum> {
debug!("associated_ty_data {:?}", id); debug!("associated_ty_data {:?}", id);
let type_alias: TypeAliasId = from_chalk(db, id); let type_alias: TypeAliasId = from_chalk(db, id);
let trait_ = match type_alias.lookup(db).container { let trait_ = match type_alias.lookup(db).container {
@ -565,28 +626,10 @@ pub(crate) fn associated_ty_data_query(
pub(crate) fn trait_datum_query( pub(crate) fn trait_datum_query(
db: &impl HirDatabase, db: &impl HirDatabase,
krate: CrateId, krate: CrateId,
trait_id: chalk_ir::TraitId, trait_id: TraitId,
) -> Arc<TraitDatum<ChalkIr>> { ) -> Arc<TraitDatum> {
debug!("trait_datum {:?}", trait_id); debug!("trait_datum {:?}", trait_id);
if trait_id == UNKNOWN_TRAIT { let trait_: hir_def::TraitId = from_chalk(db, trait_id);
let trait_datum_bound = chalk_rust_ir::TraitDatumBound { where_clauses: Vec::new() };
let flags = chalk_rust_ir::TraitFlags {
auto: false,
marker: false,
upstream: true,
fundamental: false,
non_enumerable: true,
coinductive: false,
};
return Arc::new(TraitDatum {
id: trait_id,
binders: make_binders(trait_datum_bound, 1),
flags,
associated_ty_ids: vec![],
});
}
let trait_: TraitId = from_chalk(db, trait_id);
let trait_data = db.trait_data(trait_); let trait_data = db.trait_data(trait_);
debug!("trait {:?} = {:?}", trait_id, trait_data.name); debug!("trait {:?} = {:?}", trait_id, trait_data.name);
let generic_params = generics(db, trait_.into()); let generic_params = generics(db, trait_.into());
@ -616,10 +659,10 @@ pub(crate) fn trait_datum_query(
pub(crate) fn struct_datum_query( pub(crate) fn struct_datum_query(
db: &impl HirDatabase, db: &impl HirDatabase,
krate: CrateId, krate: CrateId,
struct_id: chalk_ir::StructId, struct_id: StructId,
) -> Arc<StructDatum<ChalkIr>> { ) -> Arc<StructDatum> {
debug!("struct_datum {:?}", struct_id); debug!("struct_datum {:?}", struct_id);
let type_ctor: TypeCtor = from_chalk(db, struct_id); let type_ctor: TypeCtor = from_chalk(db, TypeName::Struct(struct_id));
debug!("struct {:?} = {:?}", struct_id, type_ctor); debug!("struct {:?} = {:?}", struct_id, type_ctor);
let num_params = type_ctor.num_ty_params(db); let num_params = type_ctor.num_ty_params(db);
let upstream = type_ctor.krate(db) != Some(krate); let upstream = type_ctor.krate(db) != Some(krate);
@ -648,25 +691,27 @@ pub(crate) fn struct_datum_query(
pub(crate) fn impl_datum_query( pub(crate) fn impl_datum_query(
db: &impl HirDatabase, db: &impl HirDatabase,
krate: CrateId, krate: CrateId,
impl_id: chalk_ir::ImplId, impl_id: ImplId,
) -> Arc<ImplDatum<ChalkIr>> { ) -> Arc<ImplDatum> {
let _p = ra_prof::profile("impl_datum"); let _p = ra_prof::profile("impl_datum");
debug!("impl_datum {:?}", impl_id); debug!("impl_datum {:?}", impl_id);
let impl_: Impl = from_chalk(db, impl_id); let impl_: Impl = from_chalk(db, impl_id);
match impl_ { match impl_ {
Impl::ImplBlock(impl_block) => impl_block_datum(db, krate, impl_id, impl_block), Impl::ImplBlock(impl_block) => impl_block_datum(db, krate, impl_id, impl_block),
_ => builtin::impl_datum(db, krate, impl_).map(|d| Arc::new(d.to_chalk(db))), _ => Arc::new(builtin::impl_datum(db, krate, impl_).to_chalk(db)),
} }
.unwrap_or_else(invalid_impl_datum)
} }
fn impl_block_datum( fn impl_block_datum(
db: &impl HirDatabase, db: &impl HirDatabase,
krate: CrateId, krate: CrateId,
chalk_id: chalk_ir::ImplId, chalk_id: ImplId,
impl_id: ImplId, impl_id: hir_def::ImplId,
) -> Option<Arc<ImplDatum<ChalkIr>>> { ) -> Arc<ImplDatum> {
let trait_ref = db.impl_trait(impl_id)?; 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");
let impl_data = db.impl_data(impl_id); let impl_data = db.impl_data(impl_id);
let generic_params = generics(db, impl_id.into()); let generic_params = generics(db, impl_id.into());
@ -718,29 +763,14 @@ fn impl_block_datum(
polarity, polarity,
associated_ty_value_ids, associated_ty_value_ids,
}; };
Some(Arc::new(impl_datum))
}
fn invalid_impl_datum() -> Arc<ImplDatum<ChalkIr>> {
let trait_ref = chalk_ir::TraitRef {
trait_id: UNKNOWN_TRAIT,
parameters: vec![chalk_ir::TyData::BoundVar(0).cast().intern().cast()],
};
let impl_datum_bound = chalk_rust_ir::ImplDatumBound { trait_ref, where_clauses: Vec::new() };
let impl_datum = ImplDatum {
binders: make_binders(impl_datum_bound, 1),
impl_type: chalk_rust_ir::ImplType::External,
polarity: chalk_rust_ir::Polarity::Positive,
associated_ty_value_ids: Vec::new(),
};
Arc::new(impl_datum) Arc::new(impl_datum)
} }
pub(crate) fn associated_ty_value_query( pub(crate) fn associated_ty_value_query(
db: &impl HirDatabase, db: &impl HirDatabase,
krate: CrateId, krate: CrateId,
id: chalk_rust_ir::AssociatedTyValueId, id: AssociatedTyValueId,
) -> Arc<chalk_rust_ir::AssociatedTyValue<ChalkIr>> { ) -> Arc<AssociatedTyValue> {
let data: AssocTyValue = from_chalk(db, id); let data: AssocTyValue = from_chalk(db, id);
match data { match data {
AssocTyValue::TypeAlias(type_alias) => { AssocTyValue::TypeAlias(type_alias) => {
@ -754,7 +784,7 @@ fn type_alias_associated_ty_value(
db: &impl HirDatabase, db: &impl HirDatabase,
_krate: CrateId, _krate: CrateId,
type_alias: TypeAliasId, type_alias: TypeAliasId,
) -> Arc<AssociatedTyValue<ChalkIr>> { ) -> Arc<AssociatedTyValue> {
let type_alias_data = db.type_alias_data(type_alias); let type_alias_data = db.type_alias_data(type_alias);
let impl_id = match type_alias.lookup(db).container { let impl_id = match type_alias.lookup(db).container {
AssocContainerId::ImplId(it) => it, AssocContainerId::ImplId(it) => it,
@ -786,27 +816,27 @@ fn id_to_chalk<T: InternKey>(salsa_id: T) -> chalk_ir::RawId {
chalk_ir::RawId { index: salsa_id.as_intern_id().as_u32() } chalk_ir::RawId { index: salsa_id.as_intern_id().as_u32() }
} }
impl From<chalk_ir::StructId> for crate::TypeCtorId { impl From<StructId> for crate::TypeCtorId {
fn from(struct_id: chalk_ir::StructId) -> Self { fn from(struct_id: StructId) -> Self {
id_from_chalk(struct_id.0) InternKey::from_intern_id(struct_id.0)
} }
} }
impl From<crate::TypeCtorId> for chalk_ir::StructId { impl From<crate::TypeCtorId> for StructId {
fn from(type_ctor_id: crate::TypeCtorId) -> Self { fn from(type_ctor_id: crate::TypeCtorId) -> Self {
chalk_ir::StructId(id_to_chalk(type_ctor_id)) chalk_ir::StructId(type_ctor_id.as_intern_id())
} }
} }
impl From<chalk_ir::ImplId> for crate::traits::GlobalImplId { impl From<ImplId> for crate::traits::GlobalImplId {
fn from(impl_id: chalk_ir::ImplId) -> Self { fn from(impl_id: ImplId) -> Self {
id_from_chalk(impl_id.0) InternKey::from_intern_id(impl_id.0)
} }
} }
impl From<crate::traits::GlobalImplId> for chalk_ir::ImplId { impl From<crate::traits::GlobalImplId> for ImplId {
fn from(impl_id: crate::traits::GlobalImplId) -> Self { fn from(impl_id: crate::traits::GlobalImplId) -> Self {
chalk_ir::ImplId(id_to_chalk(impl_id)) chalk_ir::ImplId(impl_id.as_intern_id())
} }
} }