jaclang 0.8.1__py3-none-any.whl → 0.8.2__py3-none-any.whl

jaclang/compiler/passes/main/sym_tab_link_pass.py

@@ -32,11 +32,8 @@ class SymTabLinkPass(Transform[uni.Module, uni.Module]):
     def transform(self, ir_in: uni.Module) -> uni.Module:
         """Link the symbol tables for all modules in the program."""
         # Process all modules in the program hub
-        for mod in self.prog.mod.hub.values():
-            module_paths = mod.get_all_sub_nodes(uni.ModulePath)
-            for node in module_paths:
-                self.process_module_path(mod, node)
-
+        for node in ir_in.get_all_sub_nodes(uni.ModulePath):
+            self.process_module_path(ir_in, node)
         return ir_in
 
     def process_module_path(self, mod: uni.Module, node: uni.ModulePath) -> None:

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

@@ -1,12 +1,10 @@
 """Test pass module."""
 
-from jaclang.compiler.passes.main import CompilerMode as CMode
 from jaclang.compiler.program import JacProgram
 from jaclang.utils.test import TestCase
 import unittest
 
 
-@unittest.skip("Skipping CFG build pass tests")
 class TestCFGBuildPass(TestCase):
     """Test FuseTypeInfoPass module."""
 
@@ -23,9 +21,7 @@ class TestCFGBuildPass(TestCase):
         with open(file_name, "r") as f:
             file_source = f.read()
 
