crates/hir_ty/src/op.rs

   1 //! Helper functions for binary operator type inference.
   2 use chalk_ir::TyVariableKind;
   3 use hir_def::expr::{ArithOp, BinaryOp, CmpOp};
   4
   5 use crate::{Interner, Scalar, Ty, TyBuilder, TyKind};
   6
   7 pub(super) fn binary_op_return_ty(op: BinaryOp, lhs_ty: Ty, rhs_ty: Ty) -> Ty {
   8     match op {
   9         BinaryOp::LogicOp(_) | BinaryOp::CmpOp(_) => TyKind::Scalar(Scalar::Bool).intern(&Interner),
  10         BinaryOp::Assignment { .. } => TyBuilder::unit(),
  11         BinaryOp::ArithOp(ArithOp::Shl) | BinaryOp::ArithOp(ArithOp::Shr) => {
  12             // all integer combinations are valid here
  13             if matches!(
  14                 lhs_ty.kind(&Interner),
  15                 TyKind::Scalar(Scalar::Int(_))
  16                     | TyKind::Scalar(Scalar::Uint(_))
  17                     | TyKind::InferenceVar(_, TyVariableKind::Integer)
  18             ) && matches!(
  19                 rhs_ty.kind(&Interner),
  20                 TyKind::Scalar(Scalar::Int(_))
  21                     | TyKind::Scalar(Scalar::Uint(_))
  22                     | TyKind::InferenceVar(_, TyVariableKind::Integer)
  23             ) {
  24                 lhs_ty
  25             } else {
  26                 TyKind::Error.intern(&Interner)
  27             }
  28         }
  29         BinaryOp::ArithOp(_) => match (lhs_ty.kind(&Interner), rhs_ty.kind(&Interner)) {
  30             // (int, int) | (uint, uint) | (float, float)
  31             (TyKind::Scalar(Scalar::Int(_)), TyKind::Scalar(Scalar::Int(_)))
  32             | (TyKind::Scalar(Scalar::Uint(_)), TyKind::Scalar(Scalar::Uint(_)))
  33             | (TyKind::Scalar(Scalar::Float(_)), TyKind::Scalar(Scalar::Float(_))) => rhs_ty,
  34             // ({int}, int) | ({int}, uint)
  35             (TyKind::InferenceVar(_, TyVariableKind::Integer), TyKind::Scalar(Scalar::Int(_)))
  36             | (TyKind::InferenceVar(_, TyVariableKind::Integer), TyKind::Scalar(Scalar::Uint(_))) => {
  37                 rhs_ty
  38             }
  39             // (int, {int}) | (uint, {int})
  40             (TyKind::Scalar(Scalar::Int(_)), TyKind::InferenceVar(_, TyVariableKind::Integer))
  41             | (TyKind::Scalar(Scalar::Uint(_)), TyKind::InferenceVar(_, TyVariableKind::Integer)) => {
  42                 lhs_ty
  43             }
  44             // ({float} | float)
  45             (TyKind::InferenceVar(_, TyVariableKind::Float), TyKind::Scalar(Scalar::Float(_))) => {
  46                 rhs_ty
  47             }
  48             // (float, {float})
  49             (TyKind::Scalar(Scalar::Float(_)), TyKind::InferenceVar(_, TyVariableKind::Float)) => {
  50                 lhs_ty
  51             }
  52             // ({int}, {int}) | ({float}, {float})
  53             (
  54                 TyKind::InferenceVar(_, TyVariableKind::Integer),
  55                 TyKind::InferenceVar(_, TyVariableKind::Integer),
  56             )
  57             | (
  58                 TyKind::InferenceVar(_, TyVariableKind::Float),
  59                 TyKind::InferenceVar(_, TyVariableKind::Float),
  60             ) => rhs_ty,
  61             _ => TyKind::Error.intern(&Interner),
  62         },
  63     }
  64 }
  65
  66 pub(super) fn binary_op_rhs_expectation(op: BinaryOp, lhs_ty: Ty) -> Ty {
  67     match op {
  68         BinaryOp::LogicOp(..) => TyKind::Scalar(Scalar::Bool).intern(&Interner),
  69         BinaryOp::Assignment { op: None } => lhs_ty,
  70         BinaryOp::CmpOp(CmpOp::Eq { .. }) => match lhs_ty.kind(&Interner) {
  71             TyKind::Scalar(_) | TyKind::Str => lhs_ty,
  72             TyKind::InferenceVar(_, TyVariableKind::Integer)
  73             | TyKind::InferenceVar(_, TyVariableKind::Float) => lhs_ty,
  74             _ => TyKind::Error.intern(&Interner),
  75         },
  76         BinaryOp::ArithOp(ArithOp::Shl) | BinaryOp::ArithOp(ArithOp::Shr) => {
  77             TyKind::Error.intern(&Interner)
  78         }
  79         BinaryOp::CmpOp(CmpOp::Ord { .. })
  80         | BinaryOp::Assignment { op: Some(_) }
  81         | BinaryOp::ArithOp(_) => match lhs_ty.kind(&Interner) {
  82             TyKind::Scalar(Scalar::Int(_))
  83             | TyKind::Scalar(Scalar::Uint(_))
  84             | TyKind::Scalar(Scalar::Float(_)) => lhs_ty,
  85             TyKind::InferenceVar(_, TyVariableKind::Integer)
  86             | TyKind::InferenceVar(_, TyVariableKind::Float) => lhs_ty,
  87             _ => TyKind::Error.intern(&Interner),
  88         },
  89     }
  90 }