jaclang 0.8.6__py3-none-any.whl → 0.8.8__py3-none-any.whl

jaclang/compiler/passes/main/tests/fixtures/checker_magic_call.jac

@@ -0,0 +1,17 @@
+
+node Bar {}
+
+node Foo {
+    def __call__() -> Bar {
+        return Bar();
+    }
+}
+
+def fn() -> Foo {
+    return Foo();
+}
+
+with entry{
+    b: Bar = fn()(); # <-- Ok
+    f: Foo = fn()(); # <-- Error
+}

jaclang/compiler/passes/main/tests/fixtures/checker_mod_path.jac

@@ -0,0 +1,8 @@
+
+
+import jaclang.compiler.unitree as uni;
+
+
+with entry{
+    a:int = uni.Module; # <-- Error
+}

jaclang/compiler/passes/main/tests/fixtures/checker_param_types.jac

@@ -0,0 +1,11 @@
+
+node A {}
+node B {}
+
+def foo(a: A) -> None { }
+
+
+with entry {
+    foo(A()); # <-- Ok
+    foo(B()); # <-- Error
+}

jaclang/compiler/passes/main/tests/fixtures/checker_self_type.jac

@@ -0,0 +1,9 @@
+
+node Foo {
+    has i: int = 0;
+
+    def foo() {
+     y: int = self.i; # <-- Ok
+     x: str = self.i; # <-- Error
+    }
+}

jaclang/compiler/passes/main/tests/fixtures/checker_sym_inherit.jac

@@ -0,0 +1,42 @@
+
+# -----------------------------------------------------------------------------
+# Simple Inheritance
+# -----------------------------------------------------------------------------
+
+node Parent {
+    has val: int = 42;
+}
+
+node Child (Parent) {
+
+}
+
+
+with entry {
+    c = Child();
+    c.val = 42;     # <-- Ok
+    c.val = "str";  # <-- Error
+}
+
+
+# -----------------------------------------------------------------------------
+# A Complex Inheritance
+# -----------------------------------------------------------------------------
+
+node Animal {
+    has name: str;
+}
+
+node Cat(Animal) {
+}
+
+node Lion(Cat) {
+}
+
+
+with entry {
+    l = Lion();
+
+    l.name = "Simba";  # <-- Ok
+    l.name = 42;       # <-- Error
+}

jaclang/compiler/passes/main/tests/fixtures/predynamo_fix3.jac