-        ir = (prog := JacProgram()).compile_from_str(
-            source_str=file_source, file_path=file_name, mode=CMode.COMPILE
-        )
+        ir = (prog := JacProgram()).compile(use_str=file_source, file_path=file_name)
 
         cfg_pass = CoalesceBBPass(
             ir_in=ir,
@@ -71,9 +67,7 @@ class TestCFGBuildPass(TestCase):
         with open(file_name, "r") as f:
             file_source = f.read()
 
-        ir = (prog := JacProgram()).compile_from_str(
-            source_str=file_source, file_path=file_name, mode=CMode.COMPILE
-        )
+        ir = (prog := JacProgram()).compile(use_str=file_source, file_path=file_name)
 
         cfg_pass = CoalesceBBPass(
             ir_in=ir,

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

@@ -4,7 +4,7 @@ import io
 import sys
 
 import jaclang.compiler.unitree as uni
-from jaclang import JacMachineInterface as Jac, JacMachine
+from jaclang import JacMachine as Jac
 from jaclang.cli import cli
 from jaclang.compiler.program import JacProgram
 from jaclang.utils.test import TestCase
@@ -15,9 +15,8 @@ class DeclImplMatchPassTests(TestCase):
 
     def setUp(self) -> None:
         """Set up test."""
-        self.mach = JacMachine(self.fixture_abs_path("./"))
+        Jac.set_base_path(self.fixture_abs_path("./"))
         Jac.attach_program(
-            self.mach,
             JacProgram(),
         )
         return super().setUp()
@@ -110,7 +109,7 @@ class DeclImplMatchPassTests(TestCase):
         """Test walking through edges and nodes."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "mtest", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("mtest", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("2.0\n", stdout_value)
@@ -119,7 +118,7 @@ class DeclImplMatchPassTests(TestCase):
         """Test walking through edges."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "impl_grab", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("impl_grab", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("1.414", stdout_value)
@@ -128,7 +127,7 @@ class DeclImplMatchPassTests(TestCase):
         """Test complex nested impls."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "nested_impls", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("nested_impls", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue().split("\n")
         self.assertIn("Hello,from bar in kk", stdout_value[0])
@@ -142,7 +141,7 @@ class DeclImplMatchPassTests(TestCase):
         """Parse micro jac file."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "atest", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("atest", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(stdout_value, "42\n")
@@ -151,7 +150,7 @@ class DeclImplMatchPassTests(TestCase):
         """Parse micro jac file."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "enumerations", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("enumerations", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(stdout_value, "1\n")

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

@@ -7,7 +7,6 @@ import unittest
 
 import jaclang.compiler.unitree as uni
 from jaclang.cli import cli
-from jaclang.compiler.passes.main import CompilerMode as CMode
 from jaclang.compiler.program import JacProgram
 from jaclang.utils.test import TestCase
 
@@ -21,7 +20,7 @@ class ImportPassPassTests(TestCase):
 
     def test_pygen_jac_cli(self) -> None:
         """Basic test for pass."""
-        (out := JacProgram()).compile(self.fixture_abs_path("base.jac"))
+        (out := JacProgram()).build(self.fixture_abs_path("base.jac"))
         self.assertFalse(out.errors_had)
         mod = out.mod.hub[self.fixture_abs_path("impl/imps.jac")]
         self.assertIn("56", str(mod.to_dict()))
@@ -38,7 +37,7 @@ class ImportPassPassTests(TestCase):
 
     def test_import_include_auto_impl(self) -> None:
         """Basic test for pass."""
-        (prog := JacProgram()).compile(self.fixture_abs_path("incautoimpl.jac"))
+        (prog := JacProgram()).build(self.fixture_abs_path("incautoimpl.jac"))
         num_modules = len(list(prog.mod.hub.values())[1].impl_mod) + 1
         mod_names = [i.name for i in list(prog.mod.hub.values())[1].impl_mod]
         self.assertEqual(num_modules, 5)
@@ -50,7 +49,7 @@ class ImportPassPassTests(TestCase):
 
     def test_annexalbe_by_discovery(self) -> None:
         """Basic test for pass."""
-        (prog := JacProgram()).compile(self.fixture_abs_path("incautoimpl.jac"))
+        (prog := JacProgram()).build(self.fixture_abs_path("incautoimpl.jac"))
         count = 0
         all_mods = prog.mod.hub.values()
         self.assertEqual(len(all_mods), 6)
@@ -66,10 +65,7 @@ class ImportPassPassTests(TestCase):
     @unittest.skip("TODO: Fix when we have the type checker")
     def test_py_raise_map(self) -> None:
         """Basic test for pass."""
-        (build := JacProgram()).compile(
-            self.fixture_abs_path("py_imp_test.jac"),
-            mode=CMode.TYPECHECK,
-        )
+        (build := JacProgram()).build(self.fixture_abs_path("py_imp_test.jac"))
         p = {
             "math": r"jaclang/vendor/mypy/typeshed/stdlib/math.pyi$",
             "pygame_mock": r"pygame_mock/__init__.pyi$",
@@ -91,9 +87,7 @@ class ImportPassPassTests(TestCase):
     @unittest.skip("TODO: Fix when we have the type checker")
     def test_py_raised_mods(self) -> None:
         """Basic test for pass."""
-        (prog := JacProgram()).compile(
-            self.fixture_abs_path("py_imp_test.jac"), mode=CMode.TYPECHECK
-        )
+        (prog := JacProgram()).build(self.fixture_abs_path("py_imp_test.jac"))
         for i in list(
             filter(
                 lambda x: x.is_raised_from_py,
@@ -125,13 +119,6 @@ class ImportPassPassTests(TestCase):
         self.assertIn("bar", stdout_value)
         self.assertIn("baz", stdout_value)
 
-    def test_raise_syntax_error(self) -> None:
-        """Test raise error on the parser , dont go to the next pass."""
-        (state := JacProgram()).compile(self.fixture_abs_path("main_err.jac"))
-        self.assertTrue(state.errors_had)
-        self.assertEqual(len(state.errors_had), 1)
-        self.assertIn("Syntax Error", state.errors_had[0].msg)
-
     def test_circular_import(self) -> None:
         """Test circular import."""
         (state := JacProgram()).compile(self.fixture_abs_path("circular_import.jac"))

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

@@ -6,9 +6,8 @@ import sys
 import types
 
 import jaclang.compiler.unitree as uni
-from jaclang.compiler.passes.main import CompilerMode as CMode, PyastGenPass
+from jaclang.compiler.passes.main import PyastGenPass
 from jaclang.compiler.program import JacProgram
-from jaclang.runtimelib.machine import JacMachine
 from jaclang.utils.test import AstSyncTestMixin, TestCaseMicroSuite
 
 
@@ -53,7 +52,6 @@ class PyastGenPassTests(TestCaseMicroSuite, AstSyncTestMixin):
             sys.stdout = captured_output
             module = types.ModuleType("__main__")
             module.__dict__["__file__"] = code_gen.loc.mod_path
-            module.__dict__["__jac_mach__"] = JacMachine()
             exec(prog, module.__dict__)
             sys.stdout = sys.__stdout__
             stdout_value = captured_output.getvalue()
@@ -123,9 +121,7 @@ class ValidateTreeParentTest(TestCaseMicroSuite):
 
     def micro_suite_test(self, filename: str) -> None:
         """Parse micro jac file."""
-        code_gen = JacProgram().compile(
-            self.fixture_abs_path(filename), mode=CMode.PARSE
-        )
+        code_gen = JacProgram().compile(self.fixture_abs_path(filename))
         self.assertTrue(self.parent_scrub(code_gen))
         code_gen = JacProgram().compile(self.fixture_abs_path(filename))
         self.assertTrue(self.parent_scrub(code_gen))

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

@@ -1,7 +1,6 @@
 """Test sub node pass module."""
 
 from jaclang.compiler.passes import UniPass
-from jaclang.compiler.passes.main import CompilerMode as CMode
 from jaclang.compiler.program import JacProgram
 from jaclang.utils.test import TestCase
 
@@ -16,8 +15,7 @@ class SubNodePassTests(TestCase):
     def test_sub_node_pass(self) -> None:
         """Basic test for pass."""
         code_gen = (out := JacProgram()).compile(
-            file_path=self.examples_abs_path("manual_code/circle.jac"),
-            mode=CMode.PARSE,
+            file_path=self.examples_abs_path("manual_code/circle.jac")
         )
         for i in code_gen.kid[1].kid:
             for k, v in i._sub_node_tab.items():

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

@@ -2,7 +2,6 @@
 
 import os
 
-from jaclang.compiler.passes.main import CompilerMode as CMode
 from jaclang.compiler.program import JacProgram
 from jaclang.utils.test import TestCase
 
@@ -23,7 +22,7 @@ class SymTabLinkPassTests(TestCase):
             "symtab_link_tests",
             "no_dupls.jac",
         )
-        mod = JacProgram().compile(file_path, mode=CMode.TYPECHECK)
+        mod = JacProgram().build(file_path)
         self.assertEqual(
             len(mod.sym_tab.names_in_scope.values()),
             3,
@@ -33,20 +32,24 @@ class SymTabLinkPassTests(TestCase):
                 i,
                 str(mod.sym_tab.names_in_scope.values()),
             )
-        self.assertEqual(len(mod.sym_tab.names_in_scope["a"].uses), 2)
-        self.assertEqual(
-            len(
-                list(
-                    mod.sym_tab.kid_scope[0]
-                    .kid_scope[0]
-                    .kid_scope[0]
-                    .kid_scope[0]
-                    .inherited_scope[0]
-                    .base_symbol_table.names_in_scope.values()
-                )[0].uses,
-            ),
-            3,
-        )
+        # TODO: def use is called on single file so this breaks
+        # Def Use pass will go away with full type checking
+        # self.assertEqual(
+        #     len(mod.sym_tab.names_in_scope["a"].uses), 4
+        # )
+        # self.assertEqual(
+        #     len(
+        #         list(
+        #             mod.sym_tab.kid_scope[0]
+        #             .kid_scope[0]
+        #             .kid_scope[0]
+        #             .kid_scope[0]
+        #             .inherited_scope[0]
+        #             .base_symbol_table.names_in_scope.values()
+        #         )[0].uses,
+        #     ),
+        #     3,
+        # )
 
     def test_package(self) -> None:
         """Test package."""
@@ -57,6 +60,6 @@ class SymTabLinkPassTests(TestCase):
             "main.jac",
         )
         prog = JacProgram()
-        prog.compile(file_path, mode=CMode.COMPILE)
+        prog.compile(file_path)
         self.assertEqual(prog.errors_had, [])
         self.assertEqual(prog.warnings_had, [])