Skip to content

Commit c36b75b

Browse files
ChayimFriedman2ChayimFriedman2
committed
Don't require a full InferenceTable for CastTy
A DB is enough.
1 parent da33061 commit c36b75b

File tree

2 files changed

+52
-59
lines changed

2 files changed

+52
-59
lines changed

‎src/tools/rust-analyzer/crates/hir-ty/src/infer/cast.rs‎

Lines changed: 47 additions & 53 deletions
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,9 @@ use stdx::never;
66

77
use crate::{
88
Adjustment, Binders, DynTy, InferenceDiagnostic, Interner, PlaceholderIndex,
9-
QuantifiedWhereClauses, Ty, TyExt, TyKind, TypeFlags, WhereClause, from_chalk_trait_id,
9+
QuantifiedWhereClauses, Ty, TyExt, TyKind, TypeFlags, WhereClause,
10+
db::HirDatabase,
11+
from_chalk_trait_id,
1012
infer::{coerce::CoerceNever, unify::InferenceTable},
1113
};
1214

@@ -30,7 +32,7 @@ pub(crate) enum CastTy {
3032
}
3133

3234
impl CastTy {
33-
pub(crate) fn from_ty(table: &mut InferenceTable<'_>, t: &Ty) -> Option<Self> {
35+
pub(crate) fn from_ty(db: &dyn HirDatabase, t: &Ty) -> Option<Self> {
3436
match t.kind(Interner) {
3537
TyKind::Scalar(Scalar::Bool) => Some(Self::Int(Int::Bool)),
3638
TyKind::Scalar(Scalar::Char) => Some(Self::Int(Int::Char)),
@@ -43,8 +45,8 @@ impl CastTy {
4345
let (AdtId::EnumId(id), _) = t.as_adt()? else {
4446
return None;
4547
};
46-
let enum_data = id.enum_variants(table.db);
47-
if enum_data.is_payload_free(table.db) { Some(Self::Int(Int::CEnum)) } else { None }
48+
let enum_data = id.enum_variants(db);
49+
if enum_data.is_payload_free(db) { Some(Self::Int(Int::CEnum)) } else { None }
4850
}
4951
TyKind::Raw(m, ty) => Some(Self::Ptr(ty.clone(), *m)),
5052
TyKind::Function(_) => Some(Self::FnPtr),
@@ -142,58 +144,50 @@ impl CastCheck {
142144
where
143145
F: FnMut(ExprId, Vec<Adjustment>),
144146
{
145-
let (t_from, t_cast) =
146-
match (CastTy::from_ty(table, &self.expr_ty), CastTy::from_ty(table, &self.cast_ty)) {
147-
(Some(t_from), Some(t_cast)) => (t_from, t_cast),
148-
(None, Some(t_cast)) => match self.expr_ty.kind(Interner) {
149-
TyKind::FnDef(..) => {
150-
let sig = self.expr_ty.callable_sig(table.db).expect("FnDef had no sig");
151-
let sig = table.eagerly_normalize_and_resolve_shallow_in(sig);
152-
let fn_ptr = TyKind::Function(sig.to_fn_ptr()).intern(Interner);
153-
if let Ok((adj, _)) = table.coerce(&self.expr_ty, &fn_ptr, CoerceNever::Yes)
154-
{
155-
apply_adjustments(self.source_expr, adj);
156-
} else {
157-
return Err(CastError::IllegalCast);
158-
}
159-
160-
(CastTy::FnPtr, t_cast)
147+
let (t_from, t_cast) = match (
148+
CastTy::from_ty(table.db, &self.expr_ty),
149+
CastTy::from_ty(table.db, &self.cast_ty),
150+
) {
151+
(Some(t_from), Some(t_cast)) => (t_from, t_cast),
152+
(None, Some(t_cast)) => match self.expr_ty.kind(Interner) {
153+
TyKind::FnDef(..) => {
154+
let sig = self.expr_ty.callable_sig(table.db).expect("FnDef had no sig");
155+
let sig = table.eagerly_normalize_and_resolve_shallow_in(sig);
156+
let fn_ptr = TyKind::Function(sig.to_fn_ptr()).intern(Interner);
157+
if let Ok((adj, _)) = table.coerce(&self.expr_ty, &fn_ptr, CoerceNever::Yes) {
158+
apply_adjustments(self.source_expr, adj);
159+
} else {
160+
return Err(CastError::IllegalCast);
161161
}
162-
TyKind::Ref(mutbl, _, inner_ty) => {
163-
return match t_cast {
164-
CastTy::Int(_) | CastTy::Float => match inner_ty.kind(Interner) {
165-
TyKind::Scalar(
166-
Scalar::Int(_) | Scalar::Uint(_) | Scalar::Float(_),
167-
)
168-
| TyKind::InferenceVar(
169-
_,
170-
TyVariableKind::Integer | TyVariableKind::Float,
171-
) => Err(CastError::NeedDeref),
172-
173-
_ => Err(CastError::NeedViaPtr),
174-
},
175-
// array-ptr-cast
176-
CastTy::Ptr(t, m) => {
177-
let t = table.eagerly_normalize_and_resolve_shallow_in(t);
178-
if !table.is_sized(&t) {
179-
return Err(CastError::IllegalCast);
180-
}
181-
self.check_ref_cast(
182-
table,
183-
inner_ty,
184-
*mutbl,
185-
&t,
186-
m,
187-
apply_adjustments,
188-
)
162+
163+
(CastTy::FnPtr, t_cast)
164+
}
165+
TyKind::Ref(mutbl, _, inner_ty) => {
166+
return match t_cast {
167+
CastTy::Int(_) | CastTy::Float => match inner_ty.kind(Interner) {
168+
TyKind::Scalar(Scalar::Int(_) | Scalar::Uint(_) | Scalar::Float(_))
169+
| TyKind::InferenceVar(
170+
_,
171+
TyVariableKind::Integer | TyVariableKind::Float,
172+
) => Err(CastError::NeedDeref),
173+
174+
_ => Err(CastError::NeedViaPtr),
175+
},
176+
// array-ptr-cast
177+
CastTy::Ptr(t, m) => {
178+
let t = table.eagerly_normalize_and_resolve_shallow_in(t);
179+
if !table.is_sized(&t) {
180+
return Err(CastError::IllegalCast);
189181
}
190-
_ => Err(CastError::NonScalar),
191-
};
192-
}
193-
_ => return Err(CastError::NonScalar),
194-
},
182+
self.check_ref_cast(table, inner_ty, *mutbl, &t, m, apply_adjustments)
183+
}
184+
_ => Err(CastError::NonScalar),
185+
};
186+
}
195187
_ => return Err(CastError::NonScalar),
196-
};
188+
},
189+
_ => return Err(CastError::NonScalar),
190+
};
197191

198192
// rustc checks whether the `expr_ty` is foreign adt with `non_exhaustive` sym
199193

‎src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs‎

Lines changed: 5 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -31,7 +31,7 @@ use crate::{
3131
display::{DisplayTarget, HirDisplay, hir_display_with_store},
3232
error_lifetime,
3333
generics::generics,
34-
infer::{CaptureKind, CapturedItem, TypeMismatch, cast::CastTy, unify::InferenceTable},
34+
infer::{CaptureKind, CapturedItem, TypeMismatch, cast::CastTy},
3535
inhabitedness::is_ty_uninhabited_from,
3636
layout::LayoutError,
3737
mapping::ToChalk,
@@ -948,8 +948,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
948948
let cast_kind = if source_ty.as_reference().is_some() {
949949
CastKind::PointerCoercion(PointerCast::ArrayToPointer)
950950
} else {
951-
let mut table = InferenceTable::new(self.db, self.env.clone());
952-
cast_kind(&mut table, &source_ty, &target_ty)?
951+
cast_kind(self.db, &source_ty, &target_ty)?
953952
};
954953

955954
Rvalue::Cast(cast_kind, it, target_ty)
@@ -2017,9 +2016,9 @@ impl<'ctx> MirLowerCtx<'ctx> {
20172016
}
20182017
}
20192018

2020-
fn cast_kind(table: &mut InferenceTable<'_>, source_ty: &Ty, target_ty: &Ty) -> Result<CastKind> {
2021-
let from = CastTy::from_ty(table, source_ty);
2022-
let cast = CastTy::from_ty(table, target_ty);
2019+
fn cast_kind(db: &dyn HirDatabase, source_ty: &Ty, target_ty: &Ty) -> Result<CastKind> {
2020+
let from = CastTy::from_ty(db, source_ty);
2021+
let cast = CastTy::from_ty(db, target_ty);
20232022
Ok(match (from, cast) {
20242023
(Some(CastTy::Ptr(..) | CastTy::FnPtr), Some(CastTy::Int(_))) => {
20252024
CastKind::PointerExposeAddress

0 commit comments

Comments
 (0)