language-servers/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-11-01 20:31:59 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

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

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

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

@ -2,12 +2,11 @@
use std::ops::ControlFlow;
use hir_def::hir::generics::LocalTypeOrConstParamId;
use hir_def::{
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 rustc_hash::FxHashSet;
use rustc_type_ir::{
@ -22,7 +21,7 @@ use crate::{
db::{HirDatabase, InternedOpaqueTyId},
lower_nextsolver::associated_ty_item_bounds,
next_solver::{
Clause, Clauses, DbInterner, GenericArgs, ParamEnv, SolverDefId, TraitPredicate,
Clause, Clauses, DbInterner, GenericArgs, ParamEnv, SolverDefId, TraitPredicate, TraitRef,
TypingMode, infer::DbInternerInferExt, mk_param,
},
traits::next_trait_solve_in_ctxt,
@ -56,16 +55,12 @@ pub fn dyn_compatibility(
trait_: TraitId,
) -> Option<DynCompatibilityViolation> {
let interner = DbInterner::new_with(db, Some(trait_.krate(db)), None);
for super_trait in elaborate::supertrait_def_ids(interner, SolverDefId::TraitId(trait_)) {
let super_trait = match super_trait {
SolverDefId::TraitId(id) => id,
_ => unreachable!(),
};
if let Some(v) = db.dyn_compatibility_of_trait(super_trait) {
return if super_trait == trait_ {
for super_trait in elaborate::supertrait_def_ids(interner, trait_.into()) {
if let Some(v) = db.dyn_compatibility_of_trait(super_trait.0) {
return if super_trait.0 == trait_ {
Some(v)
} else {
Some(DynCompatibilityViolation::HasNonCompatibleSuperTrait(super_trait))
Some(DynCompatibilityViolation::HasNonCompatibleSuperTrait(super_trait.0))
};
}
}
@ -82,13 +77,8 @@ where
F: FnMut(DynCompatibilityViolation) -> ControlFlow<()>,
{
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)
{
let super_trait = match super_trait {
SolverDefId::TraitId(id) => id,
_ => unreachable!(),
};
if db.dyn_compatibility_of_trait(super_trait).is_some() {
for super_trait in elaborate::supertrait_def_ids(interner, trait_.into()).skip(1) {
if db.dyn_compatibility_of_trait(super_trait.0).is_some() {
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| {
match pred.kind().skip_binder() {
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) =
trait_pred.trait_ref.self_ty().kind()
&& param_ty.index == 0
@ -257,15 +247,9 @@ fn contains_illegal_self_type_reference<'db, T: rustc_type_ir::TypeVisitable<DbI
};
if self.super_traits.is_none() {
self.super_traits = Some(
elaborate::supertrait_def_ids(
interner,
SolverDefId::TraitId(self.trait_),
)
.map(|super_trait| match super_trait {
SolverDefId::TraitId(id) => id,
_ => unreachable!(),
})
.collect(),
elaborate::supertrait_def_ids(interner, self.trait_.into())
.map(|super_trait| super_trait.0)
.collect(),
)
}
if self.super_traits.as_ref().is_some_and(|s| s.contains(&trait_)) {
@ -390,8 +374,7 @@ where
trait_ref: pred_trait_ref,
polarity: PredicatePolarity::Positive,
}) = pred
&& let SolverDefId::TraitId(trait_id) = pred_trait_ref.def_id
&& let trait_data = db.trait_signature(trait_id)
&& let trait_data = db.trait_signature(pred_trait_ref.def_id.0)
&& trait_data.flags.contains(TraitFlags::AUTO)
&& let rustc_type_ir::TyKind::Param(crate::next_solver::ParamTy { index: 0, .. }) =
pred_trait_ref.self_ty().kind()
@ -464,25 +447,17 @@ fn receiver_is_dispatchable<'db>(
let generic_predicates = &*db.generic_predicates_ns(func.into());
// Self: Unsize<U>
let unsize_predicate = crate::next_solver::TraitRef::new(
interner,
SolverDefId::TraitId(unsize_did),
[self_param_ty, unsized_self_ty],
);
let unsize_predicate =
TraitRef::new(interner, unsize_did.into(), [self_param_ty, unsized_self_ty]);
// U: Trait<Arg1, ..., ArgN>
let trait_def_id = SolverDefId::TraitId(trait_);
let args = GenericArgs::for_item(interner, trait_def_id, |name, index, kind, _| {
let args = GenericArgs::for_item(interner, trait_.into(), |name, index, kind, _| {
if index == 0 { unsized_self_ty.into() } else { mk_param(interner, index, name, kind) }
});
let trait_predicate =
crate::next_solver::TraitRef::new_from_args(interner, trait_def_id, args);
let trait_predicate = TraitRef::new_from_args(interner, trait_.into(), args);
let meta_sized_predicate = crate::next_solver::TraitRef::new(
interner,
SolverDefId::TraitId(meta_sized_did),
[unsized_self_ty],
);
let meta_sized_predicate =
TraitRef::new(interner, meta_sized_did.into(), [unsized_self_ty]);
ParamEnv {
clauses: Clauses::new_from_iter(
@ -497,11 +472,8 @@ fn receiver_is_dispatchable<'db>(
};
// Receiver: DispatchFromDyn<Receiver[Self => U]>
let predicate = crate::next_solver::TraitRef::new(
interner,
SolverDefId::TraitId(dispatch_from_dyn_did),
[receiver_ty, unsized_receiver_ty],
);
let predicate =
TraitRef::new(interner, dispatch_from_dyn_did.into(), [receiver_ty, unsized_receiver_ty]);
let goal = crate::next_solver::Goal::new(interner, param_env, predicate);
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());
let pointee_sized = LangItem::PointeeSized
.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
} else if pointee_sized
.is_some_and(|it| SolverDefId::TraitId(it) == trait_ref.def_id)
{
} else if pointee_sized.is_some_and(|it| it == trait_ref.def_id.0) {
// Regard this as `?Sized` bound
ctx.ty_ctx().unsized_types.insert(self_ty);
} else {
@ -618,13 +616,9 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
// Don't lower associated type bindings as the only possible relaxed trait bound
// `?Sized` has no of them.
// If we got another trait here ignore the bound completely.
let trait_id =
self.lower_trait_ref_from_path(path, self_ty).map(|(trait_ref, _)| {
match trait_ref.def_id {
SolverDefId::TraitId(id) => id,
_ => unreachable!(),
}
});
let trait_id = self
.lower_trait_ref_from_path(path, self_ty)
.map(|(trait_ref, _)| trait_ref.def_id.0);
if trait_id == sized_trait {
self.unsized_types.insert(self_ty);
}
@ -668,12 +662,8 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
.map_bound(|c| match c {
rustc_type_ir::ClauseKind::Trait(t) => {
let id = t.def_id();
let id = match id {
SolverDefId::TraitId(id) => id,
_ => unreachable!(),
};
let is_auto =
db.trait_signature(id).flags.contains(TraitFlags::AUTO);
db.trait_signature(id.0).flags.contains(TraitFlags::AUTO);
if is_auto {
Some(ExistentialPredicate::AutoTrait(t.def_id()))
} else {
@ -733,17 +723,7 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
(
ExistentialPredicate::AutoTrait(lhs_id),
ExistentialPredicate::AutoTrait(rhs_id),
) => {
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)
}
) => lhs_id.0.cmp(&rhs_id.0),
(ExistentialPredicate::Trait(_), _) => Ordering::Less,
(_, ExistentialPredicate::Trait(_)) => Ordering::Greater,
(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| {
let tr = match tr {
SolverDefId::TraitId(id) => id,
_ => unreachable!(),
};
tr.trait_items(db).items.iter().any(|(name, item)| {
tr.0.trait_items(db).items.iter().any(|(name, item)| {
matches!(item, AssocItemId::TypeAliasId(_)) && name == assoc_name
})
})
@ -1629,11 +1605,7 @@ pub(crate) fn associated_ty_item_bounds<'db>(
.map_bound(|c| match c {
rustc_type_ir::ClauseKind::Trait(t) => {
let id = t.def_id();
let id = match id {
SolverDefId::TraitId(id) => id,
_ => unreachable!(),
};
let is_auto = db.trait_signature(id).flags.contains(TraitFlags::AUTO);
let is_auto = db.trait_signature(id.0).flags.contains(TraitFlags::AUTO);
if is_auto {
Some(ExistentialPredicate::AutoTrait(t.def_id()))
} 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_clause = Binder::dummy(ExistentialPredicate::Trait(ExistentialTraitRef::new(
interner,
SolverDefId::TraitId(trait_),
trait_.into(),
[] as [crate::next_solver::GenericArg<'_>; 0],
)));
bounds.push(sized_clause);
@ -1694,10 +1666,7 @@ pub(crate) fn associated_type_by_name_including_super_traits<'db>(
) -> Option<(TraitRef<'db>, TypeAliasId)> {
let interner = DbInterner::new_with(db, None, None);
rustc_type_ir::elaborate::supertraits(interner, Binder::dummy(trait_ref)).find_map(|t| {
let trait_id = match t.as_ref().skip_binder().def_id {
SolverDefId::TraitId(id) => id,
_ => unreachable!(),
};
let trait_id = t.as_ref().skip_binder().def_id.0;
let assoc_type = trait_id.trait_items(db).associated_type_by_name(name)?;
Some((t.skip_binder(), assoc_type))
})
@ -1727,10 +1696,7 @@ fn named_associated_type_shorthand_candidates<'db, R>(
) -> Option<R> {
let db = interner.db;
let mut search = |t: TraitRef<'db>| -> Option<R> {
let trait_id = match t.def_id {
SolverDefId::TraitId(id) => id,
_ => unreachable!(),
};
let trait_id = t.def_id.0;
let mut checked_traits = FxHashSet::default();
let mut check_trait = |trait_id: TraitId| {
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(),
_ => continue,
};
let trait_id = match trait_id {
SolverDefId::TraitId(trait_id) => trait_id,
_ => continue,
};
stack.push(trait_id);
stack.push(trait_id.0);
}
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);
self.skip_resolved_segment();
let segment = self.current_or_prev_segment;
let trait_id = match trait_ref.def_id {
SolverDefId::TraitId(id) => id,
_ => unreachable!(),
};
let trait_id = trait_ref.def_id.0;
let found =
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,
})
.next()?;
let trait_id = match trait_ref {
SolverDefId::TraitId(id) => id,
_ => panic!("Bad GenericDefId in trait ref"),
};
TyFingerprint::Dyn(trait_id)
TyFingerprint::Dyn(trait_ref.0)
}
TyKind::Ref(_, _, mutability) => match mutability {
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)]
pub struct ParamConst {
@ -304,7 +304,7 @@ impl<'db> rustc_type_ir::inherent::Const<DbInterner<'db>> for Const<'db> {
fn new_bound(
interner: DbInterner<'db>,
debruijn: rustc_type_ir::DebruijnIndex,
var: BoundVar,
var: BoundConst,
) -> Self {
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,
var: rustc_type_ir::BoundVar,
) -> Self {
Const::new(interner, ConstKind::Bound(debruijn, var))
Const::new(interner, ConstKind::Bound(debruijn, BoundConst { var }))
}
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 {
type Bound = rustc_type_ir::BoundVar;
type Bound = BoundConst;
fn universe(self) -> rustc_type_ir::UniverseIndex {
self.universe
}
fn var(self) -> rustc_type_ir::BoundVar {
self.bound
self.bound.var
}
fn with_updated_universe(self, ui: rustc_type_ir::UniverseIndex) -> Self {
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 }
}
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
}
}
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 _},
};
use crate::next_solver::BoundConst;
use super::{
Binder, BoundRegion, BoundTy, Const, ConstKind, DbInterner, Predicate, Region, Ty, TyKind,
};
@ -18,7 +20,7 @@ use super::{
pub trait BoundVarReplacerDelegate<'db> {
fn replace_region(&mut self, br: BoundRegion) -> Region<'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
@ -27,7 +29,7 @@ pub trait BoundVarReplacerDelegate<'db> {
pub struct FnMutDelegate<'db, 'a> {
pub regions: &'a mut (dyn FnMut(BoundRegion) -> Region<'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> {
@ -37,7 +39,7 @@ impl<'db, 'a> BoundVarReplacerDelegate<'db> for FnMutDelegate<'db, 'a> {
fn replace_ty(&mut self, bt: BoundTy) -> Ty<'db> {
(self.types)(bt)
}
fn replace_const(&mut self, bv: BoundVar) -> Const<'db> {
fn replace_const(&mut self, bv: BoundConst) -> Const<'db> {
(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 GoalEvaluation { certainty, has_changed, stalled_on } = match result {
let GoalEvaluation { goal: _, certainty, has_changed, stalled_on } = match result {
Ok(result) => result,
Err(NoSolution) => {
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(),
tupled_upvars_ty: tupled_upvars_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."),
}
@ -400,7 +399,6 @@ impl<'db> rustc_type_ir::inherent::GenericArgs<DbInterner<'db>> for GenericArgs<
resume_ty: resume_ty.expect_ty(),
yield_ty: yield_ty.expect_ty(),
return_ty: return_ty.expect_ty(),
witness: 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
use crate::next_solver::BoundConst;
use crate::next_solver::{
AliasTy, Binder, BoundRegion, BoundTy, Canonical, CanonicalVarValues, Const, DbInterner, Goal,
ParamEnv, Predicate, PredicateKind, Region, Ty, TyKind,
@ -95,7 +96,7 @@ where
GenericArgKind::Type(ty) => ty,
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,
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::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::{
@ -864,8 +864,8 @@ impl<'db> InferCtxt<'db> {
fn replace_ty(&mut self, bt: BoundTy) -> Ty<'db> {
self.args[bt.var.index()].expect_ty()
}
fn replace_const(&mut self, bv: BoundVar) -> Const<'db> {
self.args[bv.index()].expect_const()
fn replace_const(&mut self, bv: BoundConst) -> Const<'db> {
self.args[bv.var.index()].expect_const()
}
}
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::snapshot::CombinedSnapshot;
use crate::next_solver::{
Binder, BoundRegion, BoundTy, Const, DbInterner, PlaceholderConst, PlaceholderRegion,
PlaceholderTy, Region, Ty,
Binder, BoundConst, BoundRegion, BoundTy, Const, DbInterner, PlaceholderConst,
PlaceholderRegion, PlaceholderTy, Region, Ty,
};
impl<'db> InferCtxt<'db> {
@ -50,10 +50,10 @@ impl<'db> InferCtxt<'db> {
PlaceholderTy { universe: next_universe, bound: bound_ty },
)
},
consts: &mut |bound_var: BoundVar| {
consts: &mut |bound: BoundConst| {
Const::new_placeholder(
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::{
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::{
AliasTerm, AliasTermKind, AliasTy, AliasTyKind, EarlyBinder, FlagComputation, Flags,
@ -44,9 +44,11 @@ use rustc_type_ir::{
use crate::lower_nextsolver::{self, TyLoweringContext};
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::{
CanonicalVarKind, FxIndexMap, InternedWrapperNoDebug, RegionAssumptions, SolverDefIds,
BoundConst, CanonicalVarKind, FxIndexMap, InternedWrapperNoDebug, RegionAssumptions,
SolverContext, SolverDefIds, TraitIdWrapper,
};
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);
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> {
type DefId = SolverDefId;
type LocalDefId = SolverDefId;
type LocalDefIds = SolverDefIds;
type TraitId = TraitIdWrapper;
type Span = Span;
type GenericArgs = GenericArgs<'db>;
@ -923,7 +950,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
type Const = Const<'db>;
type PlaceholderConst = PlaceholderConst;
type ParamConst = ParamConst;
type BoundConst = rustc_type_ir::BoundVar;
type BoundConst = BoundConst;
type ValueConst = ValueConst<'db>;
type ValTree = Valtree<'db>;
type ExprConst = ExprConst;
@ -1117,7 +1144,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
);
let alias_args =
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 {
@ -1305,11 +1332,11 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
#[tracing::instrument(skip(self), ret)]
fn explicit_super_predicates_of(
self,
def_id: Self::DefId,
def_id: Self::TraitId,
) -> EarlyBinder<Self, impl IntoIterator<Item = (Self::Clause, Self::Span)>> {
let predicates: Vec<(Clause<'db>, Span)> = self
.db()
.generic_predicates_ns(def_id.try_into().unwrap())
.generic_predicates_ns(def_id.0.into())
.iter()
.cloned()
.map(|p| (p, Span::dummy()))
@ -1369,65 +1396,19 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
false
}
fn require_lang_item(
self,
lang_item: rustc_type_ir::lang_items::TraitSolverLangItem,
) -> Self::DefId {
fn require_lang_item(self, lang_item: SolverLangItem) -> Self::DefId {
let lang_item = match lang_item {
rustc_type_ir::lang_items::TraitSolverLangItem::AsyncFn => LangItem::AsyncFn,
rustc_type_ir::lang_items::TraitSolverLangItem::AsyncFnKindHelper => unimplemented!(),
rustc_type_ir::lang_items::TraitSolverLangItem::AsyncFnKindUpvars => unimplemented!(),
rustc_type_ir::lang_items::TraitSolverLangItem::AsyncFnMut => LangItem::AsyncFnMut,
rustc_type_ir::lang_items::TraitSolverLangItem::AsyncFnOnce => LangItem::AsyncFnOnce,
rustc_type_ir::lang_items::TraitSolverLangItem::AsyncFnOnceOutput => {
LangItem::AsyncFnOnceOutput
}
rustc_type_ir::lang_items::TraitSolverLangItem::AsyncIterator => unimplemented!(),
rustc_type_ir::lang_items::TraitSolverLangItem::CallOnceFuture => {
LangItem::CallOnceFuture
}
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!()
}
SolverLangItem::AsyncFnKindUpvars => unimplemented!(),
SolverLangItem::AsyncFnOnceOutput => LangItem::AsyncFnOnceOutput,
SolverLangItem::CallOnceFuture => LangItem::CallOnceFuture,
SolverLangItem::CallRefFuture => LangItem::CallRefFuture,
SolverLangItem::CoroutineReturn => LangItem::CoroutineReturn,
SolverLangItem::CoroutineYield => LangItem::CoroutineYield,
SolverLangItem::DynMetadata => LangItem::DynMetadata,
SolverLangItem::FutureOutput => LangItem::FutureOutput,
SolverLangItem::Metadata => LangItem::Metadata,
SolverLangItem::Option => LangItem::Option,
SolverLangItem::Poll => LangItem::Poll,
};
let target = hir_def::lang_item::lang_item(
self.db(),
@ -1448,216 +1429,131 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
}
}
#[allow(clippy::match_like_matches_macro)]
fn is_lang_item(
self,
def_id: Self::DefId,
lang_item: rustc_type_ir::lang_items::TraitSolverLangItem,
) -> bool {
use rustc_type_ir::lang_items::TraitSolverLangItem::*;
// FIXME: derive PartialEq on TraitSolverLangItem
self.as_lang_item(def_id).map_or(false, |l| match (l, lang_item) {
(AsyncFn, AsyncFn) => true,
(AsyncFnKindHelper, AsyncFnKindHelper) => true,
(AsyncFnKindUpvars, AsyncFnKindUpvars) => true,
(AsyncFnMut, AsyncFnMut) => true,
(AsyncFnOnce, AsyncFnOnce) => true,
(AsyncFnOnceOutput, AsyncFnOnceOutput) => true,
(AsyncIterator, AsyncIterator) => true,
(CallOnceFuture, CallOnceFuture) => true,
(CallRefFuture, CallRefFuture) => true,
(Clone, Clone) => true,
(Copy, Copy) => true,
(Coroutine, Coroutine) => true,
(CoroutineReturn, CoroutineReturn) => true,
(CoroutineYield, CoroutineYield) => true,
(Destruct, Destruct) => true,
(DiscriminantKind, DiscriminantKind) => true,
(Drop, Drop) => true,
(DynMetadata, DynMetadata) => true,
(Fn, Fn) => true,
(FnMut, FnMut) => true,
(FnOnce, FnOnce) => true,
(FnPtrTrait, FnPtrTrait) => true,
(FusedIterator, FusedIterator) => true,
(Future, Future) => true,
(FutureOutput, FutureOutput) => true,
(Iterator, Iterator) => true,
(Metadata, Metadata) => true,
(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 require_trait_lang_item(self, lang_item: SolverTraitLangItem) -> TraitIdWrapper {
let lang_item = match lang_item {
SolverTraitLangItem::AsyncFn => LangItem::AsyncFn,
SolverTraitLangItem::AsyncFnKindHelper => unimplemented!(),
SolverTraitLangItem::AsyncFnMut => LangItem::AsyncFnMut,
SolverTraitLangItem::AsyncFnOnce => LangItem::AsyncFnOnce,
SolverTraitLangItem::AsyncFnOnceOutput => LangItem::AsyncFnOnceOutput,
SolverTraitLangItem::AsyncIterator => unimplemented!(),
SolverTraitLangItem::Clone => LangItem::Clone,
SolverTraitLangItem::Copy => LangItem::Copy,
SolverTraitLangItem::Coroutine => LangItem::Coroutine,
SolverTraitLangItem::Destruct => LangItem::Destruct,
SolverTraitLangItem::DiscriminantKind => LangItem::DiscriminantKind,
SolverTraitLangItem::Drop => LangItem::Drop,
SolverTraitLangItem::Fn => LangItem::Fn,
SolverTraitLangItem::FnMut => LangItem::FnMut,
SolverTraitLangItem::FnOnce => LangItem::FnOnce,
SolverTraitLangItem::FnPtrTrait => LangItem::FnPtrTrait,
SolverTraitLangItem::FusedIterator => unimplemented!(),
SolverTraitLangItem::Future => LangItem::Future,
SolverTraitLangItem::Iterator => LangItem::Iterator,
SolverTraitLangItem::PointeeTrait => LangItem::PointeeTrait,
SolverTraitLangItem::Sized => LangItem::Sized,
SolverTraitLangItem::MetaSized => LangItem::MetaSized,
SolverTraitLangItem::PointeeSized => LangItem::PointeeSized,
SolverTraitLangItem::TransmuteTrait => LangItem::TransmuteTrait,
SolverTraitLangItem::Tuple => LangItem::Tuple,
SolverTraitLangItem::Unpin => LangItem::Unpin,
SolverTraitLangItem::Unsize => LangItem::Unsize,
SolverTraitLangItem::BikeshedGuaranteedNoDrop => {
unimplemented!()
}
};
lang_item
.resolve_trait(self.db(), self.krate.expect("Must have self.krate"))
.unwrap_or_else(|| panic!("Lang item {lang_item:?} required but not found."))
.into()
}
fn as_lang_item(
self,
def_id: Self::DefId,
) -> Option<rustc_type_ir::lang_items::TraitSolverLangItem> {
use rustc_type_ir::lang_items::TraitSolverLangItem;
#[allow(clippy::match_like_matches_macro)]
fn is_lang_item(self, def_id: Self::DefId, lang_item: SolverLangItem) -> bool {
use SolverLangItem::*;
// 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 {
SolverDefId::TraitId(id) => id.into(),
SolverDefId::TypeAliasId(id) => id.into(),
SolverDefId::AdtId(id) => id.into(),
_ => panic!("Unexpected SolverDefId in as_lang_item"),
};
let lang_item = self.db().lang_attr(def_id)?;
Some(match lang_item {
LangItem::Sized => TraitSolverLangItem::Sized,
LangItem::MetaSized => TraitSolverLangItem::MetaSized,
LangItem::PointeeSized => TraitSolverLangItem::PointeeSized,
LangItem::Unsize => TraitSolverLangItem::Unsize,
LangItem::StructuralPeq => return None,
LangItem::StructuralTeq => return None,
LangItem::Copy => TraitSolverLangItem::Copy,
LangItem::Clone => TraitSolverLangItem::Clone,
LangItem::Sync => return None,
LangItem::DiscriminantKind => TraitSolverLangItem::DiscriminantKind,
LangItem::Discriminant => return None,
LangItem::PointeeTrait => TraitSolverLangItem::PointeeTrait,
LangItem::Metadata => TraitSolverLangItem::Metadata,
LangItem::DynMetadata => TraitSolverLangItem::DynMetadata,
LangItem::Freeze => return None,
LangItem::FnPtrTrait => TraitSolverLangItem::FnPtrTrait,
LangItem::FnPtrAddr => return None,
LangItem::Drop => TraitSolverLangItem::Drop,
LangItem::Destruct => TraitSolverLangItem::Destruct,
LangItem::CoerceUnsized => return None,
LangItem::DispatchFromDyn => return None,
LangItem::TransmuteOpts => return None,
LangItem::TransmuteTrait => TraitSolverLangItem::TransmuteTrait,
LangItem::Add => return None,
LangItem::Sub => return None,
LangItem::Mul => return None,
LangItem::Div => return None,
LangItem::Rem => return None,
LangItem::Neg => return None,
LangItem::Not => return None,
LangItem::BitXor => return None,
LangItem::BitAnd => return None,
LangItem::BitOr => return None,
LangItem::Shl => return None,
LangItem::Shr => return None,
LangItem::AddAssign => return None,
LangItem::SubAssign => return None,
LangItem::MulAssign => return None,
LangItem::DivAssign => return None,
LangItem::RemAssign => return None,
LangItem::BitXorAssign => return None,
LangItem::BitAndAssign => return None,
LangItem::BitOrAssign => return None,
LangItem::ShlAssign => return None,
LangItem::ShrAssign => return None,
LangItem::Index => return None,
LangItem::IndexMut => return None,
LangItem::UnsafeCell => return None,
LangItem::VaList => return None,
LangItem::Deref => return None,
LangItem::DerefMut => return None,
LangItem::DerefTarget => return None,
LangItem::Receiver => return None,
LangItem::Fn => TraitSolverLangItem::Fn,
LangItem::FnMut => TraitSolverLangItem::FnMut,
LangItem::FnOnce => TraitSolverLangItem::FnOnce,
LangItem::FnOnceOutput => return None,
LangItem::Future => TraitSolverLangItem::Future,
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,
})
as_lang_item!(
SolverLangItem, lang_item;
ignore = {
AsyncFnKindUpvars,
}
Metadata,
DynMetadata,
CoroutineReturn,
CoroutineYield,
Poll,
FutureOutput,
Option,
AsyncFnOnceOutput,
CallRefFuture,
CallOnceFuture,
AsyncFnOnceOutput,
)
}
fn as_trait_lang_item(self, def_id: Self::TraitId) -> Option<SolverTraitLangItem> {
let def_id: AttrDefId = def_id.0.into();
let lang_item = self.db().lang_attr(def_id)?;
as_lang_item!(
SolverTraitLangItem, lang_item;
ignore = {
AsyncFnKindHelper,
AsyncIterator,
BikeshedGuaranteedNoDrop,
FusedIterator,
}
Sized,
MetaSized,
PointeeSized,
Unsize,
Copy,
Clone,
DiscriminantKind,
PointeeTrait,
FnPtrTrait,
Drop,
Destruct,
TransmuteTrait,
Fn,
FnMut,
FnOnce,
Future,
Coroutine,
Unpin,
Tuple,
Iterator,
AsyncFn,
AsyncFnMut,
AsyncFnOnce,
AsyncFnOnceOutput,
AsyncFnOnceOutput,
)
}
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(
self,
trait_def_id: Self::DefId,
trait_: Self::TraitId,
self_ty: Self::Ty,
mut f: impl FnMut(Self::DefId),
) {
let trait_ = match trait_def_id {
SolverDefId::TraitId(id) => id,
_ => panic!("for_each_relevant_impl called for non-trait"),
};
let trait_ = trait_.0;
let self_ty_fp = TyFingerprint::for_trait_impl_ns(&self_ty);
let fps: &[TyFingerprint] = match self_ty.kind() {
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 {
let trait_ = match trait_def_id {
SolverDefId::TraitId(id) => id,
_ => panic!("Unexpected SolverDefId in trait_is_auto"),
};
let trait_data = self.db().trait_signature(trait_);
fn trait_is_auto(self, trait_: Self::TraitId) -> bool {
let trait_data = self.db().trait_signature(trait_.0);
trait_data.flags.contains(TraitFlags::AUTO)
}
fn trait_is_alias(self, trait_def_id: Self::DefId) -> bool {
let trait_ = match trait_def_id {
SolverDefId::TraitId(id) => id,
_ => panic!("Unexpected SolverDefId in trait_is_alias"),
};
let trait_data = self.db().trait_signature(trait_);
fn trait_is_alias(self, trait_: Self::TraitId) -> bool {
let trait_data = self.db().trait_signature(trait_.0);
trait_data.flags.contains(TraitFlags::ALIAS)
}
fn trait_is_dyn_compatible(self, trait_def_id: Self::DefId) -> bool {
let trait_ = match trait_def_id {
SolverDefId::TraitId(id) => id,
_ => unreachable!(),
};
crate::dyn_compatibility::dyn_compatibility(self.db(), trait_).is_none()
fn trait_is_dyn_compatible(self, trait_: Self::TraitId) -> bool {
crate::dyn_compatibility::dyn_compatibility(self.db(), trait_.0).is_none()
}
fn trait_is_fundamental(self, def_id: Self::DefId) -> bool {
let trait_ = match def_id {
SolverDefId::TraitId(id) => id,
_ => panic!("Unexpected SolverDefId in trait_is_fundamental"),
};
let trait_data = self.db().trait_signature(trait_);
fn trait_is_fundamental(self, trait_: Self::TraitId) -> bool {
let trait_data = self.db().trait_signature(trait_.0);
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
// the `#[rustc_do_not_implement_via_object]` flag
true
@ -1920,12 +1796,12 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
(*entry.or_insert_with(|| BoundVarKind::Ty(BoundTyKind::Anon))).expect_ty();
Ty::new_bound(self.interner, DebruijnIndex::ZERO, BoundTy { var, kind })
}
fn replace_const(&mut self, bv: BoundVar) -> Const<'db> {
let entry = self.map.entry(bv);
fn replace_const(&mut self, bv: BoundConst) -> Const<'db> {
let entry = self.map.entry(bv.var);
let index = entry.index();
let var = BoundVar::from_usize(index);
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!()
}
fn is_default_trait(self, def_id: Self::DefId) -> bool {
self.as_lang_item(def_id).map_or(false, |l| matches!(l, TraitSolverLangItem::Sized))
fn is_default_trait(self, def_id: Self::TraitId) -> bool {
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 {
let id = match trait_def_id {
SolverDefId::TraitId(id) => id,
_ => unreachable!(),
};
self.db().trait_signature(id).flags.contains(TraitFlags::COINDUCTIVE)
fn trait_is_coinductive(self, trait_: Self::TraitId) -> bool {
self.db().trait_signature(trait_.0).flags.contains(TraitFlags::COINDUCTIVE)
}
fn trait_is_unsafe(self, trait_def_id: Self::DefId) -> bool {
let id = match trait_def_id {
SolverDefId::TraitId(id) => id,
_ => unreachable!(),
};
self.db().trait_signature(id).flags.contains(TraitFlags::UNSAFE)
fn trait_is_unsafe(self, trait_: Self::TraitId) -> bool {
self.db().trait_signature(trait_.0).flags.contains(TraitFlags::UNSAFE)
}
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)
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> {
@ -2072,7 +1954,9 @@ impl<'db> DbInterner<'db> {
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! {
SolverDefId,
TraitIdWrapper,
Pattern<'db>,
Safety,
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 {
salsa::with_attached_database(|db| {
let trait_ = match t.def_id {
SolverDefId::TraitId(id) => id,
_ => panic!("Expected trait."),
};
let trait_ = t.def_id.0;
let self_ty = &t.args.as_slice()[0];
let trait_args = &t.args.as_slice()[1..];
if trait_args.is_empty() {
@ -122,10 +119,7 @@ impl<'db> IrPrint<ty::ExistentialTraitRef<Self>> for DbInterner<'db> {
fmt: &mut std::fmt::Formatter<'_>,
) -> std::fmt::Result {
salsa::with_attached_database(|db| {
let trait_ = match t.def_id {
SolverDefId::TraitId(id) => id,
_ => panic!("Expected trait."),
};
let trait_ = t.def_id.0;
fmt.write_str(&format!(
"ExistentialTraitRef({:?}[{:?}])",
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::{Id, plumbing::AsId};
use crate::next_solver::BoundConst;
use crate::{
ConcreteConst, ConstScalar, ImplTraitId, Interner, MemoryMap,
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> {
match c.kind() {
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!()
};
Const::new(
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),
@ -286,11 +287,8 @@ impl<'db> ChalkToNextSolver<'db, Ty<'db>> for chalk_ir::Ty<Interner> {
.flags
.contains(TraitFlags::AUTO)
{
ExistentialPredicate::AutoTrait(SolverDefId::TraitId(
trait_id,
))
ExistentialPredicate::AutoTrait(trait_id.into())
} else {
let def_id = SolverDefId::TraitId(trait_id);
let args = GenericArgs::new_from_iter(
interner,
trait_ref
@ -301,7 +299,7 @@ impl<'db> ChalkToNextSolver<'db, Ty<'db>> for chalk_ir::Ty<Interner> {
.map(|a| a.to_nextsolver(interner)),
);
let trait_ref = ExistentialTraitRef::new_from_args(
interner, def_id, args,
interner, trait_id.into(), args,
);
ExistentialPredicate::Trait(trait_ref)
}
@ -473,7 +471,7 @@ impl<'db> ChalkToNextSolver<'db, Const<'db>> for chalk_ir::Const<Interner> {
match &data.value {
chalk_ir::ConstValue::BoundVar(bound_var) => rustc_type_ir::ConstKind::Bound(
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) => {
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> {
fn to_nextsolver(&self, interner: DbInterner<'db>) -> TraitRef<'db> {
let args = self.substitution.to_nextsolver(interner);
TraitRef::new_from_args(
interner,
SolverDefId::TraitId(from_chalk_trait_id(self.trait_id)),
args,
)
TraitRef::new_from_args(interner, from_chalk_trait_id(self.trait_id).into(), args)
}
}
@ -1207,20 +1201,14 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
trait_ref.def_id,
[self_ty.into()].into_iter().chain(trait_ref.args.iter()),
);
let trait_id = match trait_ref.def_id {
SolverDefId::TraitId(id) => to_chalk_trait_id(id),
_ => unreachable!(),
};
let trait_id = to_chalk_trait_id(trait_ref.def_id.0);
let substitution =
convert_args_for_result(interner, trait_ref.args.as_slice());
let trait_ref = chalk_ir::TraitRef { trait_id, substitution };
chalk_ir::WhereClause::Implemented(trait_ref)
}
rustc_type_ir::ExistentialPredicate::AutoTrait(trait_) => {
let trait_id = match trait_ {
SolverDefId::TraitId(id) => to_chalk_trait_id(id),
_ => unreachable!(),
};
let trait_id = to_chalk_trait_id(trait_.0);
let substitution = chalk_ir::Substitution::from1(
Interner,
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) => {
chalk_ir::ConstValue::BoundVar(chalk_ir::BoundVar::new(
chalk_ir::DebruijnIndex::new(debruijn_index.as_u32()),
var.index(),
var.var.index(),
))
}
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 crate::next_solver::TraitIdWrapper;
use super::{Binder, BoundVarKinds, DbInterner, Region, Ty, interned_vec_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>>
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)
}
@ -89,9 +91,7 @@ impl<'db> rustc_type_ir::inherent::BoundExistentialPredicates<DbInterner<'db>>
.transpose()
}
fn auto_traits(
self,
) -> impl IntoIterator<Item = <DbInterner<'db> as rustc_type_ir::Interner>::DefId> {
fn auto_traits(self) -> impl IntoIterator<Item = TraitIdWrapper> {
self.iter().filter_map(|predicate| match predicate.skip_binder() {
ExistentialPredicate::AutoTrait(did) => Some(did),
_ => None,

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

@ -2,10 +2,10 @@
use hir_def::{AssocItemId, GeneralConstId, TypeAliasId};
use rustc_next_trait_solver::delegate::SolverDelegate;
use rustc_type_ir::lang_items::SolverTraitLangItem;
use rustc_type_ir::{
InferCtxtLike, Interner, PredicatePolarity, TypeFlags, TypeVisitableExt, UniverseIndex,
inherent::{IntoKind, SliceLike, Span as _, Term as _, Ty as _},
lang_items::TraitSolverLangItem,
solve::{Certainty, NoSolution},
};
@ -225,14 +225,14 @@ impl<'db> SolverDelegate for SolverContext<'db> {
}
if trait_pred.polarity() == PredicatePolarity::Positive {
match self.0.cx().as_lang_item(trait_pred.def_id()) {
Some(TraitSolverLangItem::Sized) | Some(TraitSolverLangItem::MetaSized) => {
match self.0.cx().as_trait_lang_item(trait_pred.def_id()) {
Some(SolverTraitLangItem::Sized) | Some(SolverTraitLangItem::MetaSized) => {
let predicate = self.resolve_vars_if_possible(goal.predicate);
if sizedness_fast_path(self.cx(), predicate, goal.param_env) {
return Some(Certainty::Yes);
}
}
Some(TraitSolverLangItem::Copy | TraitSolverLangItem::Clone) => {
Some(SolverTraitLangItem::Copy | SolverTraitLangItem::Clone) => {
let self_ty =
self.resolve_vars_if_possible(trait_pred.self_ty().skip_binder());
// 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 rustc_abi::{Float, Integer, Size};
use rustc_ast_ir::{Mutability, try_visit, visit::VisitorResult};
use rustc_type_ir::Interner;
use rustc_type_ir::{
BoundVar, ClosureKind, FlagComputation, Flags, FloatTy, FloatVid, InferTy, IntTy, IntVid,
TypeFoldable, TypeSuperFoldable, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, UintTy,
@ -19,6 +20,7 @@ use rustc_type_ir::{
use salsa::plumbing::{AsId, FromId};
use smallvec::SmallVec;
use crate::next_solver::GenericArg;
use crate::{
db::HirDatabase,
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))
}
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 {
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,
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::{
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::next_solver::infer::InferCtxt;
use crate::next_solver::{
CanonicalVarKind, FxIndexMap, ParamEnv, Placeholder, PlaceholderConst, PlaceholderRegion,
TypingMode,
BoundConst, CanonicalVarKind, FxIndexMap, ParamEnv, Placeholder, PlaceholderConst,
PlaceholderRegion, TypingMode,
};
use crate::{
db::HirDatabase,
@ -511,7 +511,7 @@ pub fn apply_args_to_binder<'db, T: TypeFoldable<DbInterner<'db>>>(
) -> T {
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 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 });
b.skip_binder().fold_with(&mut instantiate)
}
@ -654,7 +654,10 @@ impl<'db> TypeFolder<DbInterner<'db>> for MiniCanonicalizer<'_, 'db> {
ConstKind::Infer(infer) => {
let len = self.vars.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),
}
@ -852,7 +855,7 @@ pub struct PlaceholderReplacer<'a, 'db> {
infcx: &'a InferCtxt<'db>,
mapped_regions: FxIndexMap<PlaceholderRegion, BoundRegion>,
mapped_types: FxIndexMap<Placeholder<BoundTy>, BoundTy>,
mapped_consts: FxIndexMap<PlaceholderConst, BoundVar>,
mapped_consts: FxIndexMap<PlaceholderConst, BoundConst>,
universe_indices: &'a [Option<UniverseIndex>],
current_index: DebruijnIndex,
}
@ -862,7 +865,7 @@ impl<'a, 'db> PlaceholderReplacer<'a, 'db> {
infcx: &'a InferCtxt<'db>,
mapped_regions: FxIndexMap<PlaceholderRegion, BoundRegion>,
mapped_types: FxIndexMap<Placeholder<BoundTy>, BoundTy>,
mapped_consts: FxIndexMap<PlaceholderConst, BoundVar>,
mapped_consts: FxIndexMap<PlaceholderConst, BoundConst>,
universe_indices: &'a [Option<UniverseIndex>],
value: T,
) -> T {
@ -1026,9 +1029,9 @@ pub fn sizedness_fast_path<'db>(
if let PredicateKind::Clause(ClauseKind::Trait(trait_pred)) = predicate.kind().skip_binder()
&& trait_pred.polarity == PredicatePolarity::Positive
{
let sizedness = match tcx.as_lang_item(trait_pred.def_id()) {
Some(TraitSolverLangItem::Sized) => SizedTraitKind::Sized,
Some(TraitSolverLangItem::MetaSized) => SizedTraitKind::MetaSized,
let sizedness = match tcx.as_trait_lang_item(trait_pred.def_id()) {
Some(SolverTraitLangItem::Sized) => SizedTraitKind::Sized,
Some(SolverTraitLangItem::MetaSized) => SizedTraitKind::MetaSized,
_ => return false,
};
@ -1051,7 +1054,10 @@ pub fn sizedness_fast_path<'db>(
&& clause_pred.self_ty() == trait_pred.self_ty()
&& (clause_pred.def_id() == trait_pred.def_id()
|| (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;
}

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