@@ -0,0 +1,43 @@
+import torch;
+class Cfg {
+    def __init__(self: Cfg, max_position_embeddings: Any = 8, has_original: Any = False) {
+        self.max_position_embeddings = max_position_embeddings;
+        if has_original {
+            self.original_max_position_embeddings = (max_position_embeddings // 2);
+        }
+    }
+}
+class ToyModel(torch.nn.Module) {
+    def __init__(self: ToyModel, cfg: Cfg) {
+        super.init();
+        self.config = cfg;
+        self.long_inv_freq = torch.tensor([10.0, 20.0, 30.0]);
+        self.original_inv_freq = torch.tensor([1.0, 2.0, 3.0]);
+    }
+    def rope_init_fn(self: ToyModel, cfg: Any, device: Any, seq_len: int) {
+        return (torch.arange(1, 4, dtype=torch.float32, device=device), None);
+    }
+    def _longrope_frequency_update(
+        self: ToyModel,
+        position_ids: Any,
+        device: Any = 'cpu'
+    ) {
+        seq_len = (torch.max(position_ids) + 1);
+        if hasattr(self.config, 'original_max_position_embeddings') {
+            original_max_position_embeddings = self.config.original_max_position_embeddings;
+        } else {
+            original_max_position_embeddings = self.config.max_position_embeddings;
+        }
+        if (seq_len > original_max_position_embeddings) {
+            self.register_buffer('inv_freq', self.long_inv_freq, persistent=False);
+        } else {
+            self.register_buffer(
+                'inv_freq',
+                self.original_inv_freq.to(device),
+                persistent=False
+            );
+        }
+        return self.inv_freq;
+    }
+}
+

jaclang/compiler/passes/main/tests/fixtures/predynamo_where_assign.jac

@@ -0,0 +1,13 @@
+import torch;
+
+def with_breaks(a: Any, b: Any) {
+    x = (a / (torch.abs(a) + 1));
+    b = (b * 1.414);
+    if (b.sum() < 0) {
+        b = (b * -1);
+    } else{
+            b = (b * -2);
+    }
+    
+    return (x * b);
+}

jaclang/compiler/passes/main/tests/fixtures/predynamo_where_return.jac

@@ -0,0 +1,11 @@
+import torch;
+
+def with_breaks(a: Any, b: Any) {
+    x = (a / (torch.abs(a) + 1));
+    b = (b * 1.414);
+    if (b.sum() < 0) {
+        return x * (b * -1);
+    } else{
+        return x * (b * -2);
+    }
+}

jaclang/compiler/passes/main/tests/test_checker_pass.py

@@ -28,6 +28,18 @@ class TypeCheckerPassTests(TestCase):
                  ^^^^^^^^^^^^^^^^^^^^^^
         """, program.errors_had[1].pretty_print())
 
+    def test_float_types(self) -> None:
+        program = JacProgram()
+        mod = program.compile(self.fixture_abs_path("checker_float.jac"))
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 1)
+        self._assert_error_pretty_found("""
+            f: float = pi; # <-- OK
+            s: str = pi;   # <-- Error
+            ^^^^^^^^^^^
+        """, program.errors_had[0].pretty_print())
+
+
     def test_infer_type_of_assignment(self) -> None:
         program = JacProgram()
         mod = program.compile(self.fixture_abs_path("infer_type_assignment.jac"))
@@ -49,6 +61,17 @@ class TypeCheckerPassTests(TestCase):
           ^^^^^^^^^^^^^^^^^^^
         """, program.errors_had[0].pretty_print())
 
+    def test_imported_sym(self) -> None:
+        program = JacProgram()
+        mod = program.compile(self.fixture_abs_path("checker/import_sym_test.jac"))
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 1)
+        self._assert_error_pretty_found("""
+          a: str = foo();  # <-- Ok
+          b: int = foo();  # <-- Error
+          ^^^^^^^^^^^^^^
+        """, program.errors_had[0].pretty_print())
+
     def test_member_access_type_infered(self) -> None:
         program = JacProgram()
         mod = program.compile(self.fixture_abs_path("member_access_type_inferred.jac"))
@@ -59,6 +82,22 @@ class TypeCheckerPassTests(TestCase):
           ^^^^^^^^^
         """, program.errors_had[0].pretty_print())
 
+    def test_inherited_symbol(self) -> None:
+        program = JacProgram()
+        mod = program.compile(self.fixture_abs_path("checker_sym_inherit.jac"))
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 2)
+        self._assert_error_pretty_found("""
+          c.val = 42;     # <-- Ok
+          c.val = "str";  # <-- Error
+          ^^^^^^^^^^^^^
+        """, program.errors_had[0].pretty_print())
+        self._assert_error_pretty_found("""
+          l.name = "Simba";  # <-- Ok
+          l.name = 42;       # <-- Error
+          ^^^^^^^^^^^
+        """, program.errors_had[1].pretty_print())
+
     def test_import_symbol_type_infer(self) -> None:
         program = JacProgram()
         mod = program.compile(self.fixture_abs_path("import_symbol_type_infer.jac"))
@@ -81,6 +120,232 @@ class TypeCheckerPassTests(TestCase):
                ^^^^^^^^^^^^^^
         """, program.errors_had[0].pretty_print())
 
