Limit the use of typeof_pyval()

This should be a non-functional change.

Signed-off-by: Greg Bonik <gbonik@nvidia.com>

Author: gbonik

src/cuda/tile/_ir/ops.py

@@ -617,18 +617,6 @@ def return_(value: Var | None):
     add_operation_variadic(Return, ())
 
 
-def _check_value_numeric_type(value: Any, dtype: DType) -> None:
-    value_type = typeof_pyval(value)
-    if datatype.is_arithmetic(value_type):
-        if not datatype.is_arithmetic(dtype):
-            raise TileTypeError(f"Expect \"value\" to be a non-numeric dtype {dtype}, "
-                                f"got numeric dtype {value_type}")
-        # TODO: Both are numeric types, check the data range after ir dtype supports it.
-    else:
-        if value_type != dtype:
-            raise TileTypeError(f"Expect \"value\" to be a {dtype}, got {value_type}")
-
-
 @dataclass(eq=False)
 class TypedConst(Operation, opcode="typed_const"):
     value: Any = attribute()

src/cuda/tile/_ir/ops_utils.py

@@ -18,7 +18,7 @@
 
 from .ir import Operation, Builder
 from .type import TileTy, LooselyTypedScalar
-from .typing_support import typeof_pyval
+from .typing_support import dtype_of_constant_scalar
 from .._datatype import DType, _DTypePromotionImpl, NumericDTypeCategory, PointerInfo
 
 
@@ -206,7 +206,7 @@ def memory_order_has_release(memory_order: MemoryOrder):
 
 def get_dtype(ty: TileTy | LooselyTypedScalar) -> datatype.DType:
     if isinstance(ty, LooselyTypedScalar):
-        ty = typeof_pyval(ty.value)
+        return dtype_of_constant_scalar(ty.value)
     assert isinstance(ty, TileTy)
     return ty.dtype
 
@@ -241,9 +241,7 @@ class CompareOrdering(Enum):
 def _promote_dtype_and_loosely_typed_constant(dtype: DType,
                                               loose_const: Any,
                                               force_float: bool) -> DType:
-    loose_ty = typeof_pyval(loose_const)
-    assert isinstance(loose_ty, TileTy) and loose_ty.ndim == 0
-    loose_dtype = loose_ty.dtype
+    loose_dtype = dtype_of_constant_scalar(loose_const)
 
     cat = datatype.numeric_dtype_category(dtype)
     if cat == NumericDTypeCategory.RestrictedFloat:
@@ -272,11 +270,9 @@ def promote_dtypes(t1: DType | LooselyTypedScalar,
                    force_float: bool = False) -> DType:
     match t1, t2:
         case LooselyTypedScalar(val1), LooselyTypedScalar(val2):
-            type1 = typeof_pyval(val1)
-            assert isinstance(type1, TileTy)
-            type2 = typeof_pyval(val2)
-            assert isinstance(type2, TileTy)
-            return _DTypePromotionImpl.promote_dtypes(type1.dtype, type2.dtype, force_float)
+            dtype1 = dtype_of_constant_scalar(val1)
+            dtype2 = dtype_of_constant_scalar(val2)
+            return _DTypePromotionImpl.promote_dtypes(dtype1, dtype2, force_float)
         case LooselyTypedScalar(val), dtype:
             return _promote_dtype_and_loosely_typed_constant(dtype, val, force_float)
         case dtype, LooselyTypedScalar(val):
@@ -329,8 +325,8 @@ def check_implicit_cast(src_ty: TileTy | LooselyTypedScalar, target_dtype: DType
             raise TileValueError(f"cannot implicitly cast {src_ty.value}"
                                  f" to a non-numeric dtype {target_dtype}")
 
-        cocnrete_ty = typeof_pyval(src_ty.value)
-        src_cat = datatype.numeric_dtype_category(cocnrete_ty.dtype)
+        concrete_dtype = dtype_of_constant_scalar(src_ty.value)
+        src_cat = datatype.numeric_dtype_category(concrete_dtype)
         dst_cat = datatype.numeric_dtype_category(target_dtype)
         if dst_cat == NumericDTypeCategory.Boolean:
             if src_cat not in (NumericDTypeCategory.Boolean, NumericDTypeCategory.Integral) \

src/cuda/tile/_ir/typing_support.py

@@ -139,28 +139,34 @@ def is_supported_builtin_func(x: Any) -> bool:
     return _safe_get(BUILTIN_FUNCS, x) is not None or getattr(x, '_cutile_is_builtin', False)
 
 
-def typeof_pyval(val) -> Type:
-    if val is None:
-        return NONE
-    if (t := _safe_get(_dtype_registry, type(val))):
-        return TileTy(t.dtype)
+def dtype_of_constant_scalar(val: bool | int | float) -> DType:
     if isinstance(val, bool):
-        return TileTy(datatype.bool_)
-    if isinstance(val, Enum):
-        return EnumTy(type(val))
-    if isinstance(val, int):
+        return datatype.bool_
+    elif isinstance(val, int):
         if -2**31 <= val < 2**31:
-            dtype = datatype.int32
+            return datatype.int32
         elif -2**63 <= val < 2**63:
-            dtype = datatype.int64
+            return datatype.int64
         elif 0 <= val < 2**64:
-            dtype = datatype.uint64
+            return datatype.uint64
         else:
             # FIXME: delay the error and allow arbitrary-precision intermediate constant values
             raise TileValueError(f"Constant {val} is out of range of any supported integer type")
-        return TileTy(dtype)
-    if isinstance(val, float):
-        return TileTy(datatype.default_float_type)
+    elif isinstance(val, float):
+        return datatype.default_float_type
+    else:
+        raise TypeError(f'Python value {val} of type {type(val)} is not supported.')
+
+
+def typeof_pyval(val) -> Type:
+    if val is None:
+        return NONE
+    if (t := _safe_get(_dtype_registry, type(val))):
+        return TileTy(t.dtype)
+    if isinstance(val, bool | int | float):
+        return TileTy(dtype_of_constant_scalar(val))
+    if isinstance(val, Enum):
+        return EnumTy(type(val))
     if isinstance(val, str):
         return StringTy(val)
     if isinstance(val, tuple):