feat: add TypeCastExpr class

src/astx/__init__.py

@@ -73,6 +73,7 @@
     LiteralUInt128,
     Number,
     SignedInteger,
+    TypeCastExpr,
     UInt8,
     UInt16,
     UInt32,
@@ -203,6 +204,7 @@ def get_version() -> str:
     "StatementType",
     "symbol_table",
     "Target",
+    "TypeCastExpr",
     "UnaryOp",
     "Undefined",
     "VariableAssignment",

src/astx/base.py

@@ -132,6 +132,7 @@ class ASTKind(Enum):
     ImportFromExprKind = -801
 
     LambdaExprKind = -807
+    TypeCastExprKind = -809
 
 
 class ASTMeta(type):

src/astx/datatypes.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import Any
+from typing import Any, Optional
 from uuid import uuid4
 
 from public import public
@@ -11,7 +11,9 @@
 from astx.base import (
     NO_SOURCE_LOCATION,
     ASTKind,
+    ASTNodes,
     DataType,
+    Expr,
     ExprType,
     ReprStruct,
     SourceLocation,
@@ -679,3 +681,38 @@ def __init__(
         """Initialize LiteralComplex64."""
         super().__init__(Complex64(real, imag), loc)
         self.type_ = Complex64
+
+
+@public
+@typechecked
+class TypeCastExpr(Expr):
+    """AST class for type casting expressions."""
+
+    expr: Expr
+    target_type: DataType
+
+    def __init__(
+        self,
+        expr: Expr,
+        target_type: DataType,
+        loc: SourceLocation = SourceLocation(-1, -1),
+        parent: Optional[ASTNodes] = None,
+    ) -> None:
+        super().__init__(loc=loc, parent=parent)
+        self.expr = expr
+        self.target_type = target_type
+        self.kind = ASTKind.TypeCastExprKind
+
+    def __str__(self) -> str:
+        """Return a string representation of the TypeCast expression."""
+        return f"TypeCastExpr ({self.expr}, {self.target_type})"
+
+    def get_struct(self, simplified: bool = False) -> ReprStruct:
+        """Return the AST structure of the TypeCast expression."""
+        key = "TypeCastExpr"
+        value: ReprStruct = {
+            "expression": self.expr.get_struct(),
+            "target_type": self.target_type.get_struct(),
+        }
+
+        return self._prepare_struct(key, value, simplified)

src/astx/transpilers/python.py

@@ -184,6 +184,11 @@ def visit(self, node: astx.LambdaExpr) -> str:
         params_str = ", ".join(param.name for param in node.params)
         return f"lambda {params_str}: {self.visit(node.body)}"
 
+    @dispatch  # type: ignore[no-redef]
+    def visit(self, node: astx.TypeCastExpr) -> str:
+        """Handle TypeCastExpr nodes."""
+        return f"cast({node.target_type.__class__.__name__}, {node.expr.name})"
+
     @dispatch  # type: ignore[no-redef]
     def visit(self, node: astx.UnaryOp) -> str:
         """Handle UnaryOp nodes."""

src/astx/viz.py

@@ -22,7 +22,7 @@
     _AsciiGraphProxy,
 )
 from graphviz import Digraph
-from IPython.display import Image, display
+from IPython.display import Image, display  # type: ignore[attr-defined]
 from msgpack import dumps, loads
 
 from astx.base import DictDataTypesStruct, ReprStruct

tests/test_datatypes.py

@@ -0,0 +1,25 @@
+"""Tests for complex number data types."""
+
+from __future__ import annotations
+
+from astx.datatypes import Int32, TypeCastExpr
+from astx.variables import Variable
+from astx.viz import visualize
+
+
+def test_typecastexpr() -> None:
+    """Test TypeCastExpr."""
+    # Expression to cast
+    expr = Variable(name="x")
+
+    # Target type for casting
+    target_type = Int32()
+
+    # Create the TypeCastExpr
+    cast_expr = TypeCastExpr(expr=expr, target_type=target_type)
+
+    assert str(cast_expr)
+    assert cast_expr.get_struct()
+    assert cast_expr.get_struct(simplified=True)
+
+    visualize(cast_expr.get_struct())

tests/transpilers/test_python.py

@@ -371,3 +371,24 @@ def test_literal_complex64() -> None:
     assert (
         generated_code == expected_code
     ), f"Expected '{expected_code}', but got '{generated_code}'"
+
+
+def test_transpiler_typecastexpr() -> None:
+    """Test astx.TypeCastExpr."""
+    # Expression to cast
+    expr = astx.Variable(name="x")
+    # Target type for casting
+    target_type = astx.Int32()
+    # Create the TypeCastExpr
+    cast_expr = astx.TypeCastExpr(expr=expr, target_type=target_type)
+
+    # Initialize the generator
+    generator = astx2py.ASTxPythonTranspiler()
+
+    # Generate Python code
+    generated_code = generator.visit(cast_expr)
+    expected_code = "cast(Int32, x)"
+
+    assert (
+        generated_code == expected_code
+    ), f"Expected '{expected_code}', but got '{generated_code}'"