+    def test_call_expr(self) -> None:
+        path = self.fixture_abs_path("checker_expr_call.jac")
+        program = JacProgram()
+        mod = program.compile(path)
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 1)
+        self._assert_error_pretty_found("""
+          s: str = foo();
+          ^^^^^^^^^^^^^^
+        """, program.errors_had[0].pretty_print())
+
+    def test_call_expr_magic(self) -> None:
+        path = self.fixture_abs_path("checker_magic_call.jac")
+        program = JacProgram()
+        mod = program.compile(path)
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 1)
+        self._assert_error_pretty_found("""
+            b: Bar = fn()(); # <-- Ok
+            f: Foo = fn()(); # <-- Error
+            ^^^^^^^^^^^^^^^^
+        """, program.errors_had[0].pretty_print())
+
+    def test_arity(self) -> None:
+        path = self.fixture_abs_path("checker_arity.jac")
+        program = JacProgram()
+        mod = program.compile(path)
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 3)
+        self._assert_error_pretty_found("""
+            f.first_is_self(f); # <-- Error
+                            ^
+        """, program.errors_had[0].pretty_print())
+        self._assert_error_pretty_found("""
+            f.with_default_args(1, 2, 3); # <-- Error
+                                      ^
+        """, program.errors_had[1].pretty_print())
+        self._assert_error_pretty_found("""
+            f.with_default_args();        # <-- Error
+            ^^^^^^^^^^^^^^^^^^^^^
+        """, program.errors_had[2].pretty_print())
+
+    def test_param_types(self) -> None:
+        path = self.fixture_abs_path("checker_param_types.jac")
+        program = JacProgram()
+        mod = program.compile(path)
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 1)
+        self._assert_error_pretty_found("""
+            foo(A()); # <-- Ok
+            foo(B()); # <-- Error
+                ^^^
+        """, program.errors_had[0].pretty_print())
+
+    def test_param_arg_match(self) -> None:
+        path = self.fixture_abs_path("checker_param_types.jac")
+        program = JacProgram()
+        path = self.fixture_abs_path("checker_arg_param_match.jac")
+        mod = program.compile(path)
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 13)
+
+        expected_errors = [
+            """
+            Not all required parameters were provided in the function call: 'a'
+                     f = Foo();
+                     f.bar();
+                     ^^^^^^^
+            """,
+            """
+            Too many positional arguments
+                     f.bar();
+                     f.bar(1);
+                     f.bar(1, 2);
+                              ^
+            """,
+            """
+            Not all required parameters were provided in the function call: 'self', 'a'
+                     f.bar(1, 2);
+                     f.baz();
+                     ^^^^^^^
+            """,
+            """
+            Not all required parameters were provided in the function call: 'a'
+                     f.baz();
+                     f.baz(1);
+                     ^^^^^^^^
+            """,
+            """
+            Not all required parameters were provided in the function call: 'f'
+                     foo(1, 2, d=3, e=4, f=5, c=4);  # order does not matter for named
+                     foo(1, 2, 3, d=4, e=5, g=7, h=8); # missing argument 'f'
+                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+            """,
+            """
+            Positional only parameter 'b' cannot be matched with a named argument
+                     foo(1, 2, 3, d=4, e=5, g=7, h=8); # missing argument 'f'
+                     foo(1, b=2, c=3, d=4, e=5, f=6); # b is positional only
+                            ^^^
+            """,
+            """
+            Too many positional arguments
+                     bar(1, 2, 3, 4, 5, f=6);
+                     bar(1, 2, 3, 4, 5, 6, 7, 8, 9); # too many args
+                                           ^
+            """,
+            """
+            Too many positional arguments
+                     bar(1, 2, 3, 4, 5, f=6);
+                     bar(1, 2, 3, 4, 5, 6, 7, 8, 9); # too many args
+                                              ^
+            """,
+            """
+            Too many positional arguments
+                     bar(1, 2, 3, 4, 5, f=6);
+                     bar(1, 2, 3, 4, 5, 6, 7, 8, 9); # too many args
+                                                 ^
+            """,
+            """
+            Parameter 'c' already matched
+                     bar(1, 2, 3, 4, 5, f=6);
+                     bar(1, 2, 3, 4, 5, 6, 7, 8, 9); # too many args
+                     bar(1, 2, 3, 4, 5, 6, c=3); # already matched
+                                           ^^^
+            """,
+            """
+            Named argument 'h' does not match any parameter
+                     bar(1, 2, 3, 4, 5, 6, 7, 8, 9); # too many args
+                     bar(1, 2, 3, 4, 5, 6, c=3); # already matched
+                     bar(1, 2, 3, 4, 5, 6, h=1); # h is not matched
+                                           ^^^
+            """,
+            """
+            Too many positional arguments
+                     baz(a=1, b=2);
+                     baz(1, b=2); # a can be both positional and keyword
+                     baz(1, 2);  # 'b' can only be keyword arg
+                            ^
+            """,
+            """
+            Not all required parameters were provided in the function call: 'b'
+                     baz(a=1, b=2);
+                     baz(1, b=2); # a can be both positional and keyword
+                     baz(1, 2);  # 'b' can only be keyword arg
+                     ^^^^^^^^^
+            """,
+        ]
+
+        for i, expected in enumerate(expected_errors):
+            self._assert_error_pretty_found(expected, program.errors_had[i].pretty_print())
+
+    def test_self_type_inference(self) -> None:
+        path = self.fixture_abs_path("checker_self_type.jac")
+        program = JacProgram()
+        mod = program.compile(path)
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 1)
+        self._assert_error_pretty_found("""
+          x: str = self.i; # <-- Error
+          ^^^^^^^^^^^^^^^
+        """, program.errors_had[0].pretty_print())
+
+    def test_binary_op(self) -> None:
+        program = JacProgram()
+        mod = program.compile(self.fixture_abs_path("checker_binary_op.jac"))
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 2)
+        self._assert_error_pretty_found("""
+            r2: A = a + a;  # <-- Error
+            ^^^^^^^^^^^^^
+        """, program.errors_had[0].pretty_print())
+        self._assert_error_pretty_found("""
+            r4: str = (a+a) * B(); # <-- Error
+            ^^^^^^^^^^^^^^^^^^^^^
+        """, program.errors_had[1].pretty_print())
+
+    def test_checker_call_expr_class(self) -> None:
+        path = self.fixture_abs_path("checker_call_expr_class.jac")
+        program = JacProgram()
+        mod = program.compile(path)
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 1)
+        self._assert_error_pretty_found("""
+            inst.i = 'str'; # <-- Error
+            ^^^^^^^^^^^^^^
+        """, program.errors_had[0].pretty_print())
+
+    def test_checker_mod_path(self) -> None:
+        path = self.fixture_abs_path("checker_mod_path.jac")
+        program = JacProgram()
+        mod = program.compile(path)
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 1)
+        self._assert_error_pretty_found("""
+            a:int = uni.Module; # <-- Error
+            ^^^^^^^^^^^^^^
+        """, program.errors_had[0].pretty_print())
+
+    def test_checker_cat_is_animal(self) -> None:
+        path = self.fixture_abs_path("checker_cat_is_animal.jac")
+        program = JacProgram()
+        mod = program.compile(path)
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 1)
+        self._assert_error_pretty_found("""
+            animal_func(cat);        # <-- Ok
+            animal_func(lion);       # <-- Ok
+            animal_func(not_animal); # <-- Error
+                        ^^^^^^^^^^
+        """, program.errors_had[0].pretty_print())
+
+    def test_checker_import_missing_module(self) -> None:
+        path = self.fixture_abs_path("checker_import_missing_module.jac")
+        program = JacProgram()
+        mod = program.compile(path)
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 0)
+
+    def test_cyclic_symbol(self) -> None:
+        path = self.fixture_abs_path("checker_cyclic_symbol.jac")
+        program = JacProgram()
+        mod = program.compile(path)
+        # This will result in a stack overflow if not handled properly.
+        # So the fact that it has 0 errors means it passed.
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 0)
 
     def _assert_error_pretty_found(self, needle: str, haystack: str) -> None:
         for line in [line.strip() for line in needle.splitlines() if line.strip()]:

