use alloc::vec::Vec;
use hir_lang::{ExprId, ItemId, ItemKind, NodeRef, Prim};
use super::Ctx;
use crate::{
diag::DiagnosticKind,
error::CheckError,
profile::RecordTyping,
typed::Coercion,
types::{Tag, Type, TypeId},
};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum Fit {
Same,
Converted(Coercion),
No,
}
impl Ctx<'_> {
pub(crate) fn coerce(&mut self, found: TypeId, expected: TypeId) -> Result<Fit, CheckError> {
if found == expected {
return Ok(Fit::Same);
}
self.coerce_with(found, expected, true)
}
fn coerce_with(
&mut self,
found: TypeId,
expected: TypeId,
wrap: bool,
) -> Result<Fit, CheckError> {
let (f, x) = (self.resolve(found), self.resolve(expected));
let (ft, xt) = (self.tag(f), self.tag(x));
if ft == Tag::Never {
return Ok(Fit::Same);
}
if self.unify(found, expected)? {
return Ok(Fit::Same);
}
if xt == Tag::Any {
return Ok(Fit::Converted(Coercion::ToAny));
}
if ft == Tag::Null {
let ok = xt == Tag::Nullable || (!self.profile.null_safety && self.reference_like(x));
return Ok(if ok {
Fit::Converted(Coercion::Null)
} else {
Fit::No
});
}
if xt == Tag::Nullable && wrap {
let mut inner = x;
while self.tag(inner) == Tag::Nullable {
self.meter.tick(1)?;
inner = self.resolve(TypeId::from_raw(self.types.node(inner).x));
}
return Ok(match self.coerce_with(f, inner, false)? {
Fit::No => Fit::No,
_ => Fit::Converted(Coercion::WrapNullable),
});
}
if self.profile.numeric_widening {
if let (Some(a), Some(b)) = (self.prim_of(f), self.prim_of(x)) {
if widens(a, b) {
return Ok(Fit::Converted(Coercion::Widen));
}
}
}
if self.profile.subtyping {
if let (Type::Adt { .. }, Type::Adt { .. }) = (self.types.get(f), self.types.get(x)) {
if self.upcast(f, x)? {
return Ok(Fit::Converted(Coercion::Subclass));
}
if self.profile.records == RecordTyping::Structural && self.record_width(f, x)? {
return Ok(Fit::Converted(Coercion::RecordWidth));
}
} else if self.profile.records == RecordTyping::Structural && self.record_width(f, x)? {
return Ok(Fit::Converted(Coercion::RecordWidth));
}
}
if let Some(fit) = self.coerce_compound(f, x)? {
return Ok(fit);
}
enum Shape {
Unsize(TypeId, TypeId),
Refs(bool, TypeId, TypeId),
}
let shape = match (self.types.get(f), self.types.get(x)) {
(Type::Array { elem, .. }, Type::Slice(target)) => Some(Shape::Unsize(elem, target)),
(
Type::Ref {
mutable: fm,
inner: fi,
},
Type::Ref {
mutable: false,
inner: xi,
},
) => Some(Shape::Refs(fm, fi, xi)),
_ => None,
};
match shape {
Some(Shape::Unsize(elem, target)) if self.unify(elem, target)? => {
return Ok(Fit::Converted(Coercion::Unsize));
}
Some(Shape::Refs(fm, fi, xi)) => {
let (fi_r, xi_r) = (self.resolve(fi), self.resolve(xi));
let unsize = match (self.types.get(fi_r), self.types.get(xi_r)) {
(Type::Array { elem, .. }, Type::Slice(target)) => Some((elem, target)),
_ => None,
};
if let Some((elem, target)) = unsize {
if self.unify(elem, target)? {
return Ok(Fit::Converted(Coercion::Unsize));
}
}
if fm && self.unify(fi, xi)? {
return Ok(Fit::Converted(Coercion::Reborrow));
}
if matches!(self.tag(xi_r), Tag::Dyn | Tag::Union | Tag::Inter)
|| self.tag(fi_r) == Tag::Inter
{
if let Some(Fit::Converted(c)) = self.coerce_compound(fi_r, xi_r)? {
return Ok(Fit::Converted(c));
}
}
}
_ => {}
}
Ok(Fit::No)
}
fn coerce_compound(&mut self, f: TypeId, x: TypeId) -> Result<Option<Fit>, CheckError> {
let (ft, xt) = (self.tag(f), self.tag(x));
if xt == Tag::Union {
let members = self.types.kids(x).to_vec();
let found: Vec<TypeId> = if ft == Tag::Union {
self.types.kids(f).to_vec()
} else {
alloc::vec![f]
};
let snap = self.infer.snapshot();
let mut all = true;
for &v in &found {
let mut ok = members.contains(&v);
for &m in &members {
if ok {
break;
}
ok = self.coerce_with(v, m, true)? != Fit::No;
}
if !ok {
all = false;
break;
}
}
if all {
self.infer.commit();
return Ok(Some(Fit::Converted(Coercion::ToUnion)));
}
self.infer.rollback(snap);
return Ok(None);
}
if xt == Tag::Inter {
let members = self.types.kids(x).to_vec();
let snap = self.infer.snapshot();
let mut same = true;
for m in members {
match self.coerce_with(f, m, true)? {
Fit::Same => {}
Fit::Converted(_) => same = false,
Fit::No => {
self.infer.rollback(snap);
return Ok(None);
}
}
}
self.infer.commit();
return Ok(Some(if same {
Fit::Same
} else {
Fit::Converted(Coercion::Subclass)
}));
}
if ft == Tag::Inter {
let members = self.types.kids(f).to_vec();
for m in members {
let snap = self.infer.snapshot();
if self.coerce_with(m, x, true)? != Fit::No {
self.infer.commit();
return Ok(Some(Fit::Converted(Coercion::FromIntersection)));
}
self.infer.rollback(snap);
}
return Ok(None);
}
if xt == Tag::Dyn && !matches!(ft, Tag::Var | Tag::Error) {
let want = self.types.kids(x).to_vec();
if ft == Tag::Dyn {
let have = self.types.kids(f).to_vec();
let ok = want.iter().all(|w| {
let wi = self.trait_item(*w);
have.iter().any(|h| self.trait_item(*h) == wi)
});
return Ok(ok.then_some(Fit::Converted(Coercion::ToDyn)));
}
let at = self.coerce_site;
for tr in want {
let Some(iface) = self.trait_item(tr) else {
continue;
};
let args = self.trait_args(tr);
let slots: Vec<TypeId> = self
.types
.kids(tr)
.get(args.len()..)
.unwrap_or(&[])
.to_vec();
let bare = self.types.trait_ref(iface, &args);
self.oblige_impl(f, bare, at);
for (assoc, v) in self.assoc_types(iface).into_iter().zip(slots) {
self.oblige_projection(f, bare, assoc, v, at);
}
self.dyn_uses.push((self.cur_item, f, bare));
}
return Ok(Some(Fit::Converted(Coercion::ToDyn)));
}
Ok(None)
}
pub(crate) fn upcast(&mut self, sub: TypeId, sup: TypeId) -> Result<bool, CheckError> {
let sup = self.resolve(sup);
let Type::Adt { item: want, .. } = self.types.get(sup) else {
return Ok(false);
};
for base in self.base_types(sub)? {
if let Type::Adt { item, .. } = self.types.get(self.resolve(base)) {
if item == want {
let snap = self.infer.snapshot();
if self.unify(base, sup)? {
self.infer.commit();
return Ok(true);
}
self.infer.rollback(snap);
}
}
}
Ok(false)
}
fn reference_like(&self, t: TypeId) -> bool {
match self.types.get(t) {
Type::Ref { .. }
| Type::Ptr { .. }
| Type::Adt { .. }
| Type::Foreign { .. }
| Type::Extern { .. }
| Type::Fn { .. }
| Type::Slice(_)
| Type::Map { .. }
| Type::Nullable(_)
| Type::Record(_)
| Type::Param(_)
| Type::ImplParam(_)
| Type::Dyn(_)
| Type::Opaque { .. }
| Type::Union(_)
| Type::Intersection(_)
| Type::Async(_)
| Type::Task(_)
| Type::Generator { .. } => true,
Type::Prim(p) => p == Prim::Str,
_ => false,
}
}
pub(crate) fn is_subclass(&mut self, sub: ItemId, sup: ItemId) -> Result<bool, CheckError> {
if !matches!(self.item_kind(sub), ItemKind::Class(_)) {
return Ok(false);
}
self.new_visit();
let mut stack: Vec<ItemId> = alloc::vec![sub];
while let Some(c) = stack.pop() {
self.meter.tick(1)?;
if c == sup {
return Ok(true);
}
if !self.visit(c) {
continue;
}
stack.extend(self.idx.bases_of(c).iter().copied());
}
Ok(false)
}
fn record_width(&mut self, found: TypeId, expected: TypeId) -> Result<bool, CheckError> {
let (Some(ff), Some(xf)) = (
self.record_fields_of(found),
self.record_fields_of(expected),
) else {
return Ok(false);
};
let snap = self.infer.snapshot();
let mut i = 0;
for want in &xf {
while ff.get(i).is_some_and(|f| f.name < want.name) {
i += 1;
}
let ok = match ff.get(i) {
Some(have) if have.name == want.name => self.unify(have.ty, want.ty)?,
_ => false,
};
if !ok {
self.infer.rollback(snap);
return Ok(false);
}
}
self.infer.commit();
Ok(true)
}
pub(crate) fn record_fields_of(&self, t: TypeId) -> Option<Vec<crate::types::Field>> {
let n = self.types.node(t);
match n.tag {
Tag::Record => Some(self.types.fields_of(&n).to_vec()),
Tag::Adt if n.len == 0 => {
let (start, len) = (*self.record_fields.get(n.x as usize)?)?;
self.field_pool
.get(start as usize..(start as usize).saturating_add(len as usize))
.map(<[_]>::to_vec)
}
_ => None,
}
}
pub(crate) fn coerce_expr(
&mut self,
e: ExprId,
found: TypeId,
expected: TypeId,
) -> Result<bool, CheckError> {
self.coerce_site = NodeRef::Expr(e);
match self.coerce(found, expected)? {
Fit::Same => Ok(true),
Fit::Converted(c) => {
self.coercions.push((e, c, expected));
Ok(true)
}
Fit::No => {
self.report(
NodeRef::Expr(e),
DiagnosticKind::Mismatch { expected, found },
);
self.poison(e);
Ok(false)
}
}
}
pub(crate) fn join(
&mut self,
prev: TypeId,
prev_expr: Option<ExprId>,
next: TypeId,
next_expr: ExprId,
) -> Result<TypeId, CheckError> {
let (pt, nt) = (self.tag(prev), self.tag(next));
if pt == Tag::Never || pt == Tag::Error {
return Ok(next);
}
if nt == Tag::Never || nt == Tag::Error {
return Ok(prev);
}
if self.unify(prev, next)? {
return Ok(prev);
}
match self.coerce(next, prev)? {
Fit::Same => return Ok(prev),
Fit::Converted(c) => {
self.coercions.push((next_expr, c, prev));
return Ok(prev);
}
Fit::No => {}
}
if let Some(pe) = prev_expr {
match self.coerce(prev, next)? {
Fit::Same => return Ok(next),
Fit::Converted(c) => {
self.coercions.push((pe, c, next));
return Ok(next);
}
Fit::No => {}
}
}
if self.profile.null_safety && (pt == Tag::Null || nt == Tag::Null) {
let (other, other_expr, null_expr) = if pt == Tag::Null {
(next, Some(next_expr), prev_expr)
} else {
(prev, prev_expr, Some(next_expr))
};
let joined = self.types.nullable(other);
if let Some(e) = other_expr {
self.coercions.push((e, Coercion::WrapNullable, joined));
}
if let Some(e) = null_expr {
self.coercions.push((e, Coercion::Null, joined));
}
return Ok(joined);
}
self.report(
NodeRef::Expr(next_expr),
DiagnosticKind::Mismatch {
expected: prev,
found: next,
},
);
self.poison(next_expr);
Ok(prev)
}
}
pub(crate) fn widens(from: Prim, to: Prim) -> bool {
let (fb, tb) = (from.bits(), to.bits());
if from.is_int() && to.is_int() {
if from.is_signed() && !to.is_signed() {
return false;
}
return fb < tb;
}
if from.is_int() && to.is_float() {
return (to == Prim::F32 && fb <= 16) || (to == Prim::F64 && fb <= 32);
}
from == Prim::F32 && to == Prim::F64
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_widening_table() {
assert!(widens(Prim::I8, Prim::I64));
assert!(widens(Prim::U8, Prim::I16));
assert!(!widens(Prim::I8, Prim::U64));
assert!(!widens(Prim::I64, Prim::I32));
assert!(!widens(Prim::I64, Prim::Isize));
assert!(widens(Prim::I32, Prim::F64));
assert!(!widens(Prim::I64, Prim::F64));
assert!(widens(Prim::U16, Prim::F32));
assert!(!widens(Prim::U32, Prim::F32));
assert!(widens(Prim::F32, Prim::F64));
assert!(!widens(Prim::F64, Prim::F32));
assert!(!widens(Prim::Bool, Prim::I8));
}
}