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

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

@@ -0,0 +1,11 @@
+def test_if_without_else(x: int) {
+    if (x > 0) {
+        print("Positive");
+    }
+    print("Done");
+}
+
+with entry {
+    test_if_without_else(5);
+    test_if_without_else(-3);
+}

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

@@ -0,0 +1,9 @@
+def test_return_direct() {
+    print("Before return");
+    return;
+    print("After return");
+}
+
+with entry {
+    test_return_direct();
+}

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

@@ -0,0 +1,2 @@
+
+glob some_int: int = 42;

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

@@ -0,0 +1,6 @@
+import from checker_imported {
+    some_int as alias
+}
+
+glob i: int = alias;  # <-- Ok
+glob s: str = alias;  # <-- Error

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

@@ -126,5 +126,5 @@ with entry {
     root spawn walker1();
     root spawn walker2();
     root spawn walker3();
-    print(_.node_dot(root));
+    print(printgraph(root));
 }

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

@@ -0,0 +1,11 @@
+import math as alias;
+with entry {
+
+  # math module imports sys so it has the symbol
+  # we're not using math.pi since it's a Final[float]
+  # and we haven't implemented generic types yet.
+  m = alias;
+
+  i: int = m.sys.prefix; # <-- Error
+  s: str = m.sys.prefix; # <-- Ok
+}

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

@@ -0,0 +1,5 @@
+with entry {
+  some_int_inferred = 42;
+  assigning_to_int: int = some_int_inferred; # <-- Ok
+  assigning_to_str: str = some_int_inferred; # <-- Error
+}

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

@@ -0,0 +1,13 @@
+node Foo {
+  # We can infer the type of `bar` but the jac
+  # syntax makes the type annotation a must here.
+  has bar: int = 42;
+}
+with entry {
+  f: Foo = Foo();
+
+  i = 42; s = "foo";
+
+  i = f.bar; # <-- Ok
+  s = f.bar; # <-- Error
+}

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

@@ -0,0 +1,11 @@
+node Bar {
+  has baz: int;
+}
+node Foo {
+  has bar: Bar;
+}
+with entry {
+  f: Foo = Foo();
+  i: int = f.bar.baz; # <-- Ok
+  s: str = f.bar.baz; # <-- Error
+}

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

@@ -0,0 +1,47 @@
+import M1;
+# import M2 as m2alias;
+# import M3, M4;
+# import M5 as m5alias, M6 as m6alias;
+# import from M7 {M7S1}
+# import from M8 {M8S1 as m8s1alias, M8S2 as m8s2alias}
+# include M9;
+# glob a = 5, k = 9;
+glob aa = 9;
+with entry{
+    Y: int;
+    Y = 0;
+    # b.Person.ss = 9;
+    n = 0;
+    z = Y;
+    aa = 9;
+}
+with entry {
+    Y = 99;
+
+}
+def ccc() {
+    # aa = 99; #Error:name 'aa' is assigned to before global declaration
+    if (0) {
+        global aa;
+        global bb;
+        aa = 88;
+        bb = 0;
+        p = 90;
+        M1.k = 0;
+    } 
+    aa = 99;
+    print(aa);
+}
+with entry {
+    ccc();
+    print(aa);
+}
+
+
+# import random;
+
+
+
+# with entry{
+#     d = random.randint(1, 100);
+# }

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

@@ -0,0 +1,8 @@
+glob should_pass1: int = 42;
+glob should_fail1: int = "foo";
+glob should_pass2: str = "bar";
+glob should_fail2: str = 42;
+
+# This is without any explicit type annotation.
+# was failing after the first PR.
+glob should_be_fine = "baz";

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