jaclang/compiler/passes/main/tests/test_predynamo_pass.py

@@ -0,0 +1,57 @@
+"""Test ast build pass module."""
+
+import io
+import os
+import sys
+
+from jaclang.compiler.program import JacProgram
+from jaclang.utils.test import TestCase
+from jaclang.settings import settings
+from jaclang.compiler.passes.main import PreDynamoPass
+
+class PreDynamoPassTests(TestCase):
+    """Test pass module."""
+
+    TargetPass = PreDynamoPass
+
+    def setUp(self) -> None:
+        """Set up test."""
+        return super().setUp()
+    
+    def test_predynamo_where_assign(self) -> None:
+        """Test torch.where transformation."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        os.environ["JAC_PREDYNAMO_PASS"] = "True"
+        settings.load_env_vars()
+        code_gen = JacProgram().compile(self.fixture_abs_path("predynamo_where_assign.jac"))
+        sys.stdout = sys.__stdout__
+        self.assertIn("torch.where", code_gen.unparse())
+        os.environ["JAC_PREDYNAMO_PASS"] = "false"
+        settings.load_env_vars()
+        
+    def test_predynamo_where_return(self) -> None:
+        """Test torch.where transformation."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        os.environ["JAC_PREDYNAMO_PASS"] = "True"
+        settings.load_env_vars()
+        code_gen = JacProgram().compile(self.fixture_abs_path("predynamo_where_return.jac"))
+        sys.stdout = sys.__stdout__
+        self.assertIn("torch.where", code_gen.unparse())
+        os.environ["JAC_PREDYNAMO_PASS"] = "false"
+        settings.load_env_vars()
+
+    def test_predynamo_fix3(self) -> None:
+        """Test torch.where transformation."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        os.environ["JAC_PREDYNAMO_PASS"] = "True"
+        settings.load_env_vars()
+        code_gen = JacProgram().compile(self.fixture_abs_path("predynamo_fix3.jac"))
+        sys.stdout = sys.__stdout__
+        unparsed_code = code_gen.unparse()
+        self.assertIn("__inv_freq = torch.where(", unparsed_code)
+        self.assertIn("self.register_buffer('inv_freq', __inv_freq, persistent=False);", unparsed_code)
+        os.environ["JAC_PREDYNAMO_PASS"] = "false"
+        settings.load_env_vars()

jaclang/compiler/passes/main/type_checker_pass.py

@@ -9,80 +9,34 @@ Reference:
     craizy_type_expr branch: type_checker_pass.py
 """
 
