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

jaclang/compiler/passes/main/pyjac_ast_link_pass.py

@@ -14,6 +14,7 @@ relationships between the two AST representations throughout the compilation pro
 """
 
 import ast as ast3
+from typing import Sequence
 
 import jaclang.compiler.unitree as uni
 from jaclang.compiler.passes import UniPass
@@ -50,7 +51,7 @@ class PyJacAstLinkPass(UniPass):
             self.link_jac_py_nodes(jac_node=node.body, py_nodes=node.gen.py_ast)
 
     def exit_impl_def(self, node: uni.ImplDef) -> None:
-        for i in node.target.items:
+        for i in node.target:
             if i.name_spec.name_of.sym:
                 self.link_jac_py_nodes(
                     jac_node=i, py_nodes=i.name_spec.name_of.sym.decl.gen.py_ast
@@ -62,12 +63,12 @@ class PyJacAstLinkPass(UniPass):
 
         if isinstance(node.decl_link, uni.Ability) and node.decl_link.signature:
             if isinstance(node.spec, uni.FuncSignature) and node.spec.params:
-                for src_prm in node.spec.params.items:
+                for src_prm in node.spec.params:
                     if (
                         isinstance(node.decl_link.signature, uni.FuncSignature)
                         and node.decl_link.signature.params
                     ):
-                        for trg_prm in node.decl_link.signature.params.items:
+                        for trg_prm in node.decl_link.signature.params:
                             if src_prm.name.sym_name == trg_prm.name.sym_name:
                                 self.link_jac_py_nodes(
                                     jac_node=src_prm, py_nodes=trg_prm.gen.py_ast
@@ -88,9 +89,9 @@ class PyJacAstLinkPass(UniPass):
                 )
 
         if isinstance(node.decl_link, uni.Ability) and isinstance(
-            node.target, uni.SubNodeList
+            node.target, Sequence
         ):
-            for arch in node.target.items:
+            for arch in node.target:
                 if arch.name_spec.name_of.sym:
                     arch.name_spec.name_of.sym.add_use(arch.name_spec)
 
@@ -107,11 +108,11 @@ class PyJacAstLinkPass(UniPass):
             self.link_jac_py_nodes(jac_node=node.alias, py_nodes=node.gen.py_ast)
 
     def exit_global_stmt(self, node: uni.GlobalStmt) -> None:
-        for x, y in enumerate(node.target.items):
+        for x, y in enumerate(node.target):
             self.link_jac_py_nodes(jac_node=y, py_nodes=[node.gen.py_ast[x]])
 
     def exit_non_local_stmt(self, node: uni.NonLocalStmt) -> None:
-        for x, y in enumerate(node.target.items):
+        for x, y in enumerate(node.target):
             self.link_jac_py_nodes(jac_node=y, py_nodes=[node.gen.py_ast[x]])
 
     def exit_k_w_pair(self, node: uni.KWPair) -> None:

jaclang/compiler/passes/main/sym_tab_build_pass.py

@@ -54,7 +54,7 @@ class SymTabBuildPass(UniPass):
 
     def exit_global_vars(self, node: uni.GlobalVars) -> None:
         for i in self.get_all_sub_nodes(node, uni.Assignment):
-            for j in i.target.items:
+            for j in i.target:
                 if isinstance(j, uni.AstSymbolNode):
                     j.sym_tab.def_insert(j, access_spec=node, single_decl="global var")
                 else:
@@ -75,12 +75,12 @@ class SymTabBuildPass(UniPass):
     def exit_module_path(self, node: uni.ModulePath) -> None:
         if node.alias:
             node.alias.sym_tab.def_insert(node.alias, single_decl="import")
-        elif node.path and isinstance(node.path.items[0], uni.Name):
+        elif node.path and isinstance(node.path[0], uni.Name):
             if node.parent_of_type(uni.Import) and not (
                 node.parent_of_type(uni.Import).from_loc
                 and node.parent_of_type(uni.Import).is_jac
             ):
-                node.path.items[0].sym_tab.def_insert(node.path.items[0])
+                node.path[0].sym_tab.def_insert(node.path[0])
         else:
             pass  # Need to support pythonic import symbols with dots in it
 

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:
@@ -97,15 +94,15 @@ class SymTabLinkPass(Transform[uni.Module, uni.Module]):
 
     def _is_all_import(self, imp_node: uni.Import, node: uni.ModulePath) -> bool:
         """Determine if this is an all import (import everything from module)."""
-        return (
-            imp_node.is_jac and node.parent and isinstance(node.parent, uni.SubNodeList)
-        ) or (imp_node.is_py and imp_node.from_loc is None and not imp_node.is_absorb)
+        return (imp_node.is_jac and node in imp_node.items) or (
+            imp_node.is_py and imp_node.from_loc is None and not imp_node.is_absorb
+        )
 
     def _get_imported_symbols(self, node: uni.ModulePath) -> list[str]:
         """Get list of specific symbols being imported."""
         symbols = []
         if node.parent and isinstance(node.parent, uni.Import):
-            for mod_items in node.parent.items.items:
+            for mod_items in node.parent.items:
                 if isinstance(mod_items, uni.ModuleItem):
                     symbols.append(mod_items.name.value)
         return symbols

jaclang/compiler/passes/main/tests/fixtures/symtab_link_tests/action/actions.jac

@@ -1,5 +1,3 @@
-
-
 node LLM{
 
     can infer with AgentNode entry{
@@ -9,15 +7,13 @@ node LLM{
     def testing_infer {
         return "LLM's response";
     }
-
 }
 
 
-obj AgentNode{
+walker Agent{
     has describ :str = "AgentNode";
 
     can connect with LLM entry{
         return "AgentNode's response";
-
     }
 }

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

@@ -1,14 +1,7 @@
-
-
-
 import from action {actions}
 
-
 with entry{
-
         openai = actions.LLM();
-        agent = actions.AgentNode();
+        agent = actions.Agent();
         print("openai: response: ", openai.testing_infer());
-
-
 }

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

@@ -1,8 +1,8 @@
 """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
 
 
 class TestCFGBuildPass(TestCase):
@@ -21,16 +21,14 @@ 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,
             prog=prog,
         )
 
-        dot = cfg_pass.dotgen_cfg()
+        dot = cfg_pass.printgraph_cfg()
 
         expected_dot = (
             "digraph G {\n"
@@ -69,16 +67,14 @@ 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,
             prog=prog,
         )
 
-        dot = cfg_pass.dotgen_cfg()
+        dot = cfg_pass.printgraph_cfg()
 
         expected_dot = (
             "digraph G {\n"

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, [])