@@ -0,0 +1,111 @@
+"""Test Binder pass."""
+
+from jaclang.compiler.program import JacProgram
+from jaclang.utils.symtable_test_helpers import SymTableTestMixin
+
+
+class BinderPassTests( SymTableTestMixin):
+    """Test pass module."""
+
+    def setUp(self) -> None:
+        """Set up test."""
+        return super().setUp()
+
+    def test_glob_sym_build(self) -> None:
+        """Test symbol table construction for symbol_binding_test.jac fixture."""
+        mod_targ = JacProgram().bind(self.fixture_abs_path("sym_binder.jac"))
+        sym_table = mod_targ.sym_tab
+
+        #currenlty 'aa' is not in the main table, need fix #TODO
+            # defns=[(9, 6), (16, 5), (27, 9), (32, 5)],
+            # uses=[(33, 11), (37, 11)]
+        # Test global variable 'aa'
+        self.assert_symbol_complete(
+            sym_table, "aa", "variable",
+            decl=(9, 6),
+            defns=[(9, 6), (16, 5), ],
+            uses=[ (37, 11)]
+        )
+
+        # Test global variable 'n'
+        self.assert_symbol_complete(
+            sym_table, "n", "variable",
+            decl=(14, 5),
+            defns=[(14, 5)]
+        )
+
+        # Test imported module 'M1'
+        self.assert_symbol_complete(
+            sym_table, "M1", "module",
+            decl=(1, 8),
+            defns=[(1, 8)]
+        )
+
+        # Test global variable 'z'
+        self.assert_symbol_complete(
+            sym_table, "z", "variable",
+            decl=(15, 5),
+            defns=[(15, 5)]
+        )
+
+        # Test global variable 'Y'
+        self.assert_symbol_complete(
+            sym_table, "Y", "variable",
+            decl=(11, 5),
+            defns=[(11, 5), (12, 5), (19, 5)],
+            uses=[(15, 9)]
+        )
+
+        # Test ability 'ccc'
+        self.assert_symbol_complete(
+            sym_table, "ccc", "ability",
+            decl=(22, 5),
+            defns=[(22, 5)],
+            uses=[(36, 5)]
+        )
+
+        #TODO: Fix the following test, 'bb' is not in the main table
+        # # Test global variable 'bb'
+        # self.assert_symbol_complete(
+        #     sym_table, "bb", "variable",
+        #     decl=(26, 17),
+        #     defns=[(26, 17), (28, 9)]
+        # )
+
+        # Test sub-table for ability 'ccc'
+        ccc_table = self.assert_sub_table_exists(sym_table, "ccc",'ability')
+
+        # Test sub-table for if statement inside 'ccc'
+        if_table = self.assert_sub_table_exists(ccc_table, "IfStmt",'variable')
+
+        # Test local variable 'p' inside if statement
+        self.assert_symbol_complete(
+            if_table, "p", "variable",
+            decl=(29, 9),
+            defns=[(29, 9)]
+        )
+
+    def test_symbol_table_structure(self) -> None:
+        """Test the overall structure of the symbol table."""
+        mod_targ = JacProgram().build(self.fixture_abs_path("sym_binder.jac"))
+        sym_table = mod_targ.sym_tab
+
+        # Verify main module table exists
+        self.assertIn("sym_binder", str(sym_table))
+
+        # Verify expected number of symbols in main table
+        main_symbols = ["aa", "n", "M1", "z", "Y", "ccc"]
+        # 'bb' is not here:need fix #TODO
+        for symbol_name in main_symbols:
+            self.assert_symbol_exists(sym_table, symbol_name)
+
+        # Verify sub-tables exist
+        sub_tables = sym_table.kid_scope
+        self.assertTrue(len(sub_tables) > 0, "No sub-tables found")
+
+        # Verify ability sub-table has nested if-statement table
+        ccc_table = self.assert_sub_table_exists(sym_table, "ccc", 'ability')
+        if_table = self.assert_sub_table_exists(ccc_table, "IfStmt", 'variable')
+
+        # Verify if-statement table contains local variable
+        self.assert_symbol_exists(if_table, "p")

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

@@ -16,19 +16,9 @@ class TestCFGBuildPass(TestCase):
         """Test basic blocks."""
         file_name = self.fixture_abs_path("cfg_gen.jac")
 
-        from jaclang.compiler.passes.main.cfg_build_pass import CoalesceBBPass
+        from jaclang.compiler.passes.main.cfg_build_pass import cfg_dot_from_file
 
