language-servers/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-11-13 17:35:21 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Merge pull request #20609 from ChayimFriedman2/update-rustc
Some checks failed
metrics / build_metrics (push) Has been cancelled
Details
rustdoc / rustdoc (push) Has been cancelled
Details
metrics / other_metrics (diesel-1.4.8) (push) Has been cancelled
Details
metrics / other_metrics (hyper-0.14.18) (push) Has been cancelled
Details
metrics / other_metrics (ripgrep-13.0.0) (push) Has been cancelled
Details
metrics / other_metrics (self) (push) Has been cancelled
Details
metrics / other_metrics (webrender-2022) (push) Has been cancelled
Details
metrics / generate_final_metrics (push) Has been cancelled
Details

Browse source 
internal: Upgrade rustc crates
This commit is contained in:
Shoyu Vanilla (Flint) 2025-09-05 03:18:14 +00:00 • committed by GitHub
commit a53b44412d
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
24 changed files with 447 additions and 580 deletions
Download patch file Download diff file Expand all files Collapse all files

77
Cargo.lock generated
View file

@ -1360,7 +1360,7 @@ dependencies = [
"expect-test", "expect-test",
"intern", "intern",
"parser", "parser",
"ra-ap-rustc_lexer 0.123.0", "ra-ap-rustc_lexer",
"rustc-hash 2.1.1", "rustc-hash 2.1.1",
"smallvec", "smallvec",
"span", "span",
@ -1596,8 +1596,8 @@ dependencies = [
"drop_bomb", "drop_bomb",
"edition", "edition",
"expect-test", "expect-test",
"ra-ap-rustc_lexer 0.123.0", "ra-ap-rustc_lexer",
"rustc-literal-escaper", "rustc-literal-escaper 0.0.4",
"stdx", "stdx",
"tracing", "tracing",
] ]
@ -1717,7 +1717,7 @@ dependencies = [
"object", "object",
"paths", "paths",
"proc-macro-test", "proc-macro-test",
"ra-ap-rustc_lexer 0.123.0", "ra-ap-rustc_lexer",
"span", "span",
"syntax-bridge", "syntax-bridge",
"temp-dir", "temp-dir",
@ -1863,9 +1863,9 @@ dependencies = [
[[package]] [[package]]
name = "ra-ap-rustc_abi" name = "ra-ap-rustc_abi"
version = "0.123.0" version = "0.126.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f18c877575c259d127072e9bfc41d985202262fb4d6bfdae3d1252147c2562c2" checksum = "0c6789d94fb3e6e30d62f55e99a321ba63484a8bb3b4ead338687c9ddc282d28"
dependencies = [ dependencies = [
"bitflags 2.9.1", "bitflags 2.9.1",
"ra-ap-rustc_hashes", "ra-ap-rustc_hashes",
@ -1875,24 +1875,24 @@ dependencies = [
[[package]] [[package]]
name = "ra-ap-rustc_ast_ir" name = "ra-ap-rustc_ast_ir"
version = "0.123.0" version = "0.126.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "87cc17e8ce797f2a8d03b838fbf166749b876164432ce81e37d283bf69e3cf80" checksum = "aaab80bda0f05e9842e3afb7779b0bad0a4b54e0f7ba6deb5705dcf86482811d"
[[package]] [[package]]
name = "ra-ap-rustc_hashes" name = "ra-ap-rustc_hashes"
version = "0.123.0" version = "0.126.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2439ed1df3472443133b66949f81080dff88089b42f825761455463709ee1cad" checksum = "64bd405e538102b5f699241794b2eefee39d5414c0e4bc72435e91430c51f905"
dependencies = [ dependencies = [
"rustc-stable-hash", "rustc-stable-hash",
] ]
[[package]] [[package]]
name = "ra-ap-rustc_index" name = "ra-ap-rustc_index"
version = "0.123.0" version = "0.126.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "57a24fe0be21be1f8ebc21dcb40129214fb4cefb0f2753f3d46b6dbe656a1a45" checksum = "521621e271aa03b8433dad5981838278d6cfd7d2d8c9f4eb6d427f1d671f90fc"
dependencies = [ dependencies = [
"ra-ap-rustc_index_macros", "ra-ap-rustc_index_macros",
"smallvec", "smallvec",
@ -1900,9 +1900,9 @@ dependencies = [
[[package]] [[package]]
name = "ra-ap-rustc_index_macros" name = "ra-ap-rustc_index_macros"
version = "0.123.0" version = "0.126.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "844a27ddcad0116facae2df8e741fd788662cf93dc13029cd864f2b8013b81f9" checksum = "245e30f2e1fef258913cc548b36f575549c8af31cbc4649929d21deda96ceeb7"
dependencies = [ dependencies = [
"proc-macro2", "proc-macro2",
"quote", "quote",
@ -1911,20 +1911,9 @@ dependencies = [
[[package]] [[package]]
name = "ra-ap-rustc_lexer" name = "ra-ap-rustc_lexer"
version = "0.121.0" version = "0.126.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "22944e31fb91e9b3e75bcbc91e37d958b8c0825a6160927f2856831d2ce83b36" checksum = "a82681f924500e888c860e60ed99e9bf702a219a69374f59116c4261525a2157"
dependencies = [
"memchr",
"unicode-properties",
"unicode-xid",
]
[[package]]
name = "ra-ap-rustc_lexer"
version = "0.123.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2b734cfcb577d09877799a22742f1bd398be6c00bc428d9de56d48d11ece5771"
dependencies = [ dependencies = [
"memchr", "memchr",
"unicode-properties", "unicode-properties",
@ -1933,9 +1922,9 @@ dependencies = [
[[package]] [[package]]
name = "ra-ap-rustc_next_trait_solver" name = "ra-ap-rustc_next_trait_solver"
version = "0.123.0" version = "0.126.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "14f7dfbdf1d045ff4e385e1efdfc3799379895e9c3f3b9b379a0bef4cb238441" checksum = "0c9ce51f2431fbdc7fabd2d957522b6e27f41f68ec2af74b52a6f4116352ce1a"
dependencies = [ dependencies = [
"derive-where", "derive-where",
"ra-ap-rustc_index", "ra-ap-rustc_index",
@ -1946,19 +1935,19 @@ dependencies = [
[[package]] [[package]]
name = "ra-ap-rustc_parse_format" name = "ra-ap-rustc_parse_format"
version = "0.121.0" version = "0.126.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "81057891bc2063ad9e353f29462fbc47a0f5072560af34428ae9313aaa5e9d97" checksum = "adc85ef3fdb6c084bde84857d8948dc66b752129dc8417a8614ce490e99a143f"
dependencies = [ dependencies = [
"ra-ap-rustc_lexer 0.121.0", "ra-ap-rustc_lexer",
"rustc-literal-escaper", "rustc-literal-escaper 0.0.5",
] ]
[[package]] [[package]]
name = "ra-ap-rustc_pattern_analysis" name = "ra-ap-rustc_pattern_analysis"
version = "0.123.0" version = "0.126.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "75b0ee1f059b9dea0818c6c7267478926eee95ba4c7dcf89c8db32fa165d3904" checksum = "3cd81eccf33d9528905d4e5abaa254b3129a6405d6c5f123fed9b73a3d217f35"
dependencies = [ dependencies = [
"ra-ap-rustc_index", "ra-ap-rustc_index",
"rustc-hash 2.1.1", "rustc-hash 2.1.1",
@ -1969,9 +1958,9 @@ dependencies = [
[[package]] [[package]]
name = "ra-ap-rustc_type_ir" name = "ra-ap-rustc_type_ir"
version = "0.123.0" version = "0.126.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0bc59fb10a922c38a24cb8a1494f799b0af30bd041acbea689378d3bf330534b" checksum = "11cb0da02853698d9c89e1d1c01657b9969752befd56365e8899d4310e52b373"
dependencies = [ dependencies = [
"bitflags 2.9.1", "bitflags 2.9.1",
"derive-where", "derive-where",
@ -1988,9 +1977,9 @@ dependencies = [
[[package]] [[package]]
name = "ra-ap-rustc_type_ir_macros" name = "ra-ap-rustc_type_ir_macros"
version = "0.123.0" version = "0.126.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "58878914b6dac7499baeecc8dbb4b9d9dda88030e4ab90cd3b4e87523fbedafe" checksum = "ffc93adeb52c483ede13bee6680466458218243ab479c04fb71bb53925a6e0ff"
dependencies = [ dependencies = [
"proc-macro2", "proc-macro2",
"quote", "quote",
@ -2140,6 +2129,12 @@ version = "0.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ab03008eb631b703dd16978282ae36c73282e7922fe101a4bd072a40ecea7b8b" checksum = "ab03008eb631b703dd16978282ae36c73282e7922fe101a4bd072a40ecea7b8b"
[[package]]
name = "rustc-literal-escaper"
version = "0.0.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e4ee29da77c5a54f42697493cd4c9b9f31b74df666a6c04dfc4fde77abe0438b"
[[package]] [[package]]
name = "rustc-stable-hash" name = "rustc-stable-hash"
version = "0.1.2" version = "0.1.2"
@ -2445,7 +2440,7 @@ dependencies = [
"rayon", "rayon",
"rowan", "rowan",
"rustc-hash 2.1.1", "rustc-hash 2.1.1",
"rustc-literal-escaper", "rustc-literal-escaper 0.0.4",
"rustc_apfloat", "rustc_apfloat",
"smol_str", "smol_str",
"stdx", "stdx",
@ -2773,7 +2768,7 @@ version = "0.0.0"
dependencies = [ dependencies = [
"arrayvec", "arrayvec",
"intern", "intern",
"ra-ap-rustc_lexer 0.123.0", "ra-ap-rustc_lexer",
"stdx", "stdx",
"text-size", "text-size",
] ]

16
Cargo.toml
View file

@ -89,14 +89,14 @@ vfs-notify = { path = "./crates/vfs-notify", version = "0.0.0" }
vfs = { path = "./crates/vfs", version = "0.0.0" } vfs = { path = "./crates/vfs", version = "0.0.0" }
edition = { path = "./crates/edition", version = "0.0.0" } edition = { path = "./crates/edition", version = "0.0.0" }
ra-ap-rustc_lexer = { version = "0.123", default-features = false } ra-ap-rustc_lexer = { version = "0.126", default-features = false }
ra-ap-rustc_parse_format = { version = "0.121", default-features = false } ra-ap-rustc_parse_format = { version = "0.126", default-features = false }
ra-ap-rustc_index = { version = "0.123", default-features = false } ra-ap-rustc_index = { version = "0.126", default-features = false }
ra-ap-rustc_abi = { version = "0.123", default-features = false } ra-ap-rustc_abi = { version = "0.126", default-features = false }
ra-ap-rustc_pattern_analysis = { version = "0.123", default-features = false } ra-ap-rustc_pattern_analysis = { version = "0.126", default-features = false }
ra-ap-rustc_ast_ir = { version = "0.123", default-features = false } ra-ap-rustc_ast_ir = { version = "0.126", default-features = false }
ra-ap-rustc_type_ir = { version = "0.123", default-features = false } ra-ap-rustc_type_ir = { version = "0.126", default-features = false }
ra-ap-rustc_next_trait_solver = { version = "0.123", default-features = false } ra-ap-rustc_next_trait_solver = { version = "0.126", default-features = false }
# local crates that aren't published to crates.io. These should not have versions. # local crates that aren't published to crates.io. These should not have versions.

12
crates/hir-ty/src/display.rs
View file

@ -737,7 +737,7 @@ impl<'db> HirDisplay for crate::next_solver::Const<'db> {
match self.kind() { match self.kind() {
rustc_type_ir::ConstKind::Placeholder(_) => write!(f, "<placeholder>"), rustc_type_ir::ConstKind::Placeholder(_) => write!(f, "<placeholder>"),
rustc_type_ir::ConstKind::Bound(db, bound_const) => { rustc_type_ir::ConstKind::Bound(db, bound_const) => {
write!(f, "?{}.{}", db.as_u32(), bound_const.as_u32()) write!(f, "?{}.{}", db.as_u32(), bound_const.var.as_u32())
} }
rustc_type_ir::ConstKind::Infer(..) => write!(f, "#c#"), rustc_type_ir::ConstKind::Infer(..) => write!(f, "#c#"),
rustc_type_ir::ConstKind::Param(param) => { rustc_type_ir::ConstKind::Param(param) => {
@ -1208,10 +1208,7 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
let contains_impl_fn_ns = |bounds: &[BoundExistentialPredicate<'_>]| { let contains_impl_fn_ns = |bounds: &[BoundExistentialPredicate<'_>]| {
bounds.iter().any(|bound| match bound.skip_binder() { bounds.iter().any(|bound| match bound.skip_binder() {
rustc_type_ir::ExistentialPredicate::Trait(trait_ref) => { rustc_type_ir::ExistentialPredicate::Trait(trait_ref) => {
let trait_ = match trait_ref.def_id { let trait_ = trait_ref.def_id.0;
SolverDefId::TraitId(id) => id,
_ => unreachable!(),
};
fn_traits(db, trait_).any(|it| it == trait_) fn_traits(db, trait_).any(|it| it == trait_)
} }
_ => false, _ => false,
@ -2217,10 +2214,7 @@ impl HirDisplay for TraitRef {
impl<'db> HirDisplay for crate::next_solver::TraitRef<'db> { impl<'db> HirDisplay for crate::next_solver::TraitRef<'db> {
fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> { fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
let trait_ = match self.def_id { let trait_ = self.def_id.0;
SolverDefId::TraitId(id) => id,
_ => unreachable!(),
};
f.start_location_link(trait_.into()); f.start_location_link(trait_.into());
write!(f, "{}", f.db.trait_signature(trait_).name.display(f.db, f.edition()))?; write!(f, "{}", f.db.trait_signature(trait_).name.display(f.db, f.edition()))?;
f.end_location_link(); f.end_location_link();

70
crates/hir-ty/src/dyn_compatibility.rs
View file

@ -2,12 +2,11 @@
use std::ops::ControlFlow; use std::ops::ControlFlow;
use hir_def::hir::generics::LocalTypeOrConstParamId;
use hir_def::{ use hir_def::{
AssocItemId, ConstId, CrateRootModuleId, FunctionId, GenericDefId, HasModule, TraitId, AssocItemId, ConstId, CrateRootModuleId, FunctionId, GenericDefId, HasModule, TraitId,
TypeAliasId, lang_item::LangItem, signatures::TraitFlags, TypeAliasId, TypeOrConstParamId, TypeParamId, hir::generics::LocalTypeOrConstParamId,
lang_item::LangItem, signatures::TraitFlags,
}; };
use hir_def::{TypeOrConstParamId, TypeParamId};
use intern::Symbol; use intern::Symbol;
use rustc_hash::FxHashSet; use rustc_hash::FxHashSet;
use rustc_type_ir::{ use rustc_type_ir::{
@ -22,7 +21,7 @@ use crate::{
db::{HirDatabase, InternedOpaqueTyId}, db::{HirDatabase, InternedOpaqueTyId},
lower_nextsolver::associated_ty_item_bounds, lower_nextsolver::associated_ty_item_bounds,
next_solver::{ next_solver::{
Clause, Clauses, DbInterner, GenericArgs, ParamEnv, SolverDefId, TraitPredicate, Clause, Clauses, DbInterner, GenericArgs, ParamEnv, SolverDefId, TraitPredicate, TraitRef,
TypingMode, infer::DbInternerInferExt, mk_param, TypingMode, infer::DbInternerInferExt, mk_param,
}, },
traits::next_trait_solve_in_ctxt, traits::next_trait_solve_in_ctxt,
@ -56,16 +55,12 @@ pub fn dyn_compatibility(
trait_: TraitId, trait_: TraitId,
) -> Option<DynCompatibilityViolation> { ) -> Option<DynCompatibilityViolation> {
let interner = DbInterner::new_with(db, Some(trait_.krate(db)), None); let interner = DbInterner::new_with(db, Some(trait_.krate(db)), None);
for super_trait in elaborate::supertrait_def_ids(interner, SolverDefId::TraitId(trait_)) { for super_trait in elaborate::supertrait_def_ids(interner, trait_.into()) {
let super_trait = match super_trait { if let Some(v) = db.dyn_compatibility_of_trait(super_trait.0) {
SolverDefId::TraitId(id) => id, return if super_trait.0 == trait_ {
_ => unreachable!(),
};
if let Some(v) = db.dyn_compatibility_of_trait(super_trait) {
return if super_trait == trait_ {
Some(v) Some(v)
} else { } else {
Some(DynCompatibilityViolation::HasNonCompatibleSuperTrait(super_trait)) Some(DynCompatibilityViolation::HasNonCompatibleSuperTrait(super_trait.0))
}; };
} }
} }
@ -82,13 +77,8 @@ where
F: FnMut(DynCompatibilityViolation) -> ControlFlow<()>, F: FnMut(DynCompatibilityViolation) -> ControlFlow<()>,
{ {
let interner = DbInterner::new_with(db, Some(trait_.krate(db)), None); let interner = DbInterner::new_with(db, Some(trait_.krate(db)), None);
for super_trait in elaborate::supertrait_def_ids(interner, SolverDefId::TraitId(trait_)).skip(1) for super_trait in elaborate::supertrait_def_ids(interner, trait_.into()).skip(1) {
{ if db.dyn_compatibility_of_trait(super_trait.0).is_some() {
let super_trait = match super_trait {
SolverDefId::TraitId(id) => id,
_ => unreachable!(),
};
if db.dyn_compatibility_of_trait(super_trait).is_some() {
cb(DynCompatibilityViolation::HasNonCompatibleSuperTrait(trait_))?; cb(DynCompatibilityViolation::HasNonCompatibleSuperTrait(trait_))?;
} }
} }
@ -151,7 +141,7 @@ pub fn generics_require_sized_self(db: &dyn HirDatabase, def: GenericDefId) -> b
elaborate::elaborate(interner, predicates.iter().copied()).any(|pred| { elaborate::elaborate(interner, predicates.iter().copied()).any(|pred| {
match pred.kind().skip_binder() { match pred.kind().skip_binder() {
ClauseKind::Trait(trait_pred) => { ClauseKind::Trait(trait_pred) => {
if SolverDefId::TraitId(sized) == trait_pred.def_id() if sized == trait_pred.def_id().0
&& let rustc_type_ir::TyKind::Param(param_ty) = && let rustc_type_ir::TyKind::Param(param_ty) =
trait_pred.trait_ref.self_ty().kind() trait_pred.trait_ref.self_ty().kind()
&& param_ty.index == 0 && param_ty.index == 0
@ -257,14 +247,8 @@ fn contains_illegal_self_type_reference<'db, T: rustc_type_ir::TypeVisitable<DbI
}; };
if self.super_traits.is_none() { if self.super_traits.is_none() {
self.super_traits = Some( self.super_traits = Some(
elaborate::supertrait_def_ids( elaborate::supertrait_def_ids(interner, self.trait_.into())
interner, .map(|super_trait| super_trait.0)
SolverDefId::TraitId(self.trait_),
)
.map(|super_trait| match super_trait {
SolverDefId::TraitId(id) => id,
_ => unreachable!(),
})
.collect(), .collect(),
) )
} }
@ -390,8 +374,7 @@ where
trait_ref: pred_trait_ref, trait_ref: pred_trait_ref,
polarity: PredicatePolarity::Positive, polarity: PredicatePolarity::Positive,
}) = pred }) = pred
&& let SolverDefId::TraitId(trait_id) = pred_trait_ref.def_id && let trait_data = db.trait_signature(pred_trait_ref.def_id.0)
&& let trait_data = db.trait_signature(trait_id)
&& trait_data.flags.contains(TraitFlags::AUTO) && trait_data.flags.contains(TraitFlags::AUTO)
&& let rustc_type_ir::TyKind::Param(crate::next_solver::ParamTy { index: 0, .. }) = && let rustc_type_ir::TyKind::Param(crate::next_solver::ParamTy { index: 0, .. }) =
pred_trait_ref.self_ty().kind() pred_trait_ref.self_ty().kind()
@ -464,25 +447,17 @@ fn receiver_is_dispatchable<'db>(
let generic_predicates = &*db.generic_predicates_ns(func.into()); let generic_predicates = &*db.generic_predicates_ns(func.into());
// Self: Unsize<U> // Self: Unsize<U>
let unsize_predicate = crate::next_solver::TraitRef::new( let unsize_predicate =
interner, TraitRef::new(interner, unsize_did.into(), [self_param_ty, unsized_self_ty]);
SolverDefId::TraitId(unsize_did),
[self_param_ty, unsized_self_ty],
);
// U: Trait<Arg1, ..., ArgN> // U: Trait<Arg1, ..., ArgN>
let trait_def_id = SolverDefId::TraitId(trait_); let args = GenericArgs::for_item(interner, trait_.into(), |name, index, kind, _| {
let args = GenericArgs::for_item(interner, trait_def_id, |name, index, kind, _| {
if index == 0 { unsized_self_ty.into() } else { mk_param(interner, index, name, kind) } if index == 0 { unsized_self_ty.into() } else { mk_param(interner, index, name, kind) }
}); });
let trait_predicate = let trait_predicate = TraitRef::new_from_args(interner, trait_.into(), args);
crate::next_solver::TraitRef::new_from_args(interner, trait_def_id, args);
let meta_sized_predicate = crate::next_solver::TraitRef::new( let meta_sized_predicate =
interner, TraitRef::new(interner, meta_sized_did.into(), [unsized_self_ty]);
SolverDefId::TraitId(meta_sized_did),
[unsized_self_ty],
);
ParamEnv { ParamEnv {
clauses: Clauses::new_from_iter( clauses: Clauses::new_from_iter(
@ -497,11 +472,8 @@ fn receiver_is_dispatchable<'db>(
}; };
// Receiver: DispatchFromDyn<Receiver[Self => U]> // Receiver: DispatchFromDyn<Receiver[Self => U]>
let predicate = crate::next_solver::TraitRef::new( let predicate =
interner, TraitRef::new(interner, dispatch_from_dyn_did.into(), [receiver_ty, unsized_receiver_ty]);
SolverDefId::TraitId(dispatch_from_dyn_did),
[receiver_ty, unsized_receiver_ty],
);
let goal = crate::next_solver::Goal::new(interner, param_env, predicate); let goal = crate::next_solver::Goal::new(interner, param_env, predicate);
let infcx = interner.infer_ctxt().build(TypingMode::non_body_analysis()); let infcx = interner.infer_ctxt().build(TypingMode::non_body_analysis());

64
crates/hir-ty/src/lower_nextsolver.rs
View file

@ -590,11 +590,9 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
.resolve_trait(ctx.ty_ctx().db, ctx.ty_ctx().resolver.krate()); .resolve_trait(ctx.ty_ctx().db, ctx.ty_ctx().resolver.krate());
let pointee_sized = LangItem::PointeeSized let pointee_sized = LangItem::PointeeSized
.resolve_trait(ctx.ty_ctx().db, ctx.ty_ctx().resolver.krate()); .resolve_trait(ctx.ty_ctx().db, ctx.ty_ctx().resolver.krate());
if meta_sized.is_some_and(|it| SolverDefId::TraitId(it) == trait_ref.def_id) { if meta_sized.is_some_and(|it| it == trait_ref.def_id.0) {
// Ignore this bound // Ignore this bound
} else if pointee_sized } else if pointee_sized.is_some_and(|it| it == trait_ref.def_id.0) {
.is_some_and(|it| SolverDefId::TraitId(it) == trait_ref.def_id)
{
// Regard this as `?Sized` bound // Regard this as `?Sized` bound
ctx.ty_ctx().unsized_types.insert(self_ty); ctx.ty_ctx().unsized_types.insert(self_ty);
} else { } else {
@ -618,13 +616,9 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
// Don't lower associated type bindings as the only possible relaxed trait bound // Don't lower associated type bindings as the only possible relaxed trait bound
// `?Sized` has no of them. // `?Sized` has no of them.
// If we got another trait here ignore the bound completely. // If we got another trait here ignore the bound completely.
let trait_id = let trait_id = self
self.lower_trait_ref_from_path(path, self_ty).map(|(trait_ref, _)| { .lower_trait_ref_from_path(path, self_ty)
match trait_ref.def_id { .map(|(trait_ref, _)| trait_ref.def_id.0);
SolverDefId::TraitId(id) => id,
_ => unreachable!(),
}
});
if trait_id == sized_trait { if trait_id == sized_trait {
self.unsized_types.insert(self_ty); self.unsized_types.insert(self_ty);
} }
@ -668,12 +662,8 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
.map_bound(|c| match c { .map_bound(|c| match c {
rustc_type_ir::ClauseKind::Trait(t) => { rustc_type_ir::ClauseKind::Trait(t) => {
let id = t.def_id(); let id = t.def_id();
let id = match id {
SolverDefId::TraitId(id) => id,
_ => unreachable!(),
};
let is_auto = let is_auto =
db.trait_signature(id).flags.contains(TraitFlags::AUTO); db.trait_signature(id.0).flags.contains(TraitFlags::AUTO);
if is_auto { if is_auto {
Some(ExistentialPredicate::AutoTrait(t.def_id())) Some(ExistentialPredicate::AutoTrait(t.def_id()))
} else { } else {
@ -733,17 +723,7 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
( (
ExistentialPredicate::AutoTrait(lhs_id), ExistentialPredicate::AutoTrait(lhs_id),
ExistentialPredicate::AutoTrait(rhs_id), ExistentialPredicate::AutoTrait(rhs_id),
) => { ) => lhs_id.0.cmp(&rhs_id.0),
let lhs_id = match lhs_id {
SolverDefId::TraitId(id) => id,
_ => unreachable!(),
};
let rhs_id = match rhs_id {
SolverDefId::TraitId(id) => id,
_ => unreachable!(),
};
lhs_id.cmp(&rhs_id)
}
(ExistentialPredicate::Trait(_), _) => Ordering::Less, (ExistentialPredicate::Trait(_), _) => Ordering::Less,
(_, ExistentialPredicate::Trait(_)) => Ordering::Greater, (_, ExistentialPredicate::Trait(_)) => Ordering::Greater,
(ExistentialPredicate::AutoTrait(_), _) => Ordering::Less, (ExistentialPredicate::AutoTrait(_), _) => Ordering::Less,
@ -1195,11 +1175,7 @@ pub(crate) fn generic_predicates_for_param_query<'db>(
}; };
rustc_type_ir::elaborate::supertrait_def_ids(interner, tr.into()).any(|tr| { rustc_type_ir::elaborate::supertrait_def_ids(interner, tr.into()).any(|tr| {
let tr = match tr { tr.0.trait_items(db).items.iter().any(|(name, item)| {
SolverDefId::TraitId(id) => id,
_ => unreachable!(),
};
tr.trait_items(db).items.iter().any(|(name, item)| {
matches!(item, AssocItemId::TypeAliasId(_)) && name == assoc_name matches!(item, AssocItemId::TypeAliasId(_)) && name == assoc_name
}) })
}) })
@ -1629,11 +1605,7 @@ pub(crate) fn associated_ty_item_bounds<'db>(
.map_bound(|c| match c { .map_bound(|c| match c {
rustc_type_ir::ClauseKind::Trait(t) => { rustc_type_ir::ClauseKind::Trait(t) => {
let id = t.def_id(); let id = t.def_id();
let id = match id { let is_auto = db.trait_signature(id.0).flags.contains(TraitFlags::AUTO);
SolverDefId::TraitId(id) => id,
_ => unreachable!(),
};
let is_auto = db.trait_signature(id).flags.contains(TraitFlags::AUTO);
if is_auto { if is_auto {
Some(ExistentialPredicate::AutoTrait(t.def_id())) Some(ExistentialPredicate::AutoTrait(t.def_id()))
} else { } else {
@ -1677,7 +1649,7 @@ pub(crate) fn associated_ty_item_bounds<'db>(
let sized_trait = LangItem::Sized.resolve_trait(db, resolver.krate()); let sized_trait = LangItem::Sized.resolve_trait(db, resolver.krate());
let sized_clause = Binder::dummy(ExistentialPredicate::Trait(ExistentialTraitRef::new( let sized_clause = Binder::dummy(ExistentialPredicate::Trait(ExistentialTraitRef::new(
interner, interner,
SolverDefId::TraitId(trait_), trait_.into(),
[] as [crate::next_solver::GenericArg<'_>; 0], [] as [crate::next_solver::GenericArg<'_>; 0],
))); )));
bounds.push(sized_clause); bounds.push(sized_clause);
@ -1694,10 +1666,7 @@ pub(crate) fn associated_type_by_name_including_super_traits<'db>(
) -> Option<(TraitRef<'db>, TypeAliasId)> { ) -> Option<(TraitRef<'db>, TypeAliasId)> {
let interner = DbInterner::new_with(db, None, None); let interner = DbInterner::new_with(db, None, None);
rustc_type_ir::elaborate::supertraits(interner, Binder::dummy(trait_ref)).find_map(|t| { rustc_type_ir::elaborate::supertraits(interner, Binder::dummy(trait_ref)).find_map(|t| {
let trait_id = match t.as_ref().skip_binder().def_id { let trait_id = t.as_ref().skip_binder().def_id.0;
SolverDefId::TraitId(id) => id,
_ => unreachable!(),
};
let assoc_type = trait_id.trait_items(db).associated_type_by_name(name)?; let assoc_type = trait_id.trait_items(db).associated_type_by_name(name)?;
Some((t.skip_binder(), assoc_type)) Some((t.skip_binder(), assoc_type))
}) })
@ -1727,10 +1696,7 @@ fn named_associated_type_shorthand_candidates<'db, R>(
) -> Option<R> { ) -> Option<R> {
let db = interner.db; let db = interner.db;
let mut search = |t: TraitRef<'db>| -> Option<R> { let mut search = |t: TraitRef<'db>| -> Option<R> {
let trait_id = match t.def_id { let trait_id = t.def_id.0;
SolverDefId::TraitId(id) => id,
_ => unreachable!(),
};
let mut checked_traits = FxHashSet::default(); let mut checked_traits = FxHashSet::default();
let mut check_trait = |trait_id: TraitId| { let mut check_trait = |trait_id: TraitId| {
let name = &db.trait_signature(trait_id).name; let name = &db.trait_signature(trait_id).name;
@ -1773,11 +1739,7 @@ fn named_associated_type_shorthand_candidates<'db, R>(
rustc_type_ir::ClauseKind::Trait(pred) => pred.def_id(), rustc_type_ir::ClauseKind::Trait(pred) => pred.def_id(),
_ => continue, _ => continue,
}; };
let trait_id = match trait_id { stack.push(trait_id.0);
SolverDefId::TraitId(trait_id) => trait_id,
_ => continue,
};
stack.push(trait_id);
} }
tracing::debug!(?stack); tracing::debug!(?stack);
} }

5
crates/hir-ty/src/lower_nextsolver/path.rs
View file

@ -208,10 +208,7 @@ impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {
tracing::debug!(?trait_ref); tracing::debug!(?trait_ref);
self.skip_resolved_segment(); self.skip_resolved_segment();
let segment = self.current_or_prev_segment; let segment = self.current_or_prev_segment;
let trait_id = match trait_ref.def_id { let trait_id = trait_ref.def_id.0;
SolverDefId::TraitId(id) => id,
_ => unreachable!(),
};
let found = let found =
trait_id.trait_items(self.ctx.db).associated_type_by_name(segment.name); trait_id.trait_items(self.ctx.db).associated_type_by_name(segment.name);

6
crates/hir-ty/src/method_resolution.rs
View file

@ -168,11 +168,7 @@ impl TyFingerprint {
_ => None, _ => None,
}) })
.next()?; .next()?;
let trait_id = match trait_ref { TyFingerprint::Dyn(trait_ref.0)
SolverDefId::TraitId(id) => id,
_ => panic!("Bad GenericDefId in trait ref"),
};
TyFingerprint::Dyn(trait_id)
} }
TyKind::Ref(_, _, mutability) => match mutability { TyKind::Ref(_, _, mutability) => match mutability {
rustc_ast_ir::Mutability::Mut => TyFingerprint::Ref(Mutability::Mut), rustc_ast_ir::Mutability::Mut => TyFingerprint::Ref(Mutability::Mut),

29
crates/hir-ty/src/next_solver/consts.rs
View file

@ -81,7 +81,7 @@ impl<'db> std::fmt::Debug for InternedWrapperNoDebug<WithCachedTypeInfo<ConstKin
} }
} }
pub type PlaceholderConst = Placeholder<rustc_type_ir::BoundVar>; pub type PlaceholderConst = Placeholder<BoundConst>;
#[derive(Copy, Clone, Hash, Eq, PartialEq)] #[derive(Copy, Clone, Hash, Eq, PartialEq)]
pub struct ParamConst { pub struct ParamConst {
@ -304,7 +304,7 @@ impl<'db> rustc_type_ir::inherent::Const<DbInterner<'db>> for Const<'db> {
fn new_bound( fn new_bound(
interner: DbInterner<'db>, interner: DbInterner<'db>,
debruijn: rustc_type_ir::DebruijnIndex, debruijn: rustc_type_ir::DebruijnIndex,
var: BoundVar, var: BoundConst,
) -> Self { ) -> Self {
Const::new(interner, ConstKind::Bound(debruijn, var)) Const::new(interner, ConstKind::Bound(debruijn, var))
} }
@ -314,7 +314,7 @@ impl<'db> rustc_type_ir::inherent::Const<DbInterner<'db>> for Const<'db> {
debruijn: rustc_type_ir::DebruijnIndex, debruijn: rustc_type_ir::DebruijnIndex,
var: rustc_type_ir::BoundVar, var: rustc_type_ir::BoundVar,
) -> Self { ) -> Self {
Const::new(interner, ConstKind::Bound(debruijn, var)) Const::new(interner, ConstKind::Bound(debruijn, BoundConst { var }))
} }
fn new_unevaluated( fn new_unevaluated(
@ -340,26 +340,41 @@ impl<'db> rustc_type_ir::inherent::Const<DbInterner<'db>> for Const<'db> {
} }
} }
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
pub struct BoundConst {
pub var: BoundVar,
}
impl<'db> rustc_type_ir::inherent::BoundVarLike<DbInterner<'db>> for BoundConst {
fn var(self) -> BoundVar {
self.var
}
fn assert_eq(self, var: BoundVarKind) {
var.expect_const()
}
}
impl<'db> PlaceholderLike<DbInterner<'db>> for PlaceholderConst { impl<'db> PlaceholderLike<DbInterner<'db>> for PlaceholderConst {
type Bound = rustc_type_ir::BoundVar; type Bound = BoundConst;
fn universe(self) -> rustc_type_ir::UniverseIndex { fn universe(self) -> rustc_type_ir::UniverseIndex {
self.universe self.universe
} }
fn var(self) -> rustc_type_ir::BoundVar { fn var(self) -> rustc_type_ir::BoundVar {
self.bound self.bound.var
} }
fn with_updated_universe(self, ui: rustc_type_ir::UniverseIndex) -> Self { fn with_updated_universe(self, ui: rustc_type_ir::UniverseIndex) -> Self {
Placeholder { universe: ui, bound: self.bound } Placeholder { universe: ui, bound: self.bound }
} }
fn new(ui: rustc_type_ir::UniverseIndex, var: rustc_type_ir::BoundVar) -> Self { fn new(ui: rustc_type_ir::UniverseIndex, var: BoundConst) -> Self {
Placeholder { universe: ui, bound: var } Placeholder { universe: ui, bound: var }
} }
fn new_anon(ui: rustc_type_ir::UniverseIndex, var: rustc_type_ir::BoundVar) -> Self { fn new_anon(ui: rustc_type_ir::UniverseIndex, var: rustc_type_ir::BoundVar) -> Self {
Placeholder { universe: ui, bound: var } Placeholder { universe: ui, bound: BoundConst { var } }
} }
} }

57
crates/hir-ty/src/next_solver/def_id.rs
View file

@ -88,3 +88,60 @@ impl<'db> inherent::DefId<DbInterner<'db>> for SolverDefId {
true true
} }
} }
macro_rules! declare_id_wrapper {
($name:ident, $wraps:ident) => {
#[derive(Clone, Copy, PartialEq, Eq, Hash)]
pub struct $name(pub $wraps);
impl std::fmt::Debug for $name {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
std::fmt::Debug::fmt(&self.0, f)
}
}
impl From<$name> for $wraps {
#[inline]
fn from(value: $name) -> $wraps {
value.0
}
}
impl From<$wraps> for $name {
#[inline]
fn from(value: $wraps) -> $name {
Self(value)
}
}
impl From<$name> for SolverDefId {
#[inline]
fn from(value: $name) -> SolverDefId {
value.0.into()
}
}
impl TryFrom<SolverDefId> for $name {
type Error = ();
#[inline]
fn try_from(value: SolverDefId) -> Result<Self, Self::Error> {
match value {
SolverDefId::$wraps(it) => Ok(Self(it)),
_ => Err(()),
}
}
}
impl<'db> inherent::DefId<DbInterner<'db>> for $name {
fn as_local(self) -> Option<SolverDefId> {
Some(self.into())
}
fn is_local(self) -> bool {
true
}
}
};
}
declare_id_wrapper!(TraitIdWrapper, TraitId);

8
crates/hir-ty/src/next_solver/fold.rs
View file

@ -6,6 +6,8 @@ use rustc_type_ir::{
inherent::{IntoKind, Region as _}, inherent::{IntoKind, Region as _},
}; };
use crate::next_solver::BoundConst;
use super::{ use super::{
Binder, BoundRegion, BoundTy, Const, ConstKind, DbInterner, Predicate, Region, Ty, TyKind, Binder, BoundRegion, BoundTy, Const, ConstKind, DbInterner, Predicate, Region, Ty, TyKind,
}; };
@ -18,7 +20,7 @@ use super::{
pub trait BoundVarReplacerDelegate<'db> { pub trait BoundVarReplacerDelegate<'db> {
fn replace_region(&mut self, br: BoundRegion) -> Region<'db>; fn replace_region(&mut self, br: BoundRegion) -> Region<'db>;
fn replace_ty(&mut self, bt: BoundTy) -> Ty<'db>; fn replace_ty(&mut self, bt: BoundTy) -> Ty<'db>;
fn replace_const(&mut self, bv: BoundVar) -> Const<'db>; fn replace_const(&mut self, bv: BoundConst) -> Const<'db>;
} }
/// A simple delegate taking 3 mutable functions. The used functions must /// A simple delegate taking 3 mutable functions. The used functions must
@ -27,7 +29,7 @@ pub trait BoundVarReplacerDelegate<'db> {
pub struct FnMutDelegate<'db, 'a> { pub struct FnMutDelegate<'db, 'a> {
pub regions: &'a mut (dyn FnMut(BoundRegion) -> Region<'db> + 'a), pub regions: &'a mut (dyn FnMut(BoundRegion) -> Region<'db> + 'a),
pub types: &'a mut (dyn FnMut(BoundTy) -> Ty<'db> + 'a), pub types: &'a mut (dyn FnMut(BoundTy) -> Ty<'db> + 'a),
pub consts: &'a mut (dyn FnMut(BoundVar) -> Const<'db> + 'a), pub consts: &'a mut (dyn FnMut(BoundConst) -> Const<'db> + 'a),
} }
impl<'db, 'a> BoundVarReplacerDelegate<'db> for FnMutDelegate<'db, 'a> { impl<'db, 'a> BoundVarReplacerDelegate<'db> for FnMutDelegate<'db, 'a> {
@ -37,7 +39,7 @@ impl<'db, 'a> BoundVarReplacerDelegate<'db> for FnMutDelegate<'db, 'a> {
fn replace_ty(&mut self, bt: BoundTy) -> Ty<'db> { fn replace_ty(&mut self, bt: BoundTy) -> Ty<'db> {
(self.types)(bt) (self.types)(bt)
} }
fn replace_const(&mut self, bv: BoundVar) -> Const<'db> { fn replace_const(&mut self, bv: BoundConst) -> Const<'db> {
(self.consts)(bv) (self.consts)(bv)
} }
} }

2
crates/hir-ty/src/next_solver/fulfill.rs
View file

@ -167,7 +167,7 @@ impl<'db> FulfillmentCtxt<'db> {
} }
let result = delegate.evaluate_root_goal(goal, Span::dummy(), stalled_on); let result = delegate.evaluate_root_goal(goal, Span::dummy(), stalled_on);
let GoalEvaluation { certainty, has_changed, stalled_on } = match result { let GoalEvaluation { goal: _, certainty, has_changed, stalled_on } = match result {
Ok(result) => result, Ok(result) => result,
Err(NoSolution) => { Err(NoSolution) => {
errors.push(NextSolverError::TrueError(obligation)); errors.push(NextSolverError::TrueError(obligation));

2
crates/hir-ty/src/next_solver/generic_arg.rs
View file

@ -384,7 +384,6 @@ impl<'db> rustc_type_ir::inherent::GenericArgs<DbInterner<'db>> for GenericArgs<
signature_parts_ty: signature_parts_ty.expect_ty(), signature_parts_ty: signature_parts_ty.expect_ty(),
tupled_upvars_ty: tupled_upvars_ty.expect_ty(), tupled_upvars_ty: tupled_upvars_ty.expect_ty(),
coroutine_captures_by_ref_ty: coroutine_captures_by_ref_ty.expect_ty(), coroutine_captures_by_ref_ty: coroutine_captures_by_ref_ty.expect_ty(),
coroutine_witness_ty: coroutine_witness_ty.expect_ty(),
}, },
_ => panic!("GenericArgs were likely not for a CoroutineClosure."), _ => panic!("GenericArgs were likely not for a CoroutineClosure."),
} }
@ -400,7 +399,6 @@ impl<'db> rustc_type_ir::inherent::GenericArgs<DbInterner<'db>> for GenericArgs<
resume_ty: resume_ty.expect_ty(), resume_ty: resume_ty.expect_ty(),
yield_ty: yield_ty.expect_ty(), yield_ty: yield_ty.expect_ty(),
return_ty: return_ty.expect_ty(), return_ty: return_ty.expect_ty(),
witness: Ty::new_unit(interner),
tupled_upvars_ty: Ty::new_unit(interner), tupled_upvars_ty: Ty::new_unit(interner),
} }
} }

3
crates/hir-ty/src/next_solver/infer/canonical/instantiate.rs
View file

@ -6,6 +6,7 @@
//! //!
//! [c]: https://rust-lang.github.io/chalk/book/canonical_queries/canonicalization.html //! [c]: https://rust-lang.github.io/chalk/book/canonical_queries/canonicalization.html
use crate::next_solver::BoundConst;
use crate::next_solver::{ use crate::next_solver::{
AliasTy, Binder, BoundRegion, BoundTy, Canonical, CanonicalVarValues, Const, DbInterner, Goal, AliasTy, Binder, BoundRegion, BoundTy, Canonical, CanonicalVarValues, Const, DbInterner, Goal,
ParamEnv, Predicate, PredicateKind, Region, Ty, TyKind, ParamEnv, Predicate, PredicateKind, Region, Ty, TyKind,
@ -95,7 +96,7 @@ where
GenericArgKind::Type(ty) => ty, GenericArgKind::Type(ty) => ty,
r => panic!("{bound_ty:?} is a type but value is {r:?}"), r => panic!("{bound_ty:?} is a type but value is {r:?}"),
}, },
consts: &mut |bound_ct: BoundVar| match var_values[bound_ct].kind() { consts: &mut |bound_ct: BoundConst| match var_values[bound_ct.var].kind() {
GenericArgKind::Const(ct) => ct, GenericArgKind::Const(ct) => ct,
c => panic!("{bound_ct:?} is a const but value is {c:?}"), c => panic!("{bound_ct:?} is a const but value is {c:?}"),
}, },

6
crates/hir-ty/src/next_solver/infer/mod.rs
View file

@ -37,7 +37,7 @@ use unify_key::{ConstVariableOrigin, ConstVariableValue, ConstVidKey};
use crate::next_solver::fold::BoundVarReplacerDelegate; use crate::next_solver::fold::BoundVarReplacerDelegate;
use crate::next_solver::infer::opaque_types::table::OpaqueTypeStorageEntries; use crate::next_solver::infer::opaque_types::table::OpaqueTypeStorageEntries;
use crate::next_solver::{BoundRegion, BoundTy, BoundVarKind}; use crate::next_solver::{BoundConst, BoundRegion, BoundTy, BoundVarKind};
use super::generics::GenericParamDef; use super::generics::GenericParamDef;
use super::{ use super::{
@ -864,8 +864,8 @@ impl<'db> InferCtxt<'db> {
fn replace_ty(&mut self, bt: BoundTy) -> Ty<'db> { fn replace_ty(&mut self, bt: BoundTy) -> Ty<'db> {
self.args[bt.var.index()].expect_ty() self.args[bt.var.index()].expect_ty()
} }
fn replace_const(&mut self, bv: BoundVar) -> Const<'db> { fn replace_const(&mut self, bv: BoundConst) -> Const<'db> {
self.args[bv.index()].expect_const() self.args[bv.var.index()].expect_const()
} }
} }
let delegate = ToFreshVars { args }; let delegate = ToFreshVars { args };

8
crates/hir-ty/src/next_solver/infer/relate/higher_ranked.rs
View file

@ -10,8 +10,8 @@ use crate::next_solver::fold::FnMutDelegate;
use crate::next_solver::infer::InferCtxt; use crate::next_solver::infer::InferCtxt;
use crate::next_solver::infer::snapshot::CombinedSnapshot; use crate::next_solver::infer::snapshot::CombinedSnapshot;
use crate::next_solver::{ use crate::next_solver::{
Binder, BoundRegion, BoundTy, Const, DbInterner, PlaceholderConst, PlaceholderRegion, Binder, BoundConst, BoundRegion, BoundTy, Const, DbInterner, PlaceholderConst,
PlaceholderTy, Region, Ty, PlaceholderRegion, PlaceholderTy, Region, Ty,
}; };
impl<'db> InferCtxt<'db> { impl<'db> InferCtxt<'db> {
@ -50,10 +50,10 @@ impl<'db> InferCtxt<'db> {
PlaceholderTy { universe: next_universe, bound: bound_ty }, PlaceholderTy { universe: next_universe, bound: bound_ty },
) )
}, },
consts: &mut |bound_var: BoundVar| { consts: &mut |bound: BoundConst| {
Const::new_placeholder( Const::new_placeholder(
self.interner, self.interner,
PlaceholderConst { universe: next_universe, bound: bound_var }, PlaceholderConst { universe: next_universe, bound },
) )
}, },
}; };

513
crates/hir-ty/src/next_solver/interner.rs
View file

@ -19,7 +19,7 @@ use rustc_type_ir::error::TypeError;
use rustc_type_ir::inherent::{ use rustc_type_ir::inherent::{
AdtDef as _, GenericArgs as _, GenericsOf, IntoKind, SliceLike as _, Span as _, AdtDef as _, GenericArgs as _, GenericsOf, IntoKind, SliceLike as _, Span as _,
}; };
use rustc_type_ir::lang_items::TraitSolverLangItem; use rustc_type_ir::lang_items::{SolverLangItem, SolverTraitLangItem};
use rustc_type_ir::solve::SizedTraitKind; use rustc_type_ir::solve::SizedTraitKind;
use rustc_type_ir::{ use rustc_type_ir::{
AliasTerm, AliasTermKind, AliasTy, AliasTyKind, EarlyBinder, FlagComputation, Flags, AliasTerm, AliasTermKind, AliasTy, AliasTyKind, EarlyBinder, FlagComputation, Flags,
@ -44,9 +44,11 @@ use rustc_type_ir::{
use crate::lower_nextsolver::{self, TyLoweringContext}; use crate::lower_nextsolver::{self, TyLoweringContext};
use crate::method_resolution::{ALL_FLOAT_FPS, ALL_INT_FPS, TyFingerprint}; use crate::method_resolution::{ALL_FLOAT_FPS, ALL_INT_FPS, TyFingerprint};
use crate::next_solver::infer::InferCtxt;
use crate::next_solver::util::{ContainsTypeErrors, explicit_item_bounds, for_trait_impls}; use crate::next_solver::util::{ContainsTypeErrors, explicit_item_bounds, for_trait_impls};
use crate::next_solver::{ use crate::next_solver::{
CanonicalVarKind, FxIndexMap, InternedWrapperNoDebug, RegionAssumptions, SolverDefIds, BoundConst, CanonicalVarKind, FxIndexMap, InternedWrapperNoDebug, RegionAssumptions,
SolverContext, SolverDefIds, TraitIdWrapper,
}; };
use crate::{ConstScalar, FnAbi, Interner, db::HirDatabase}; use crate::{ConstScalar, FnAbi, Interner, db::HirDatabase};
@ -858,10 +860,35 @@ impl<'db> rustc_type_ir::relate::Relate<DbInterner<'db>> for Pattern<'db> {
interned_vec_db!(PatList, Pattern); interned_vec_db!(PatList, Pattern);
macro_rules! as_lang_item {
(
$solver_enum:ident, $var:ident;
ignore = {
$( $ignore:ident ),* $(,)?
}
$( $variant:ident ),* $(,)?
) => {{
// Ensure exhaustiveness.
if let Some(it) = None::<$solver_enum> {
match it {
$( $solver_enum::$variant => {} )*
$( $solver_enum::$ignore => {} )*
}
}
match $var {
$( LangItem::$variant => Some($solver_enum::$variant), )*
_ => None
}
}};
}
impl<'db> rustc_type_ir::Interner for DbInterner<'db> { impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
type DefId = SolverDefId; type DefId = SolverDefId;
type LocalDefId = SolverDefId; type LocalDefId = SolverDefId;
type LocalDefIds = SolverDefIds; type LocalDefIds = SolverDefIds;
type TraitId = TraitIdWrapper;
type Span = Span; type Span = Span;
type GenericArgs = GenericArgs<'db>; type GenericArgs = GenericArgs<'db>;
@ -923,7 +950,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
type Const = Const<'db>; type Const = Const<'db>;
type PlaceholderConst = PlaceholderConst; type PlaceholderConst = PlaceholderConst;
type ParamConst = ParamConst; type ParamConst = ParamConst;
type BoundConst = rustc_type_ir::BoundVar; type BoundConst = BoundConst;
type ValueConst = ValueConst<'db>; type ValueConst = ValueConst<'db>;
type ValTree = Valtree<'db>; type ValTree = Valtree<'db>;
type ExprConst = ExprConst; type ExprConst = ExprConst;
@ -1117,7 +1144,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
); );
let alias_args = let alias_args =
GenericArgs::new_from_iter(self, args.iter().skip(trait_generics.own_params.len())); GenericArgs::new_from_iter(self, args.iter().skip(trait_generics.own_params.len()));
(TraitRef::new_from_args(self, trait_def_id, trait_args), alias_args) (TraitRef::new_from_args(self, trait_def_id.try_into().unwrap(), trait_args), alias_args)
} }
fn check_args_compatible(self, def_id: Self::DefId, args: Self::GenericArgs) -> bool { fn check_args_compatible(self, def_id: Self::DefId, args: Self::GenericArgs) -> bool {
@ -1305,11 +1332,11 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
#[tracing::instrument(skip(self), ret)] #[tracing::instrument(skip(self), ret)]
fn explicit_super_predicates_of( fn explicit_super_predicates_of(
self, self,
def_id: Self::DefId, def_id: Self::TraitId,
) -> EarlyBinder<Self, impl IntoIterator<Item = (Self::Clause, Self::Span)>> { ) -> EarlyBinder<Self, impl IntoIterator<Item = (Self::Clause, Self::Span)>> {
let predicates: Vec<(Clause<'db>, Span)> = self let predicates: Vec<(Clause<'db>, Span)> = self
.db() .db()
.generic_predicates_ns(def_id.try_into().unwrap()) .generic_predicates_ns(def_id.0.into())
.iter() .iter()
.cloned() .cloned()
.map(|p| (p, Span::dummy())) .map(|p| (p, Span::dummy()))
@ -1369,65 +1396,19 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
false false
} }
fn require_lang_item( fn require_lang_item(self, lang_item: SolverLangItem) -> Self::DefId {
self,
lang_item: rustc_type_ir::lang_items::TraitSolverLangItem,
) -> Self::DefId {
let lang_item = match lang_item { let lang_item = match lang_item {
rustc_type_ir::lang_items::TraitSolverLangItem::AsyncFn => LangItem::AsyncFn, SolverLangItem::AsyncFnKindUpvars => unimplemented!(),
rustc_type_ir::lang_items::TraitSolverLangItem::AsyncFnKindHelper => unimplemented!(), SolverLangItem::AsyncFnOnceOutput => LangItem::AsyncFnOnceOutput,
rustc_type_ir::lang_items::TraitSolverLangItem::AsyncFnKindUpvars => unimplemented!(), SolverLangItem::CallOnceFuture => LangItem::CallOnceFuture,
rustc_type_ir::lang_items::TraitSolverLangItem::AsyncFnMut => LangItem::AsyncFnMut, SolverLangItem::CallRefFuture => LangItem::CallRefFuture,
rustc_type_ir::lang_items::TraitSolverLangItem::AsyncFnOnce => LangItem::AsyncFnOnce, SolverLangItem::CoroutineReturn => LangItem::CoroutineReturn,
rustc_type_ir::lang_items::TraitSolverLangItem::AsyncFnOnceOutput => { SolverLangItem::CoroutineYield => LangItem::CoroutineYield,
LangItem::AsyncFnOnceOutput SolverLangItem::DynMetadata => LangItem::DynMetadata,
} SolverLangItem::FutureOutput => LangItem::FutureOutput,
rustc_type_ir::lang_items::TraitSolverLangItem::AsyncIterator => unimplemented!(), SolverLangItem::Metadata => LangItem::Metadata,
rustc_type_ir::lang_items::TraitSolverLangItem::CallOnceFuture => { SolverLangItem::Option => LangItem::Option,
LangItem::CallOnceFuture SolverLangItem::Poll => LangItem::Poll,
}
rustc_type_ir::lang_items::TraitSolverLangItem::CallRefFuture => {
LangItem::CallRefFuture
}
rustc_type_ir::lang_items::TraitSolverLangItem::Clone => LangItem::Clone,
rustc_type_ir::lang_items::TraitSolverLangItem::Copy => LangItem::Copy,
rustc_type_ir::lang_items::TraitSolverLangItem::Coroutine => LangItem::Coroutine,
rustc_type_ir::lang_items::TraitSolverLangItem::CoroutineReturn => {
LangItem::CoroutineReturn
}
rustc_type_ir::lang_items::TraitSolverLangItem::CoroutineYield => {
LangItem::CoroutineYield
}
rustc_type_ir::lang_items::TraitSolverLangItem::Destruct => LangItem::Destruct,
rustc_type_ir::lang_items::TraitSolverLangItem::DiscriminantKind => {
LangItem::DiscriminantKind
}
rustc_type_ir::lang_items::TraitSolverLangItem::Drop => LangItem::Drop,
rustc_type_ir::lang_items::TraitSolverLangItem::DynMetadata => LangItem::DynMetadata,
rustc_type_ir::lang_items::TraitSolverLangItem::Fn => LangItem::Fn,
rustc_type_ir::lang_items::TraitSolverLangItem::FnMut => LangItem::FnMut,
rustc_type_ir::lang_items::TraitSolverLangItem::FnOnce => LangItem::FnOnce,
rustc_type_ir::lang_items::TraitSolverLangItem::FnPtrTrait => LangItem::FnPtrTrait,
rustc_type_ir::lang_items::TraitSolverLangItem::FusedIterator => unimplemented!(),
rustc_type_ir::lang_items::TraitSolverLangItem::Future => LangItem::Future,
rustc_type_ir::lang_items::TraitSolverLangItem::FutureOutput => LangItem::FutureOutput,
rustc_type_ir::lang_items::TraitSolverLangItem::Iterator => LangItem::Iterator,
rustc_type_ir::lang_items::TraitSolverLangItem::Metadata => LangItem::Metadata,
rustc_type_ir::lang_items::TraitSolverLangItem::Option => LangItem::Option,
rustc_type_ir::lang_items::TraitSolverLangItem::PointeeTrait => LangItem::PointeeTrait,
rustc_type_ir::lang_items::TraitSolverLangItem::Poll => LangItem::Poll,
rustc_type_ir::lang_items::TraitSolverLangItem::Sized => LangItem::Sized,
rustc_type_ir::lang_items::TraitSolverLangItem::MetaSized => LangItem::MetaSized,
rustc_type_ir::lang_items::TraitSolverLangItem::PointeeSized => LangItem::PointeeSized,
rustc_type_ir::lang_items::TraitSolverLangItem::TransmuteTrait => {
LangItem::TransmuteTrait
}
rustc_type_ir::lang_items::TraitSolverLangItem::Tuple => LangItem::Tuple,
rustc_type_ir::lang_items::TraitSolverLangItem::Unpin => LangItem::Unpin,
rustc_type_ir::lang_items::TraitSolverLangItem::Unsize => LangItem::Unsize,
rustc_type_ir::lang_items::TraitSolverLangItem::BikeshedGuaranteedNoDrop => {
unimplemented!()
}
}; };
let target = hir_def::lang_item::lang_item( let target = hir_def::lang_item::lang_item(
self.db(), self.db(),
@ -1448,216 +1429,131 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
} }
} }
#[allow(clippy::match_like_matches_macro)] fn require_trait_lang_item(self, lang_item: SolverTraitLangItem) -> TraitIdWrapper {
fn is_lang_item( let lang_item = match lang_item {
self, SolverTraitLangItem::AsyncFn => LangItem::AsyncFn,
def_id: Self::DefId, SolverTraitLangItem::AsyncFnKindHelper => unimplemented!(),
lang_item: rustc_type_ir::lang_items::TraitSolverLangItem, SolverTraitLangItem::AsyncFnMut => LangItem::AsyncFnMut,
) -> bool { SolverTraitLangItem::AsyncFnOnce => LangItem::AsyncFnOnce,
use rustc_type_ir::lang_items::TraitSolverLangItem::*; SolverTraitLangItem::AsyncFnOnceOutput => LangItem::AsyncFnOnceOutput,
SolverTraitLangItem::AsyncIterator => unimplemented!(),
// FIXME: derive PartialEq on TraitSolverLangItem SolverTraitLangItem::Clone => LangItem::Clone,
self.as_lang_item(def_id).map_or(false, |l| match (l, lang_item) { SolverTraitLangItem::Copy => LangItem::Copy,
(AsyncFn, AsyncFn) => true, SolverTraitLangItem::Coroutine => LangItem::Coroutine,
(AsyncFnKindHelper, AsyncFnKindHelper) => true, SolverTraitLangItem::Destruct => LangItem::Destruct,
(AsyncFnKindUpvars, AsyncFnKindUpvars) => true, SolverTraitLangItem::DiscriminantKind => LangItem::DiscriminantKind,
(AsyncFnMut, AsyncFnMut) => true, SolverTraitLangItem::Drop => LangItem::Drop,
(AsyncFnOnce, AsyncFnOnce) => true, SolverTraitLangItem::Fn => LangItem::Fn,
(AsyncFnOnceOutput, AsyncFnOnceOutput) => true, SolverTraitLangItem::FnMut => LangItem::FnMut,
(AsyncIterator, AsyncIterator) => true, SolverTraitLangItem::FnOnce => LangItem::FnOnce,
(CallOnceFuture, CallOnceFuture) => true, SolverTraitLangItem::FnPtrTrait => LangItem::FnPtrTrait,
(CallRefFuture, CallRefFuture) => true, SolverTraitLangItem::FusedIterator => unimplemented!(),
(Clone, Clone) => true, SolverTraitLangItem::Future => LangItem::Future,
(Copy, Copy) => true, SolverTraitLangItem::Iterator => LangItem::Iterator,
(Coroutine, Coroutine) => true, SolverTraitLangItem::PointeeTrait => LangItem::PointeeTrait,
(CoroutineReturn, CoroutineReturn) => true, SolverTraitLangItem::Sized => LangItem::Sized,
(CoroutineYield, CoroutineYield) => true, SolverTraitLangItem::MetaSized => LangItem::MetaSized,
(Destruct, Destruct) => true, SolverTraitLangItem::PointeeSized => LangItem::PointeeSized,
(DiscriminantKind, DiscriminantKind) => true, SolverTraitLangItem::TransmuteTrait => LangItem::TransmuteTrait,
(Drop, Drop) => true, SolverTraitLangItem::Tuple => LangItem::Tuple,
(DynMetadata, DynMetadata) => true, SolverTraitLangItem::Unpin => LangItem::Unpin,
(Fn, Fn) => true, SolverTraitLangItem::Unsize => LangItem::Unsize,
(FnMut, FnMut) => true, SolverTraitLangItem::BikeshedGuaranteedNoDrop => {
(FnOnce, FnOnce) => true, unimplemented!()
(FnPtrTrait, FnPtrTrait) => true, }
(FusedIterator, FusedIterator) => true, };
(Future, Future) => true, lang_item
(FutureOutput, FutureOutput) => true, .resolve_trait(self.db(), self.krate.expect("Must have self.krate"))
(Iterator, Iterator) => true, .unwrap_or_else(|| panic!("Lang item {lang_item:?} required but not found."))
(Metadata, Metadata) => true, .into()
(Option, Option) => true,
(PointeeTrait, PointeeTrait) => true,
(Poll, Poll) => true,
(Sized, Sized) => true,
(TransmuteTrait, TransmuteTrait) => true,
(Tuple, Tuple) => true,
(Unpin, Unpin) => true,
(Unsize, Unsize) => true,
_ => false,
})
} }
fn as_lang_item( #[allow(clippy::match_like_matches_macro)]
self, fn is_lang_item(self, def_id: Self::DefId, lang_item: SolverLangItem) -> bool {
def_id: Self::DefId, use SolverLangItem::*;
) -> Option<rustc_type_ir::lang_items::TraitSolverLangItem> {
use rustc_type_ir::lang_items::TraitSolverLangItem;
// FIXME: derive PartialEq on SolverLangItem
self.as_lang_item(def_id)
.map_or(false, |l| std::mem::discriminant(&l) == std::mem::discriminant(&lang_item))
}
#[allow(clippy::match_like_matches_macro)]
fn is_trait_lang_item(self, def_id: Self::TraitId, lang_item: SolverTraitLangItem) -> bool {
use SolverTraitLangItem::*;
// FIXME: derive PartialEq on SolverTraitLangItem
self.as_trait_lang_item(def_id)
.map_or(false, |l| std::mem::discriminant(&l) == std::mem::discriminant(&lang_item))
}
fn as_lang_item(self, def_id: Self::DefId) -> Option<SolverLangItem> {
let def_id: AttrDefId = match def_id { let def_id: AttrDefId = match def_id {
SolverDefId::TraitId(id) => id.into(), SolverDefId::TraitId(id) => id.into(),
SolverDefId::TypeAliasId(id) => id.into(), SolverDefId::TypeAliasId(id) => id.into(),
SolverDefId::AdtId(id) => id.into(),
_ => panic!("Unexpected SolverDefId in as_lang_item"), _ => panic!("Unexpected SolverDefId in as_lang_item"),
}; };
let lang_item = self.db().lang_attr(def_id)?; let lang_item = self.db().lang_attr(def_id)?;
Some(match lang_item { as_lang_item!(
LangItem::Sized => TraitSolverLangItem::Sized, SolverLangItem, lang_item;
LangItem::MetaSized => TraitSolverLangItem::MetaSized,
LangItem::PointeeSized => TraitSolverLangItem::PointeeSized, ignore = {
LangItem::Unsize => TraitSolverLangItem::Unsize, AsyncFnKindUpvars,
LangItem::StructuralPeq => return None, }
LangItem::StructuralTeq => return None,
LangItem::Copy => TraitSolverLangItem::Copy, Metadata,
LangItem::Clone => TraitSolverLangItem::Clone, DynMetadata,
LangItem::Sync => return None, CoroutineReturn,
LangItem::DiscriminantKind => TraitSolverLangItem::DiscriminantKind, CoroutineYield,
LangItem::Discriminant => return None, Poll,
LangItem::PointeeTrait => TraitSolverLangItem::PointeeTrait, FutureOutput,
LangItem::Metadata => TraitSolverLangItem::Metadata, Option,
LangItem::DynMetadata => TraitSolverLangItem::DynMetadata, AsyncFnOnceOutput,
LangItem::Freeze => return None, CallRefFuture,
LangItem::FnPtrTrait => TraitSolverLangItem::FnPtrTrait, CallOnceFuture,
LangItem::FnPtrAddr => return None, AsyncFnOnceOutput,
LangItem::Drop => TraitSolverLangItem::Drop, )
LangItem::Destruct => TraitSolverLangItem::Destruct, }
LangItem::CoerceUnsized => return None,
LangItem::DispatchFromDyn => return None, fn as_trait_lang_item(self, def_id: Self::TraitId) -> Option<SolverTraitLangItem> {
LangItem::TransmuteOpts => return None, let def_id: AttrDefId = def_id.0.into();
LangItem::TransmuteTrait => TraitSolverLangItem::TransmuteTrait, let lang_item = self.db().lang_attr(def_id)?;
LangItem::Add => return None, as_lang_item!(
LangItem::Sub => return None, SolverTraitLangItem, lang_item;
LangItem::Mul => return None,
LangItem::Div => return None, ignore = {
LangItem::Rem => return None, AsyncFnKindHelper,
LangItem::Neg => return None, AsyncIterator,
LangItem::Not => return None, BikeshedGuaranteedNoDrop,
LangItem::BitXor => return None, FusedIterator,
LangItem::BitAnd => return None, }
LangItem::BitOr => return None,
LangItem::Shl => return None, Sized,
LangItem::Shr => return None, MetaSized,
LangItem::AddAssign => return None, PointeeSized,
LangItem::SubAssign => return None, Unsize,
LangItem::MulAssign => return None, Copy,
LangItem::DivAssign => return None, Clone,
LangItem::RemAssign => return None, DiscriminantKind,
LangItem::BitXorAssign => return None, PointeeTrait,
LangItem::BitAndAssign => return None, FnPtrTrait,
LangItem::BitOrAssign => return None, Drop,
LangItem::ShlAssign => return None, Destruct,
LangItem::ShrAssign => return None, TransmuteTrait,
LangItem::Index => return None, Fn,
LangItem::IndexMut => return None, FnMut,
LangItem::UnsafeCell => return None, FnOnce,
LangItem::VaList => return None, Future,
LangItem::Deref => return None, Coroutine,
LangItem::DerefMut => return None, Unpin,
LangItem::DerefTarget => return None, Tuple,
LangItem::Receiver => return None, Iterator,
LangItem::Fn => TraitSolverLangItem::Fn, AsyncFn,
LangItem::FnMut => TraitSolverLangItem::FnMut, AsyncFnMut,
LangItem::FnOnce => TraitSolverLangItem::FnOnce, AsyncFnOnce,
LangItem::FnOnceOutput => return None, AsyncFnOnceOutput,
LangItem::Future => TraitSolverLangItem::Future, AsyncFnOnceOutput,
LangItem::CoroutineState => return None, )
LangItem::Coroutine => TraitSolverLangItem::Coroutine,
LangItem::CoroutineReturn => TraitSolverLangItem::CoroutineReturn,
LangItem::CoroutineYield => TraitSolverLangItem::CoroutineYield,
LangItem::Unpin => TraitSolverLangItem::Unpin,
LangItem::Pin => return None,
LangItem::PartialEq => return None,
LangItem::PartialOrd => return None,
LangItem::CVoid => return None,
LangItem::Panic => return None,
LangItem::PanicNounwind => return None,
LangItem::PanicFmt => return None,
LangItem::PanicDisplay => return None,
LangItem::ConstPanicFmt => return None,
LangItem::PanicBoundsCheck => return None,
LangItem::PanicMisalignedPointerDereference => return None,
LangItem::PanicInfo => return None,
LangItem::PanicLocation => return None,
LangItem::PanicImpl => return None,
LangItem::PanicCannotUnwind => return None,
LangItem::BeginPanic => return None,
LangItem::FormatAlignment => return None,
LangItem::FormatArgument => return None,
LangItem::FormatArguments => return None,
LangItem::FormatCount => return None,
LangItem::FormatPlaceholder => return None,
LangItem::FormatUnsafeArg => return None,
LangItem::ExchangeMalloc => return None,
LangItem::BoxFree => return None,
LangItem::DropInPlace => return None,
LangItem::AllocLayout => return None,
LangItem::Start => return None,
LangItem::EhPersonality => return None,
LangItem::EhCatchTypeinfo => return None,
LangItem::OwnedBox => return None,
LangItem::PhantomData => return None,
LangItem::ManuallyDrop => return None,
LangItem::MaybeUninit => return None,
LangItem::AlignOffset => return None,
LangItem::Termination => return None,
LangItem::Try => return None,
LangItem::Tuple => TraitSolverLangItem::Tuple,
LangItem::SliceLen => return None,
LangItem::TryTraitFromResidual => return None,
LangItem::TryTraitFromOutput => return None,
LangItem::TryTraitBranch => return None,
LangItem::TryTraitFromYeet => return None,
LangItem::PointerLike => return None,
LangItem::ConstParamTy => return None,
LangItem::Poll => TraitSolverLangItem::Poll,
LangItem::PollReady => return None,
LangItem::PollPending => return None,
LangItem::ResumeTy => return None,
LangItem::GetContext => return None,
LangItem::Context => return None,
LangItem::FuturePoll => return None,
LangItem::FutureOutput => TraitSolverLangItem::FutureOutput,
LangItem::Option => TraitSolverLangItem::Option,
LangItem::OptionSome => return None,
LangItem::OptionNone => return None,
LangItem::ResultOk => return None,
LangItem::ResultErr => return None,
LangItem::ControlFlowContinue => return None,
LangItem::ControlFlowBreak => return None,
LangItem::IntoFutureIntoFuture => return None,
LangItem::IntoIterIntoIter => return None,
LangItem::IteratorNext => return None,
LangItem::Iterator => TraitSolverLangItem::Iterator,
LangItem::PinNewUnchecked => return None,
LangItem::RangeFrom => return None,
LangItem::RangeFull => return None,
LangItem::RangeInclusiveStruct => return None,
LangItem::RangeInclusiveNew => return None,
LangItem::Range => return None,
LangItem::RangeToInclusive => return None,
LangItem::RangeTo => return None,
LangItem::String => return None,
LangItem::CStr => return None,
LangItem::AsyncFn => TraitSolverLangItem::AsyncFn,
LangItem::AsyncFnMut => TraitSolverLangItem::AsyncFnMut,
LangItem::AsyncFnOnce => TraitSolverLangItem::AsyncFnOnce,
LangItem::AsyncFnOnceOutput => TraitSolverLangItem::AsyncFnOnceOutput,
LangItem::CallRefFuture => TraitSolverLangItem::CallRefFuture,
LangItem::CallOnceFuture => TraitSolverLangItem::CallOnceFuture,
LangItem::Ordering => return None,
LangItem::PanicNullPointerDereference => return None,
LangItem::ReceiverTarget => return None,
LangItem::UnsafePinned => return None,
LangItem::AsyncFnOnceOutput => TraitSolverLangItem::AsyncFnOnceOutput,
})
} }
fn associated_type_def_ids(self, def_id: Self::DefId) -> impl IntoIterator<Item = Self::DefId> { fn associated_type_def_ids(self, def_id: Self::DefId) -> impl IntoIterator<Item = Self::DefId> {
@ -1670,15 +1566,11 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
fn for_each_relevant_impl( fn for_each_relevant_impl(
self, self,
trait_def_id: Self::DefId, trait_: Self::TraitId,
self_ty: Self::Ty, self_ty: Self::Ty,
mut f: impl FnMut(Self::DefId), mut f: impl FnMut(Self::DefId),
) { ) {
let trait_ = match trait_def_id { let trait_ = trait_.0;
SolverDefId::TraitId(id) => id,
_ => panic!("for_each_relevant_impl called for non-trait"),
};
let self_ty_fp = TyFingerprint::for_trait_impl_ns(&self_ty); let self_ty_fp = TyFingerprint::for_trait_impl_ns(&self_ty);
let fps: &[TyFingerprint] = match self_ty.kind() { let fps: &[TyFingerprint] = match self_ty.kind() {
TyKind::Infer(InferTy::IntVar(..)) => &ALL_INT_FPS, TyKind::Infer(InferTy::IntVar(..)) => &ALL_INT_FPS,
@ -1775,42 +1667,26 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
} }
} }
fn trait_is_auto(self, trait_def_id: Self::DefId) -> bool { fn trait_is_auto(self, trait_: Self::TraitId) -> bool {
let trait_ = match trait_def_id { let trait_data = self.db().trait_signature(trait_.0);
SolverDefId::TraitId(id) => id,
_ => panic!("Unexpected SolverDefId in trait_is_auto"),
};
let trait_data = self.db().trait_signature(trait_);
trait_data.flags.contains(TraitFlags::AUTO) trait_data.flags.contains(TraitFlags::AUTO)
} }
fn trait_is_alias(self, trait_def_id: Self::DefId) -> bool { fn trait_is_alias(self, trait_: Self::TraitId) -> bool {
let trait_ = match trait_def_id { let trait_data = self.db().trait_signature(trait_.0);
SolverDefId::TraitId(id) => id,
_ => panic!("Unexpected SolverDefId in trait_is_alias"),
};
let trait_data = self.db().trait_signature(trait_);
trait_data.flags.contains(TraitFlags::ALIAS) trait_data.flags.contains(TraitFlags::ALIAS)
} }
fn trait_is_dyn_compatible(self, trait_def_id: Self::DefId) -> bool { fn trait_is_dyn_compatible(self, trait_: Self::TraitId) -> bool {
let trait_ = match trait_def_id { crate::dyn_compatibility::dyn_compatibility(self.db(), trait_.0).is_none()
SolverDefId::TraitId(id) => id,
_ => unreachable!(),
};
crate::dyn_compatibility::dyn_compatibility(self.db(), trait_).is_none()
} }
fn trait_is_fundamental(self, def_id: Self::DefId) -> bool { fn trait_is_fundamental(self, trait_: Self::TraitId) -> bool {
let trait_ = match def_id { let trait_data = self.db().trait_signature(trait_.0);
SolverDefId::TraitId(id) => id,
_ => panic!("Unexpected SolverDefId in trait_is_fundamental"),
};
let trait_data = self.db().trait_signature(trait_);
trait_data.flags.contains(TraitFlags::FUNDAMENTAL) trait_data.flags.contains(TraitFlags::FUNDAMENTAL)
} }
fn trait_may_be_implemented_via_object(self, trait_def_id: Self::DefId) -> bool { fn trait_may_be_implemented_via_object(self, trait_def_id: Self::TraitId) -> bool {
// FIXME(next-solver): should check the `TraitFlags` for // FIXME(next-solver): should check the `TraitFlags` for
// the `#[rustc_do_not_implement_via_object]` flag // the `#[rustc_do_not_implement_via_object]` flag
true true
@ -1920,12 +1796,12 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
(*entry.or_insert_with(|| BoundVarKind::Ty(BoundTyKind::Anon))).expect_ty(); (*entry.or_insert_with(|| BoundVarKind::Ty(BoundTyKind::Anon))).expect_ty();
Ty::new_bound(self.interner, DebruijnIndex::ZERO, BoundTy { var, kind }) Ty::new_bound(self.interner, DebruijnIndex::ZERO, BoundTy { var, kind })
} }
fn replace_const(&mut self, bv: BoundVar) -> Const<'db> { fn replace_const(&mut self, bv: BoundConst) -> Const<'db> {
let entry = self.map.entry(bv); let entry = self.map.entry(bv.var);
let index = entry.index(); let index = entry.index();
let var = BoundVar::from_usize(index); let var = BoundVar::from_usize(index);
let () = (*entry.or_insert_with(|| BoundVarKind::Const)).expect_const(); let () = (*entry.or_insert_with(|| BoundVarKind::Const)).expect_const();
Const::new_bound(self.interner, DebruijnIndex::ZERO, var) Const::new_bound(self.interner, DebruijnIndex::ZERO, BoundConst { var })
} }
} }
@ -2008,24 +1884,16 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
unimplemented!() unimplemented!()
} }
fn is_default_trait(self, def_id: Self::DefId) -> bool { fn is_default_trait(self, def_id: Self::TraitId) -> bool {
self.as_lang_item(def_id).map_or(false, |l| matches!(l, TraitSolverLangItem::Sized)) self.as_trait_lang_item(def_id).map_or(false, |l| matches!(l, SolverTraitLangItem::Sized))
} }
fn trait_is_coinductive(self, trait_def_id: Self::DefId) -> bool { fn trait_is_coinductive(self, trait_: Self::TraitId) -> bool {
let id = match trait_def_id { self.db().trait_signature(trait_.0).flags.contains(TraitFlags::COINDUCTIVE)
SolverDefId::TraitId(id) => id,
_ => unreachable!(),
};
self.db().trait_signature(id).flags.contains(TraitFlags::COINDUCTIVE)
} }
fn trait_is_unsafe(self, trait_def_id: Self::DefId) -> bool { fn trait_is_unsafe(self, trait_: Self::TraitId) -> bool {
let id = match trait_def_id { self.db().trait_signature(trait_.0).flags.contains(TraitFlags::UNSAFE)
SolverDefId::TraitId(id) => id,
_ => unreachable!(),
};
self.db().trait_signature(id).flags.contains(TraitFlags::UNSAFE)
} }
fn impl_self_is_guaranteed_unsized(self, def_id: Self::DefId) -> bool { fn impl_self_is_guaranteed_unsized(self, def_id: Self::DefId) -> bool {
@ -2047,6 +1915,20 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
// FIXME(next-solver) // FIXME(next-solver)
unimplemented!() unimplemented!()
} }
type Probe = rustc_type_ir::solve::inspect::Probe<DbInterner<'db>>;
fn mk_probe(self, probe: rustc_type_ir::solve::inspect::Probe<Self>) -> Self::Probe {
probe
}
fn evaluate_root_goal_for_proof_tree_raw(
self,
canonical_goal: rustc_type_ir::solve::CanonicalInput<Self>,
) -> (rustc_type_ir::solve::QueryResult<Self>, Self::Probe) {
rustc_next_trait_solver::solve::evaluate_root_goal_for_proof_tree_raw_provider::<
SolverContext<'db>,
Self,
>(self, canonical_goal)
}
} }
impl<'db> DbInterner<'db> { impl<'db> DbInterner<'db> {
@ -2072,7 +1954,9 @@ impl<'db> DbInterner<'db> {
BoundTy { var: shift_bv(t.var), kind: t.kind }, BoundTy { var: shift_bv(t.var), kind: t.kind },
) )
}, },
consts: &mut |c| Const::new_bound(self, DebruijnIndex::ZERO, shift_bv(c)), consts: &mut |c| {
Const::new_bound(self, DebruijnIndex::ZERO, BoundConst { var: shift_bv(c.var) })
},
}, },
) )
} }
@ -2135,6 +2019,7 @@ macro_rules! TrivialTypeTraversalImpls {
TrivialTypeTraversalImpls! { TrivialTypeTraversalImpls! {
SolverDefId, SolverDefId,
TraitIdWrapper,
Pattern<'db>, Pattern<'db>,
Safety, Safety,
FnAbi, FnAbi,

10
crates/hir-ty/src/next_solver/ir_print.rs
View file

@ -58,10 +58,7 @@ impl<'db> IrPrint<ty::TraitRef<Self>> for DbInterner<'db> {
fn print_debug(t: &ty::TraitRef<Self>, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { fn print_debug(t: &ty::TraitRef<Self>, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
salsa::with_attached_database(|db| { salsa::with_attached_database(|db| {
let trait_ = match t.def_id { let trait_ = t.def_id.0;
SolverDefId::TraitId(id) => id,
_ => panic!("Expected trait."),
};
let self_ty = &t.args.as_slice()[0]; let self_ty = &t.args.as_slice()[0];
let trait_args = &t.args.as_slice()[1..]; let trait_args = &t.args.as_slice()[1..];
if trait_args.is_empty() { if trait_args.is_empty() {
@ -122,10 +119,7 @@ impl<'db> IrPrint<ty::ExistentialTraitRef<Self>> for DbInterner<'db> {
fmt: &mut std::fmt::Formatter<'_>, fmt: &mut std::fmt::Formatter<'_>,
) -> std::fmt::Result { ) -> std::fmt::Result {
salsa::with_attached_database(|db| { salsa::with_attached_database(|db| {
let trait_ = match t.def_id { let trait_ = t.def_id.0;
SolverDefId::TraitId(id) => id,
_ => panic!("Expected trait."),
};
fmt.write_str(&format!( fmt.write_str(&format!(
"ExistentialTraitRef({:?}[{:?}])", "ExistentialTraitRef({:?}[{:?}])",
db.as_view::<dyn HirDatabase>().trait_signature(trait_).name.as_str(), db.as_view::<dyn HirDatabase>().trait_signature(trait_).name.as_str(),

32
crates/hir-ty/src/next_solver/mapping.rs
View file

@ -22,6 +22,7 @@ use rustc_type_ir::{
use salsa::plumbing::FromId; use salsa::plumbing::FromId;
use salsa::{Id, plumbing::AsId}; use salsa::{Id, plumbing::AsId};
use crate::next_solver::BoundConst;
use crate::{ use crate::{
ConcreteConst, ConstScalar, ImplTraitId, Interner, MemoryMap, ConcreteConst, ConstScalar, ImplTraitId, Interner, MemoryMap,
db::{ db::{
@ -125,12 +126,12 @@ impl<'db> rustc_type_ir::TypeFolder<DbInterner<'db>> for BinderToEarlyBinder<'db
fn fold_const(&mut self, c: Const<'db>) -> Const<'db> { fn fold_const(&mut self, c: Const<'db>) -> Const<'db> {
match c.kind() { match c.kind() {
rustc_type_ir::ConstKind::Bound(debruijn, var) if self.debruijn == debruijn => { rustc_type_ir::ConstKind::Bound(debruijn, var) if self.debruijn == debruijn => {
let GenericParamId::ConstParamId(id) = self.params[var.as_usize()] else { let GenericParamId::ConstParamId(id) = self.params[var.var.as_usize()] else {
unreachable!() unreachable!()
}; };
Const::new( Const::new(
self.cx(), self.cx(),
rustc_type_ir::ConstKind::Param(ParamConst { index: var.as_u32(), id }), rustc_type_ir::ConstKind::Param(ParamConst { index: var.var.as_u32(), id }),
) )
} }
_ => c.super_fold_with(self), _ => c.super_fold_with(self),
@ -286,11 +287,8 @@ impl<'db> ChalkToNextSolver<'db, Ty<'db>> for chalk_ir::Ty<Interner> {
.flags .flags
.contains(TraitFlags::AUTO) .contains(TraitFlags::AUTO)
{ {
ExistentialPredicate::AutoTrait(SolverDefId::TraitId( ExistentialPredicate::AutoTrait(trait_id.into())
trait_id,
))
} else { } else {
let def_id = SolverDefId::TraitId(trait_id);
let args = GenericArgs::new_from_iter( let args = GenericArgs::new_from_iter(
interner, interner,
trait_ref trait_ref
@ -301,7 +299,7 @@ impl<'db> ChalkToNextSolver<'db, Ty<'db>> for chalk_ir::Ty<Interner> {
.map(|a| a.to_nextsolver(interner)), .map(|a| a.to_nextsolver(interner)),
); );
let trait_ref = ExistentialTraitRef::new_from_args( let trait_ref = ExistentialTraitRef::new_from_args(
interner, def_id, args, interner, trait_id.into(), args,
); );
ExistentialPredicate::Trait(trait_ref) ExistentialPredicate::Trait(trait_ref)
} }
@ -473,7 +471,7 @@ impl<'db> ChalkToNextSolver<'db, Const<'db>> for chalk_ir::Const<Interner> {
match &data.value { match &data.value {
chalk_ir::ConstValue::BoundVar(bound_var) => rustc_type_ir::ConstKind::Bound( chalk_ir::ConstValue::BoundVar(bound_var) => rustc_type_ir::ConstKind::Bound(
bound_var.debruijn.to_nextsolver(interner), bound_var.debruijn.to_nextsolver(interner),
rustc_type_ir::BoundVar::from_usize(bound_var.index), BoundConst { var: rustc_type_ir::BoundVar::from_usize(bound_var.index) },
), ),
chalk_ir::ConstValue::InferenceVar(inference_var) => { chalk_ir::ConstValue::InferenceVar(inference_var) => {
rustc_type_ir::ConstKind::Infer(rustc_type_ir::InferConst::Var( rustc_type_ir::ConstKind::Infer(rustc_type_ir::InferConst::Var(
@ -871,11 +869,7 @@ impl<'db> ChalkToNextSolver<'db, PredicateKind<'db>> for chalk_ir::DomainGoal<In
impl<'db> ChalkToNextSolver<'db, TraitRef<'db>> for chalk_ir::TraitRef<Interner> { impl<'db> ChalkToNextSolver<'db, TraitRef<'db>> for chalk_ir::TraitRef<Interner> {
fn to_nextsolver(&self, interner: DbInterner<'db>) -> TraitRef<'db> { fn to_nextsolver(&self, interner: DbInterner<'db>) -> TraitRef<'db> {
let args = self.substitution.to_nextsolver(interner); let args = self.substitution.to_nextsolver(interner);
TraitRef::new_from_args( TraitRef::new_from_args(interner, from_chalk_trait_id(self.trait_id).into(), args)
interner,
SolverDefId::TraitId(from_chalk_trait_id(self.trait_id)),
args,
)
} }
} }
@ -1207,20 +1201,14 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
trait_ref.def_id, trait_ref.def_id,
[self_ty.into()].into_iter().chain(trait_ref.args.iter()), [self_ty.into()].into_iter().chain(trait_ref.args.iter()),
); );
let trait_id = match trait_ref.def_id { let trait_id = to_chalk_trait_id(trait_ref.def_id.0);
SolverDefId::TraitId(id) => to_chalk_trait_id(id),
_ => unreachable!(),
};
let substitution = let substitution =
convert_args_for_result(interner, trait_ref.args.as_slice()); convert_args_for_result(interner, trait_ref.args.as_slice());
let trait_ref = chalk_ir::TraitRef { trait_id, substitution }; let trait_ref = chalk_ir::TraitRef { trait_id, substitution };
chalk_ir::WhereClause::Implemented(trait_ref) chalk_ir::WhereClause::Implemented(trait_ref)
} }
rustc_type_ir::ExistentialPredicate::AutoTrait(trait_) => { rustc_type_ir::ExistentialPredicate::AutoTrait(trait_) => {
let trait_id = match trait_ { let trait_id = to_chalk_trait_id(trait_.0);
SolverDefId::TraitId(id) => to_chalk_trait_id(id),
_ => unreachable!(),
};
let substitution = chalk_ir::Substitution::from1( let substitution = chalk_ir::Substitution::from1(
Interner, Interner,
convert_ty_for_result(interner, self_ty), convert_ty_for_result(interner, self_ty),
@ -1354,7 +1342,7 @@ pub fn convert_const_for_result<'db>(
rustc_type_ir::ConstKind::Bound(debruijn_index, var) => { rustc_type_ir::ConstKind::Bound(debruijn_index, var) => {
chalk_ir::ConstValue::BoundVar(chalk_ir::BoundVar::new( chalk_ir::ConstValue::BoundVar(chalk_ir::BoundVar::new(
chalk_ir::DebruijnIndex::new(debruijn_index.as_u32()), chalk_ir::DebruijnIndex::new(debruijn_index.as_u32()),
var.index(), var.var.index(),
)) ))
} }
rustc_type_ir::ConstKind::Placeholder(placeholder_const) => { rustc_type_ir::ConstKind::Placeholder(placeholder_const) => {

8
crates/hir-ty/src/next_solver/predicate.rs
View file

@ -15,6 +15,8 @@ use rustc_type_ir::{
}; };
use smallvec::{SmallVec, smallvec}; use smallvec::{SmallVec, smallvec};
use crate::next_solver::TraitIdWrapper;
use super::{Binder, BoundVarKinds, DbInterner, Region, Ty, interned_vec_db}; use super::{Binder, BoundVarKinds, DbInterner, Region, Ty, interned_vec_db};
pub type BoundExistentialPredicate<'db> = Binder<'db, ExistentialPredicate<'db>>; pub type BoundExistentialPredicate<'db> = Binder<'db, ExistentialPredicate<'db>>;
@ -72,7 +74,7 @@ interned_vec_db!(BoundExistentialPredicates, BoundExistentialPredicate);
impl<'db> rustc_type_ir::inherent::BoundExistentialPredicates<DbInterner<'db>> impl<'db> rustc_type_ir::inherent::BoundExistentialPredicates<DbInterner<'db>>
for BoundExistentialPredicates<'db> for BoundExistentialPredicates<'db>
{ {
fn principal_def_id(self) -> Option<<DbInterner<'db> as rustc_type_ir::Interner>::DefId> { fn principal_def_id(self) -> Option<TraitIdWrapper> {
self.principal().map(|trait_ref| trait_ref.skip_binder().def_id) self.principal().map(|trait_ref| trait_ref.skip_binder().def_id)
} }
@ -89,9 +91,7 @@ impl<'db> rustc_type_ir::inherent::BoundExistentialPredicates<DbInterner<'db>>
.transpose() .transpose()
} }
fn auto_traits( fn auto_traits(self) -> impl IntoIterator<Item = TraitIdWrapper> {
self,
) -> impl IntoIterator<Item = <DbInterner<'db> as rustc_type_ir::Interner>::DefId> {
self.iter().filter_map(|predicate| match predicate.skip_binder() { self.iter().filter_map(|predicate| match predicate.skip_binder() {
ExistentialPredicate::AutoTrait(did) => Some(did), ExistentialPredicate::AutoTrait(did) => Some(did),
_ => None, _ => None,

8
crates/hir-ty/src/next_solver/solver.rs
View file

@ -2,10 +2,10 @@
use hir_def::{AssocItemId, GeneralConstId, TypeAliasId}; use hir_def::{AssocItemId, GeneralConstId, TypeAliasId};
use rustc_next_trait_solver::delegate::SolverDelegate; use rustc_next_trait_solver::delegate::SolverDelegate;
use rustc_type_ir::lang_items::SolverTraitLangItem;
use rustc_type_ir::{ use rustc_type_ir::{
InferCtxtLike, Interner, PredicatePolarity, TypeFlags, TypeVisitableExt, UniverseIndex, InferCtxtLike, Interner, PredicatePolarity, TypeFlags, TypeVisitableExt, UniverseIndex,
inherent::{IntoKind, SliceLike, Span as _, Term as _, Ty as _}, inherent::{IntoKind, SliceLike, Span as _, Term as _, Ty as _},
lang_items::TraitSolverLangItem,
solve::{Certainty, NoSolution}, solve::{Certainty, NoSolution},
}; };
@ -225,14 +225,14 @@ impl<'db> SolverDelegate for SolverContext<'db> {
} }
if trait_pred.polarity() == PredicatePolarity::Positive { if trait_pred.polarity() == PredicatePolarity::Positive {
match self.0.cx().as_lang_item(trait_pred.def_id()) { match self.0.cx().as_trait_lang_item(trait_pred.def_id()) {
Some(TraitSolverLangItem::Sized) | Some(TraitSolverLangItem::MetaSized) => { Some(SolverTraitLangItem::Sized) | Some(SolverTraitLangItem::MetaSized) => {
let predicate = self.resolve_vars_if_possible(goal.predicate); let predicate = self.resolve_vars_if_possible(goal.predicate);
if sizedness_fast_path(self.cx(), predicate, goal.param_env) { if sizedness_fast_path(self.cx(), predicate, goal.param_env) {
return Some(Certainty::Yes); return Some(Certainty::Yes);
} }
} }
Some(TraitSolverLangItem::Copy | TraitSolverLangItem::Clone) => { Some(SolverTraitLangItem::Copy | SolverTraitLangItem::Clone) => {
let self_ty = let self_ty =
self.resolve_vars_if_possible(trait_pred.self_ty().skip_binder()); self.resolve_vars_if_possible(trait_pred.self_ty().skip_binder());
// Unlike `Sized` traits, which always prefer the built-in impl, // Unlike `Sized` traits, which always prefer the built-in impl,

27
crates/hir-ty/src/next_solver/ty.rs
View file

@ -4,6 +4,7 @@ use hir_def::{GenericDefId, TypeOrConstParamId, TypeParamId};
use intern::{Interned, Symbol, sym}; use intern::{Interned, Symbol, sym};
use rustc_abi::{Float, Integer, Size}; use rustc_abi::{Float, Integer, Size};
use rustc_ast_ir::{Mutability, try_visit, visit::VisitorResult}; use rustc_ast_ir::{Mutability, try_visit, visit::VisitorResult};
use rustc_type_ir::Interner;
use rustc_type_ir::{ use rustc_type_ir::{
BoundVar, ClosureKind, FlagComputation, Flags, FloatTy, FloatVid, InferTy, IntTy, IntVid, BoundVar, ClosureKind, FlagComputation, Flags, FloatTy, FloatVid, InferTy, IntTy, IntVid,
TypeFoldable, TypeSuperFoldable, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, UintTy, TypeFoldable, TypeSuperFoldable, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, UintTy,
@ -19,6 +20,7 @@ use rustc_type_ir::{
use salsa::plumbing::{AsId, FromId}; use salsa::plumbing::{AsId, FromId};
use smallvec::SmallVec; use smallvec::SmallVec;
use crate::next_solver::GenericArg;
use crate::{ use crate::{
db::HirDatabase, db::HirDatabase,
interner::InternedWrapperNoDebug, interner::InternedWrapperNoDebug,
@ -645,6 +647,31 @@ impl<'db> rustc_type_ir::inherent::Ty<DbInterner<'db>> for Ty<'db> {
Ty::new(interner, TyKind::CoroutineWitness(def_id, args)) Ty::new(interner, TyKind::CoroutineWitness(def_id, args))
} }
fn new_coroutine_witness_for_coroutine(
interner: DbInterner<'db>,
def_id: <DbInterner<'db> as rustc_type_ir::Interner>::DefId,
coroutine_args: <DbInterner<'db> as rustc_type_ir::Interner>::GenericArgs,
) -> Self {
// HACK: Coroutine witness types are lifetime erased, so they
// never reference any lifetime args from the coroutine. We erase
// the regions here since we may get into situations where a
// coroutine is recursively contained within itself, leading to
// witness types that differ by region args. This means that
// cycle detection in fulfillment will not kick in, which leads
// to unnecessary overflows in async code. See the issue:
// <https://github.com/rust-lang/rust/issues/145151>.
let coroutine_args = interner.mk_args_from_iter(coroutine_args.iter().map(|arg| {
match arg {
GenericArg::Ty(_) | GenericArg::Const(_) => arg,
GenericArg::Lifetime(_) => {
crate::next_solver::Region::new(interner, rustc_type_ir::RegionKind::ReErased)
.into()
}
}
}));
Ty::new_coroutine_witness(interner, def_id, coroutine_args)
}
fn new_ptr(interner: DbInterner<'db>, ty: Self, mutbl: rustc_ast_ir::Mutability) -> Self { fn new_ptr(interner: DbInterner<'db>, ty: Self, mutbl: rustc_ast_ir::Mutability) -> Self {
Ty::new(interner, TyKind::RawPtr(ty, mutbl)) Ty::new(interner, TyKind::RawPtr(ty, mutbl))
} }

28
crates/hir-ty/src/next_solver/util.rs
View file

@ -14,7 +14,7 @@ use rustc_type_ir::inherent::{
AdtDef, Const as _, GenericArg as _, GenericArgs as _, ParamEnv as _, Region as _, SliceLike, AdtDef, Const as _, GenericArg as _, GenericArgs as _, ParamEnv as _, Region as _, SliceLike,
Ty as _, Ty as _,
}; };
use rustc_type_ir::lang_items::TraitSolverLangItem; use rustc_type_ir::lang_items::SolverTraitLangItem;
use rustc_type_ir::solve::SizedTraitKind; use rustc_type_ir::solve::SizedTraitKind;
use rustc_type_ir::{ use rustc_type_ir::{
BoundVar, Canonical, DebruijnIndex, GenericArgKind, INNERMOST, Interner, PredicatePolarity, BoundVar, Canonical, DebruijnIndex, GenericArgKind, INNERMOST, Interner, PredicatePolarity,
@ -29,8 +29,8 @@ use rustc_type_ir::{InferCtxtLike, TypeFoldable};
use crate::lower_nextsolver::{LifetimeElisionKind, TyLoweringContext}; use crate::lower_nextsolver::{LifetimeElisionKind, TyLoweringContext};
use crate::next_solver::infer::InferCtxt; use crate::next_solver::infer::InferCtxt;
use crate::next_solver::{ use crate::next_solver::{
CanonicalVarKind, FxIndexMap, ParamEnv, Placeholder, PlaceholderConst, PlaceholderRegion, BoundConst, CanonicalVarKind, FxIndexMap, ParamEnv, Placeholder, PlaceholderConst,
TypingMode, PlaceholderRegion, TypingMode,
}; };
use crate::{ use crate::{
db::HirDatabase, db::HirDatabase,
@ -511,7 +511,7 @@ pub fn apply_args_to_binder<'db, T: TypeFoldable<DbInterner<'db>>>(
) -> T { ) -> T {
let types = &mut |ty: BoundTy| args.as_slice()[ty.var.index()].expect_ty(); let types = &mut |ty: BoundTy| args.as_slice()[ty.var.index()].expect_ty();
let regions = &mut |region: BoundRegion| args.as_slice()[region.var.index()].expect_region(); let regions = &mut |region: BoundRegion| args.as_slice()[region.var.index()].expect_region();
let consts = &mut |const_: BoundVar| args.as_slice()[const_.index()].expect_const(); let consts = &mut |const_: BoundConst| args.as_slice()[const_.var.index()].expect_const();
let mut instantiate = BoundVarReplacer::new(interner, FnMutDelegate { types, regions, consts }); let mut instantiate = BoundVarReplacer::new(interner, FnMutDelegate { types, regions, consts });
b.skip_binder().fold_with(&mut instantiate) b.skip_binder().fold_with(&mut instantiate)
} }
@ -654,7 +654,10 @@ impl<'db> TypeFolder<DbInterner<'db>> for MiniCanonicalizer<'_, 'db> {
ConstKind::Infer(infer) => { ConstKind::Infer(infer) => {
let len = self.vars.len(); let len = self.vars.len();
let var = *self.vars.entry(c.into()).or_insert(len); let var = *self.vars.entry(c.into()).or_insert(len);
Const::new(self.cx(), ConstKind::Bound(self.db, BoundVar::from_usize(var))) Const::new(
self.cx(),
ConstKind::Bound(self.db, BoundConst { var: BoundVar::from_usize(var) }),
)
} }
_ => c.super_fold_with(self), _ => c.super_fold_with(self),
} }
@ -852,7 +855,7 @@ pub struct PlaceholderReplacer<'a, 'db> {
infcx: &'a InferCtxt<'db>, infcx: &'a InferCtxt<'db>,
mapped_regions: FxIndexMap<PlaceholderRegion, BoundRegion>, mapped_regions: FxIndexMap<PlaceholderRegion, BoundRegion>,
mapped_types: FxIndexMap<Placeholder<BoundTy>, BoundTy>, mapped_types: FxIndexMap<Placeholder<BoundTy>, BoundTy>,
mapped_consts: FxIndexMap<PlaceholderConst, BoundVar>, mapped_consts: FxIndexMap<PlaceholderConst, BoundConst>,
universe_indices: &'a [Option<UniverseIndex>], universe_indices: &'a [Option<UniverseIndex>],
current_index: DebruijnIndex, current_index: DebruijnIndex,
} }
@ -862,7 +865,7 @@ impl<'a, 'db> PlaceholderReplacer<'a, 'db> {
infcx: &'a InferCtxt<'db>, infcx: &'a InferCtxt<'db>,
mapped_regions: FxIndexMap<PlaceholderRegion, BoundRegion>, mapped_regions: FxIndexMap<PlaceholderRegion, BoundRegion>,
mapped_types: FxIndexMap<Placeholder<BoundTy>, BoundTy>, mapped_types: FxIndexMap<Placeholder<BoundTy>, BoundTy>,
mapped_consts: FxIndexMap<PlaceholderConst, BoundVar>, mapped_consts: FxIndexMap<PlaceholderConst, BoundConst>,
universe_indices: &'a [Option<UniverseIndex>], universe_indices: &'a [Option<UniverseIndex>],
value: T, value: T,
) -> T { ) -> T {
@ -1026,9 +1029,9 @@ pub fn sizedness_fast_path<'db>(
if let PredicateKind::Clause(ClauseKind::Trait(trait_pred)) = predicate.kind().skip_binder() if let PredicateKind::Clause(ClauseKind::Trait(trait_pred)) = predicate.kind().skip_binder()
&& trait_pred.polarity == PredicatePolarity::Positive && trait_pred.polarity == PredicatePolarity::Positive
{ {
let sizedness = match tcx.as_lang_item(trait_pred.def_id()) { let sizedness = match tcx.as_trait_lang_item(trait_pred.def_id()) {
Some(TraitSolverLangItem::Sized) => SizedTraitKind::Sized, Some(SolverTraitLangItem::Sized) => SizedTraitKind::Sized,
Some(TraitSolverLangItem::MetaSized) => SizedTraitKind::MetaSized, Some(SolverTraitLangItem::MetaSized) => SizedTraitKind::MetaSized,
_ => return false, _ => return false,
}; };
@ -1051,7 +1054,10 @@ pub fn sizedness_fast_path<'db>(
&& clause_pred.self_ty() == trait_pred.self_ty() && clause_pred.self_ty() == trait_pred.self_ty()
&& (clause_pred.def_id() == trait_pred.def_id() && (clause_pred.def_id() == trait_pred.def_id()
|| (sizedness == SizedTraitKind::MetaSized || (sizedness == SizedTraitKind::MetaSized
&& tcx.is_lang_item(clause_pred.def_id(), TraitSolverLangItem::Sized))) && tcx.is_trait_lang_item(
clause_pred.def_id(),
SolverTraitLangItem::Sized,
)))
{ {
return true; return true;
} }

5
crates/hir-ty/src/utils.rs
View file

@ -212,10 +212,7 @@ fn direct_super_trait_refs(db: &dyn HirDatabase, trait_ref: &TraitRef, cb: impl
rustc_type_ir::ClauseKind::Trait(t) => { rustc_type_ir::ClauseKind::Trait(t) => {
let t = let t =
rustc_type_ir::EarlyBinder::bind(t).instantiate(interner, trait_ref_args); rustc_type_ir::EarlyBinder::bind(t).instantiate(interner, trait_ref_args);
let trait_id = match t.def_id() { let trait_id = to_chalk_trait_id(t.def_id().0);
crate::next_solver::SolverDefId::TraitId(id) => to_chalk_trait_id(id),
_ => unreachable!(),
};
let substitution = let substitution =
convert_args_for_result(interner, t.trait_ref.args.as_slice()); convert_args_for_result(interner, t.trait_ref.args.as_slice());

29
crates/hir/src/lib.rs
View file

@ -86,8 +86,7 @@ use hir_ty::{
method_resolution, method_resolution,
mir::{MutBorrowKind, interpret_mir}, mir::{MutBorrowKind, interpret_mir},
next_solver::{ next_solver::{
ClauseKind, DbInterner, GenericArgs, SolverDefId, infer::InferCtxt, ClauseKind, DbInterner, GenericArgs, infer::InferCtxt, mapping::ChalkToNextSolver,
mapping::ChalkToNextSolver,
}, },
primitive::UintTy, primitive::UintTy,
traits::FnTrait, traits::FnTrait,
@ -4251,13 +4250,7 @@ impl TypeParam {
db.generic_predicates_for_param_ns(self.id.parent(), self.id.into(), None) db.generic_predicates_for_param_ns(self.id.parent(), self.id.into(), None)
.iter() .iter()
.filter_map(|pred| match &pred.kind().skip_binder() { .filter_map(|pred| match &pred.kind().skip_binder() {
ClauseKind::Trait(trait_ref) => { ClauseKind::Trait(trait_ref) => Some(Trait::from(trait_ref.def_id().0)),
let trait_ = match trait_ref.def_id() {
SolverDefId::TraitId(t) => t,
_ => unreachable!(),
};
Some(Trait::from(trait_))
}
_ => None, _ => None,
}) })
.collect() .collect()
@ -4515,11 +4508,7 @@ impl Impl {
pub fn trait_(self, db: &dyn HirDatabase) -> Option<Trait> { pub fn trait_(self, db: &dyn HirDatabase) -> Option<Trait> {
let trait_ref = db.impl_trait_ns(self.id)?; let trait_ref = db.impl_trait_ns(self.id)?;
let id = trait_ref.skip_binder().def_id; let id = trait_ref.skip_binder().def_id;
let id = match id { Some(Trait { id: id.0 })
SolverDefId::TraitId(id) => id,
_ => unreachable!(),
};
Some(Trait { id })
} }
pub fn trait_ref(self, db: &dyn HirDatabase) -> Option<TraitRef<'_>> { pub fn trait_ref(self, db: &dyn HirDatabase) -> Option<TraitRef<'_>> {
@ -4609,11 +4598,7 @@ impl<'db> TraitRef<'db> {
} }
pub fn trait_(&self) -> Trait { pub fn trait_(&self) -> Trait {
let id = match self.trait_ref.def_id { Trait { id: self.trait_ref.def_id.0 }
SolverDefId::TraitId(id) => id,
_ => unreachable!(),
};
Trait { id }
} }
pub fn self_ty(&self) -> TypeNs<'_> { pub fn self_ty(&self) -> TypeNs<'_> {
@ -5984,11 +5969,7 @@ impl<'db> TypeNs<'db> {
infcx.interner, infcx.interner,
[self.ty].into_iter().chain(args.iter().map(|t| t.ty)).map(|t| t.into()), [self.ty].into_iter().chain(args.iter().map(|t| t.ty)).map(|t| t.into()),
); );
let trait_ref = hir_ty::next_solver::TraitRef::new( let trait_ref = hir_ty::next_solver::TraitRef::new(infcx.interner, trait_.id.into(), args);
infcx.interner,
SolverDefId::TraitId(trait_.id),
args,
);
let pred_kind = rustc_type_ir::Binder::dummy(rustc_type_ir::PredicateKind::Clause( let pred_kind = rustc_type_ir::Binder::dummy(rustc_type_ir::PredicateKind::Clause(
rustc_type_ir::ClauseKind::Trait(rustc_type_ir::TraitPredicate { rustc_type_ir::ClauseKind::Trait(rustc_type_ir::TraitPredicate {