-import ast as py_ast
-import os
-
 import jaclang.compiler.unitree as uni
 from jaclang.compiler.passes import UniPass
-from jaclang.compiler.type_system.type_evaluator import TypeEvaluator
-from jaclang.runtimelib.utils import read_file_with_encoding
-
-from .pyast_load_pass import PyastBuildPass
-from .sym_tab_build_pass import SymTabBuildPass
+from jaclang.compiler.type_system import types as jtypes
 
 
 class TypeCheckPass(UniPass):
     """Type checker pass for JacLang."""
 
-    # NOTE: This is done in the binder pass of pyright, however I'm doing this
-    # here, cause this will be the entry point of the type checker and we're not
-    # relying on the binder pass at the moment and we can go back to binder pass
-    # in the future if we needed it.
-    _BUILTINS_STUB_FILE_PATH = os.path.join(
-        os.path.dirname(__file__),
-        "../../../vendor/typeshed/stdlib/builtins.pyi",
-    )
-
-    # Cache the builtins module once it parsed.
-    _BUILTINS_MODULE: uni.Module | None = None
-
     def before_pass(self) -> None:
         """Initialize the checker pass."""
-        self._load_builtins_stub_module()
+        self.evaluator = self.prog.get_type_evaluator()
+        self.evaluator.diagnostic_callback = self._add_diagnostic
         self._insert_builtin_symbols()
 
-        assert TypeCheckPass._BUILTINS_MODULE is not None
-        self.evaluator = TypeEvaluator(
-            builtins_module=TypeCheckPass._BUILTINS_MODULE,
-            program=self.prog,
-        )
+    def _add_diagnostic(self, node: uni.UniNode, message: str, warning: bool) -> None:
+        """Add a diagnostic message to the pass."""
+        if warning:
+            self.log_warning(message, node)
+        else:
+            self.log_error(message, node)
 
     # --------------------------------------------------------------------------
     # Internal helper functions
     # --------------------------------------------------------------------------
 