-        with open(file_name, "r") as f:
-            file_source = f.read()
-
-        ir = (prog := JacProgram()).compile(use_str=file_source, file_path=file_name)
-
-        cfg_pass = CoalesceBBPass(
-            ir_in=ir,
-            prog=prog,
-        )
-
-        dot = cfg_pass.printgraph_cfg()
+        dot = cfg_dot_from_file(file_name=file_name)
 
         expected_dot = (
             "digraph G {\n"
@@ -62,19 +52,9 @@ class TestCFGBuildPass(TestCase):
         """Test basic blocks."""
         file_name = self.fixture_abs_path("cfg_ability_test.jac")
 
-        from jaclang.compiler.passes.main.cfg_build_pass import CoalesceBBPass
-
-        with open(file_name, "r") as f:
-            file_source = f.read()
+        from jaclang.compiler.passes.main.cfg_build_pass import cfg_dot_from_file
 
-        ir = (prog := JacProgram()).compile(use_str=file_source, file_path=file_name)
-
-        cfg_pass = CoalesceBBPass(
-            ir_in=ir,
-            prog=prog,
-        )
-
-        dot = cfg_pass.printgraph_cfg()
+        dot = cfg_dot_from_file(file_name=file_name)
 
         expected_dot = (
             "digraph G {\n"
@@ -93,3 +73,61 @@ class TestCFGBuildPass(TestCase):
         )
 
         self.assertEqual(dot, expected_dot)
+
+    def test_cfg_ability_with_has(self) -> None:
+        """Test basic blocks with ability and has."""
+        file_name = self.fixture_abs_path("cfg_has_var.jac")
+
+        from jaclang.compiler.passes.main.cfg_build_pass import cfg_dot_from_file
+
+        dot = cfg_dot_from_file(file_name=file_name)
+
+        expected_dot = (
+            "digraph G {\n"
+            '  0 [label="BB0\\nobj Rock", shape=box];\n'
+            '  1 [label="BB1\\nhas pellets : list ;", shape=box];\n'
+            '  2 [label="BB2\\ncan count_pellets( ) -> int\\nreturn self . pellets . length ( ) ;", shape=box];\n'
+            '  3 [label="BB3\\nrock = Rock ( pellets = [ 1 , 2 , 3 ] ) ;\\nprint ( \\"Number of pellets: \\" + rock . count_pellets ( ) . to_string ( ) ) ;", shape=box];\n'
+            "  0 -> 1;\n"
+            "  0 -> 2;\n"
+            "}\n"
+        )
+
+        self.assertEqual(dot, expected_dot)
+
+    def test_cfg_if_no_else(self) -> None:
+        """Test basic blocks with if without else."""
+        file_name = self.fixture_abs_path("cfg_if_no_else.jac")
+
+        from jaclang.compiler.passes.main.cfg_build_pass import cfg_dot_from_file
+
+        dot = cfg_dot_from_file(file_name=file_name)
+
+        expected_dot = (
+            "digraph G {\n"
+            '  0 [label="BB0\\ncan test_if_without_else( x : int )\\nif ( x > 0 )", shape=box];\n'
+            '  1 [label="BB1\\nprint ( \\"Positive\\" ) ;", shape=box];\n'
+            '  2 [label="BB2\\nprint ( \\"Done\\" ) ;", shape=box];\n'
+            '  3 [label="BB3\\ntest_if_without_else ( 5 ) ;\\ntest_if_without_else ( - 3 ) ;", shape=box];\n'
+            "  0 -> 1;\n"
+            "  0 -> 2;\n"
+            "  1 -> 2;\n"
+            "}\n"
+        )
+        self.assertEqual(dot, expected_dot)
+
+    def test_cfg_return_stmt(self) -> None:
+        """Test basic blocks with return statement."""
+        file_name = self.fixture_abs_path("cfg_return.jac")
+
+        from jaclang.compiler.passes.main.cfg_build_pass import cfg_dot_from_file
+
+        dot = cfg_dot_from_file(file_name=file_name)
+
+        expected_dot = (
+            "digraph G {\n"
+            '  0 [label="BB0\\ncan test_return_direct( )\\nprint ( \\"Before return\\" ) ;\\nreturn ;\\nprint ( \\"After return\\" ) ;", shape=box];\n'
+            '  1 [label="BB1\\ntest_return_direct ( ) ;", shape=box];\n'
+            "}\n"
+        )
+        self.assertEqual(dot, expected_dot)

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

@@ -0,0 +1,87 @@
+
+"""Tests for typechecker pass (the pyright implementation)."""
+
+from tempfile import NamedTemporaryFile
+
+from jaclang.utils.test import TestCase
+from jaclang.compiler.passes.main import TypeCheckPass
+from jaclang.compiler.program import JacProgram
+
+
+class TypeCheckerPassTests(TestCase):
+    """Test class obviously."""
+
+    def test_explicit_type_annotation_in_assignment(self) -> None:
+        """Test explicit type annotation in assignment."""
+        program = JacProgram()
+        program.build(
+            self.fixture_abs_path("type_annotation_assignment.jac"), type_check=True
+        )
+        self.assertEqual(len(program.errors_had), 2)
+        self._assert_error_pretty_found("""
+            glob should_fail1: int = "foo";
+                 ^^^^^^^^^^^^^^^^^^^^^^^^^
+        """, program.errors_had[0].pretty_print())
+
+        self._assert_error_pretty_found("""
+            glob should_fail2: str = 42;
+                 ^^^^^^^^^^^^^^^^^^^^^^
+        """, program.errors_had[1].pretty_print())
+
+    def test_infer_type_of_assignment(self) -> None:
+        program = JacProgram()
+        mod = program.compile(self.fixture_abs_path("infer_type_assignment.jac"))
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 1)
+
+        self._assert_error_pretty_found("""
+          assigning_to_str: str = some_int_inferred;
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        """, program.errors_had[0].pretty_print())
+
+    def test_member_access_type_resolve(self) -> None:
+        program = JacProgram()
+        mod = program.compile(self.fixture_abs_path("member_access_type_resolve.jac"))
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 1)
+        self._assert_error_pretty_found("""
+          s: str = f.bar.baz;
+          ^^^^^^^^^^^^^^^^^^^
+        """, 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"))
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 1)
+        self._assert_error_pretty_found("""
+          s = f.bar;
+          ^^^^^^^^^
+        """, program.errors_had[0].pretty_print())
+
+    def test_import_symbol_type_infer(self) -> None:
+        program = JacProgram()
+        mod = program.compile(self.fixture_abs_path("import_symbol_type_infer.jac"))
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 1)
+        self._assert_error_pretty_found("""
+            i: int = m.sys.prefix;
+            ^^^^^^^^^^^^^^^^^^^^^
+        """, program.errors_had[0].pretty_print())
+
+    def test_from_import(self) -> None:
+        path = self.fixture_abs_path("checker_importer.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("""
+          glob s: str = alias;
+               ^^^^^^^^^^^^^^
+        """, program.errors_had[0].pretty_print())
+
+
+    def _assert_error_pretty_found(self, needle: str, haystack: str) -> None:
+        for line in [line.strip() for line in needle.splitlines() if line.strip()]:
+            self.assertIn(line, haystack, f"Expected line '{line}' not found in:\n{haystack}")

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

@@ -50,43 +50,43 @@ class PyastGenPassTests(TestCaseMicroSuite, AstSyncTestMixin):
         # Function (full).
         sym_fn1 = code_gen.lookup("fn1")
         self.assertEqual(sym_fn1.semstr, "A function that takes two integers and returns nothing.")
-        self.assertEqual(sym_fn1.fetch_sym_tab.lookup("bar").semstr, "The first integer parameter.")
+        self.assertEqual(sym_fn1.symbol_table.lookup("bar").semstr, "The first integer parameter.")
 
         # Function (Missing baz)
         sym_fn2 = code_gen.lookup("fn2")
         self.assertEqual(sym_fn2.semstr, "A function that takes one integer and returns nothing.")
-        self.assertEqual(sym_fn2.fetch_sym_tab.lookup("bar").semstr, "The first integer parameter.")
-        self.assertEqual(sym_fn2.fetch_sym_tab.lookup("baz").semstr, "")
+        self.assertEqual(sym_fn2.symbol_table.lookup("bar").semstr, "The first integer parameter.")
+        self.assertEqual(sym_fn2.symbol_table.lookup("baz").semstr, "")
 
         # Function (Without sem at all)
         sym_fn3 = code_gen.lookup("fn3")
         self.assertTrue(sym_fn3.semstr == "")
-        self.assertEqual(sym_fn3.fetch_sym_tab.lookup("bar").semstr, "")
-        self.assertEqual(sym_fn3.fetch_sym_tab.lookup("baz").semstr, "")
+        self.assertEqual(sym_fn3.symbol_table.lookup("bar").semstr, "")
+        self.assertEqual(sym_fn3.symbol_table.lookup("baz").semstr, "")
 
         # Architype (with body).
         sym_arch1 = code_gen.lookup("Arch1")
         self.assertEqual(sym_arch1.semstr, "An object that contains two integer properties.")
-        self.assertEqual(sym_arch1.fetch_sym_tab.lookup("bar").semstr, "The first integer property.")
-        self.assertEqual(sym_arch1.fetch_sym_tab.lookup("baz").semstr, "The second integer property.")
+        self.assertEqual(sym_arch1.symbol_table.lookup("bar").semstr, "The first integer property.")
+        self.assertEqual(sym_arch1.symbol_table.lookup("baz").semstr, "The second integer property.")
 
         # Architype (without body).
         sym_arch2 = code_gen.lookup("Arch2")
         self.assertEqual(sym_arch2.semstr, "An object that contains two integer properties.")
-        self.assertEqual(sym_arch2.fetch_sym_tab.lookup("bar").semstr, "The first integer property.")
-        self.assertEqual(sym_arch2.fetch_sym_tab.lookup("baz").semstr, "The second integer property.")
+        self.assertEqual(sym_arch2.symbol_table.lookup("bar").semstr, "The first integer property.")
+        self.assertEqual(sym_arch2.symbol_table.lookup("baz").semstr, "The second integer property.")
 
         # Enum (with body).
         sym_enum1 = code_gen.lookup("Enum1")
         self.assertEqual(sym_enum1.semstr, "An enumeration that defines two values: Bar and Baz.")
-        self.assertEqual(sym_enum1.fetch_sym_tab.lookup("Bar").semstr, "The Bar value of the Enum1 enumeration.")
-        self.assertEqual(sym_enum1.fetch_sym_tab.lookup("Baz").semstr, "The Baz value of the Enum1 enumeration.")
+        self.assertEqual(sym_enum1.symbol_table.lookup("Bar").semstr, "The Bar value of the Enum1 enumeration.")
+        self.assertEqual(sym_enum1.symbol_table.lookup("Baz").semstr, "The Baz value of the Enum1 enumeration.")
 
         # Enum (without body).
         sym_enum2 = code_gen.lookup("Enum2")
         self.assertEqual(sym_enum2.semstr, "An enumeration that defines two values: Bar and Baz.")
-        self.assertEqual(sym_enum2.fetch_sym_tab.lookup("Bar").semstr, "The Bar value of the Enum2 enumeration.")
-        self.assertEqual(sym_enum2.fetch_sym_tab.lookup("Baz").semstr, "The Baz value of the Enum2 enumeration.")
+        self.assertEqual(sym_enum2.symbol_table.lookup("Bar").semstr, "The Bar value of the Enum2 enumeration.")
+        self.assertEqual(sym_enum2.symbol_table.lookup("Baz").semstr, "The Baz value of the Enum2 enumeration.")
 
         if code_gen.gen.py_ast and isinstance(code_gen.gen.py_ast[0], ast3.Module):
             prog = compile(code_gen.gen.py_ast[0], filename="<ast>", mode="exec")

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

@@ -15,24 +15,24 @@ class SemDefMatchPassTests(TestCase):
         mod = out.mod.hub[self.fixture_abs_path("sem_def_match.jac")]
 
         self.assertEqual(mod.lookup("E").decl.name_of.semstr, "An enum representing some values.")  # type: ignore
-        self.assertEqual(mod.lookup("E").fetch_sym_tab.lookup("A").decl.name_of.semstr, "The first value of the enum E.")  # type: ignore
-        self.assertEqual(mod.lookup("E").fetch_sym_tab.lookup("B").decl.name_of.semstr, "The second value of the enum E.")  # type: ignore
+        self.assertEqual(mod.lookup("E").symbol_table.lookup("A").decl.name_of.semstr, "The first value of the enum E.")  # type: ignore
+        self.assertEqual(mod.lookup("E").symbol_table.lookup("B").decl.name_of.semstr, "The second value of the enum E.")  # type: ignore
 
         self.assertEqual(mod.lookup("Person").decl.name_of.semstr, "A class representing a person.")  # type: ignore
 
-        person_scope = mod.lookup("Person").fetch_sym_tab  # type: ignore
+        person_scope = mod.lookup("Person").symbol_table  # type: ignore
         self.assertEqual(person_scope.lookup("name").decl.name_of.semstr, "The name of the person.")  # type: ignore
         self.assertEqual(person_scope.lookup("yob").decl.name_of.semstr, "The year of birth of the person.")  # type: ignore
 
         sym_calc_age = person_scope.lookup("calc_age")  # type: ignore
         self.assertEqual(sym_calc_age.decl.name_of.semstr, "Calculate the age of the person.")  # type: ignore
 
-        calc_age_scope = sym_calc_age.fetch_sym_tab  # type: ignore
+        calc_age_scope = sym_calc_age.symbol_table  # type: ignore
         self.assertEqual(calc_age_scope.lookup("year").decl.name_of.semstr, "The year to calculate the age against.")  # type: ignore
 
         self.assertEqual(mod.lookup("OuterClass").decl.name_of.semstr, "A class containing an inner class.")  # type: ignore
-        outer_scope = mod.lookup("OuterClass").fetch_sym_tab  # type: ignore
+        outer_scope = mod.lookup("OuterClass").symbol_table  # type: ignore
         self.assertEqual(outer_scope.lookup("InnerClass").decl.name_of.semstr, "An inner class within OuterClass.")  # type: ignore
-        inner_scope = outer_scope.lookup("InnerClass").fetch_sym_tab  # type: ignore
+        inner_scope = outer_scope.lookup("InnerClass").symbol_table  # type: ignore
         self.assertEqual(inner_scope.lookup("inner_value").decl.name_of.semstr, "A value specific to the inner class.")  # type: ignore
 

jaclang/compiler/passes/main/type_checker_pass.py

@@ -0,0 +1,128 @@
+"""
+Type checker pass.
+
+This will perform type checking on the Jac program and accumulate any type
+errors found during the process in the pass's had_errors, had_warnings list.
+
+Reference:
+    Pyright: packages/pyright-internal/src/analyzer/checker.ts
+    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
+
+
+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._insert_builtin_symbols()
+
+        assert TypeCheckPass._BUILTINS_MODULE is not None
+        self.evaluator = TypeEvaluator(
+            builtins_module=TypeCheckPass._BUILTINS_MODULE,
+            program=self.prog,
+        )
+
+    # --------------------------------------------------------------------------
+    # 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():
+            return
+
+        # TODO: Insert these symbols.
+        # Reference: pyright Binder.bindModule()
+        #
+        # List taken from https://docs.python.org/3/reference/import.html#__name__
+        # '__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
+
+    # --------------------------------------------------------------------------
+    # Ast walker hooks
+    # --------------------------------------------------------------------------
+
+    def exit_assignment(self, node: uni.Assignment) -> None:
+        """Pyright: Checker.visitAssignment(node: AssignmentNode): boolean."""
+        # TODO: In pyright this logic is present at evaluateTypesForAssignmentStatement
+        # and we're calling getTypeForStatement from here, This can be moved into the
+        # other place or we can keep it here.
+        #
+        # Grep this in pyright TypeEvaluator.ts:
+        # `} else if (node.d.leftExpr.nodeType === ParseNodeType.Name) {`
+        #
+        if len(node.target) == 1 and (node.value is not None):  # Simple assignment.
+            left_type = self.evaluator.get_type_of_expression(node.target[0])
+            right_type = self.evaluator.get_type_of_expression(node.value)
+            if not self.evaluator.assign_type(right_type, left_type):
+                self.log_error(f"Cannot assign {right_type} to {left_type}")
+        else:
+            pass  # TODO: handle
+
+    def exit_atom_trailer(self, node: uni.AtomTrailer) -> None:
+        """Handle the atom trailer node."""
+        self.evaluator.get_type_of_expression(node)