-    def _binding_builtins(self) -> bool:
-        """Return true if we're binding the builtins stub file."""
-        return self.ir_in == TypeCheckPass._BUILTINS_MODULE
-
-    def _load_builtins_stub_module(self) -> None:
-        """Return the builtins stub module.
-
-        This will parse and cache the stub file and return the cached module on
-        subsequent calls.
-        """
-        if self._binding_builtins() or TypeCheckPass._BUILTINS_MODULE is not None:
-            return
-
-        if not os.path.exists(TypeCheckPass._BUILTINS_STUB_FILE_PATH):
-            raise FileNotFoundError(
-                f"Builtins stub file not found at {TypeCheckPass._BUILTINS_STUB_FILE_PATH}"
-            )
-
-        file_content = read_file_with_encoding(TypeCheckPass._BUILTINS_STUB_FILE_PATH)
-        uni_source = uni.Source(file_content, TypeCheckPass._BUILTINS_STUB_FILE_PATH)
-        mod = PyastBuildPass(
-            ir_in=uni.PythonModuleAst(
-                py_ast.parse(file_content),
-                orig_src=uni_source,
-            ),
-            prog=self.prog,
-        ).ir_out
-        SymTabBuildPass(ir_in=mod, prog=self.prog)
-        TypeCheckPass._BUILTINS_MODULE = mod
-
     def _insert_builtin_symbols(self) -> None:
-        if self._binding_builtins():
+        # Don't insert builtin symbols into the builtin module itself.
+        if self.ir_in == self.evaluator.builtins_module:
             return
 
         # TODO: Insert these symbols.
@@ -92,20 +46,34 @@ class TypeCheckPass(UniPass):
         # '__name__', '__loader__', '__package__', '__spec__', '__path__',
         # '__file__', '__cached__', '__dict__', '__annotations__',
         # '__builtins__', '__doc__',
-        assert (
-            TypeCheckPass._BUILTINS_MODULE is not None
-        ), "Builtins module is not loaded"
         if self.ir_in.parent_scope is not None:
             self.log_info("Builtins module is already bound, skipping.")
             return
         # Review: If we ever assume a module cannot have a parent scope, this will
         # break that contract.
-        self.ir_in.parent_scope = TypeCheckPass._BUILTINS_MODULE
+        self.ir_in.parent_scope = self.evaluator.builtins_module
 
     # --------------------------------------------------------------------------
     # Ast walker hooks
     # --------------------------------------------------------------------------
 
+    def enter_ability(self, node: uni.Ability) -> None:
+        """Enter an ability node."""
+        # If the node has @staticmethod decorator, mark it as static method.
+        # this is needed since ast raised from python does not have this info.
+        for decor in node.decorators or []:
+            ty = self.evaluator.get_type_of_expression(decor)
+            if isinstance(ty, jtypes.ClassType) and ty.is_builtin("staticmethod"):
+                node.is_static = True
+                break
+
+    def exit_import(self, node: uni.Import) -> None:
+        """Exit an import node."""
+        if node.from_loc:
+            for item in node.items:
+                if isinstance(item, uni.ModuleItem):
+                    self.evaluator.get_type_of_module_item(item)
+
     def exit_assignment(self, node: uni.Assignment) -> None:
         """Pyright: Checker.visitAssignment(node: AssignmentNode): boolean."""
         # TODO: In pyright this logic is present at evaluateTypesForAssignmentStatement
@@ -126,3 +94,10 @@ class TypeCheckPass(UniPass):
     def exit_atom_trailer(self, node: uni.AtomTrailer) -> None:
         """Handle the atom trailer node."""
         self.evaluator.get_type_of_expression(node)
+
+    def exit_func_call(self, node: uni.FuncCall) -> None:
+        """Handle the function call node."""
+        # TODO:
+        # 1. Function Existence & Callable Validation
+        # 2. Argument Matching(count, types, names)
+        self.evaluator.get_type_of_expression(node)