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

jaclang/tests/test_language.py

@@ -4,15 +4,13 @@ import io
 import os
 import sys
 import sysconfig
+import tempfile
+from unittest.mock import patch
 
-
-import jaclang.compiler.passes.main as passes
-from jaclang import jac_import
+from jaclang import JacMachineInterface as Jac, JacMachine
 from jaclang.cli import cli
-from jaclang.compiler.compile import jac_file_to_pass, jac_pass_to_pass, jac_str_to_pass
-from jaclang.compiler.passes.main.schedules import py_code_gen_typed
-from jaclang.runtimelib.context import ExecutionContext
-from jaclang.runtimelib.machine import JacMachine, JacProgram
+from jaclang.compiler.passes.main import CompilerMode as CMode
+from jaclang.compiler.program import JacProgram
 from jaclang.utils.test import TestCase
 
 
@@ -21,15 +19,15 @@ class JacLanguageTests(TestCase):
 
     def setUp(self) -> None:
         """Set up test."""
-        ExecutionContext.global_system_root().edges.clear()
-        JacMachine(self.fixture_abs_path("./")).attach_program(
-            JacProgram(mod_bundle=None, bytecode=None, sem_ir=None)
+        self.mach = JacMachine(self.fixture_abs_path("./"))
+        Jac.attach_program(
+            self.mach,
+            JacProgram(),
         )
         return super().setUp()
 
     def tearDown(self) -> None:
         """Tear down test."""
-        JacMachine.detach()
         return super().tearDown()
 
     def test_sub_abilities(self) -> None:
@@ -70,7 +68,12 @@ class JacLanguageTests(TestCase):
         """Parse micro jac file."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("micro.simple_walk", base_path=self.examples_abs_path(""))
+        Jac.jac_import(
+            self.mach,
+            "micro.simple_walk",
+            base_path=self.examples_abs_path(""),
+            override_name="__main__",
+        )
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(
@@ -83,7 +86,9 @@ class JacLanguageTests(TestCase):
         """Parse micro jac file."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("micro.simple_walk_by_edge", base_path=self.examples_abs_path(""))
+        Jac.jac_import(
+            self.mach, "micro.simple_walk_by_edge", base_path=self.examples_abs_path("")
+        )
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(
@@ -95,7 +100,7 @@ class JacLanguageTests(TestCase):
         """Parse micro jac file."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("guess_game", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(self.mach, "guess_game", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(
@@ -103,44 +108,33 @@ class JacLanguageTests(TestCase):
             "Too high!\nToo low!\nToo high!\nCongratulations! You guessed correctly.\n",
         )
 
-    def test_multi_dim_arr_slice(self) -> None:
-        """Parse micro jac file."""
+    def test_dotgen(self) -> None:
+        """Test the dot gen of builtin function."""
+        import json
+
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        cli.tool(
-            "ir",
-            [
-                "ast",
-                self.fixture_abs_path("multi_dim_array_split.jac"),
-            ],
+        Jac.jac_import(
+            self.mach, "builtin_dotgen_json", base_path=self.fixture_abs_path("./")
         )
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
+        data = json.loads(stdout_value)
 
-        expected_outputs = [
-            "+-- AtomTrailer - Type: jaclang.JacList[builtins.int]",
-            "    +-- Name - arr - Type: jaclang.JacList[jaclang.JacList[builtins.int]],  SymbolTable: None",
-            "+-- IndexSlice - [IndexSlice] - Type: jaclang.JacList[jaclang.JacList[builtins.int]],  SymbolTable: None",
-            "        +-- Token - [, ",
-            "        +-- Int - 1 - Type: Literal[1]?,  SymbolTable: None",
-            "        +-- Token - :, ",
-            "        +-- Int - 3 - Type: Literal[3]?,  SymbolTable: None",
-            "        +-- Token - ,, ",
-            "        +-- Int - 1 - Type: Literal[1]?,  SymbolTable: None",
-            "        +-- Token - :, ",
-            "        +-- Token - :, ",
-            "        +-- Int - 2 - Type: Literal[2]?,  SymbolTable: None",
-            "        +-- Token - ], ",
-        ]
+        nodes = data["nodes"]
+        self.assertEqual(len(nodes), 7)
+        for node in nodes:
+            label = node["label"]
+            self.assertIn(label, ["root", "N(val=0)", "N(val=1)"])
 
-        for expected in expected_outputs:
-            self.assertIn(expected, stdout_value)
+        edges = data["edges"]
+        self.assertEqual(len(edges), 6)
 
     def test_chandra_bugs(self) -> None:
         """Parse micro jac file."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("chandra_bugs", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(self.mach, "chandra_bugs", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(
@@ -152,7 +146,9 @@ class JacLanguageTests(TestCase):
         """Parse micro jac file."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("chandra_bugs2", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(
+            self.mach, "chandra_bugs2", base_path=self.fixture_abs_path("./")
+        )
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(
@@ -167,7 +163,7 @@ class JacLanguageTests(TestCase):
         """Parse micro jac file."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("ignore_dup", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(self.mach, "ignore_dup", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(stdout_value.split("\n")[0].count("here"), 10)
@@ -177,17 +173,19 @@ class JacLanguageTests(TestCase):
         """Parse micro jac file."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("hashcheck_dup", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(
+            self.mach, "hashcheck_dup", base_path=self.fixture_abs_path("./")
+        )
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(stdout_value.count("check"), 2)
 
     def test_arith_precedence(self) -> None:
         """Basic precedence test."""
-        prog = jac_str_to_pass("with entry {print(4-5-4);}", "test.jac")
+        prog = JacProgram().compile_from_str("with entry {print(4-5-4);}", "test.jac")
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        exec(compile(prog.ir.gen.py_ast[0], "test.py", "exec"))
+        exec(compile(prog.gen.py_ast[0], "test.py", "exec"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(stdout_value, "-5\n")
@@ -196,7 +194,7 @@ class JacLanguageTests(TestCase):
         """Test importing python."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("needs_import", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(self.mach, "needs_import", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("<module 'pyfunc' from", stdout_value)
@@ -205,19 +203,22 @@ class JacLanguageTests(TestCase):
         """Testing filter comprehension."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import(
+        Jac.jac_import(
+            self.mach,
             "reference.special_comprehensions",
             base_path=self.examples_abs_path(""),
         )
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
-        self.assertIn("TestObj", stdout_value)
+        self.assertIn("True", stdout_value)
 
     def test_gen_dot_bubble(self) -> None:
         """Test the dot gen of nodes and edges of bubblesort."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("gendot_bubble_sort", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(
+            self.mach, "gendot_bubble_sort", base_path=self.fixture_abs_path("./")
+        )
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn(
@@ -225,11 +226,13 @@ class JacLanguageTests(TestCase):
             stdout_value,
         )
 
-    def test_assign_compr(self) -> None:
+    def test_assign_operation(self) -> None:
         """Test assign_compr."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("assign_compr_dup", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(
+            self.mach, "assign_compr_dup", base_path=self.fixture_abs_path("./")
+        )
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(
@@ -237,22 +240,13 @@ class JacLanguageTests(TestCase):
             stdout_value,
         )
 
-    def test_semstr(self) -> None:
-        """Test semstring."""
-        captured_output = io.StringIO()
-        sys.stdout = captured_output
-        sys.stderr = captured_output
-        jac_import("semstr", base_path=self.fixture_abs_path("./"))
-        sys.stdout = sys.__stdout__
-        sys.stderr = sys.__stderr__
-        stdout_value = captured_output.getvalue()
-        self.assertNotIn("Error", stdout_value)
-
     def test_raw_bytestr(self) -> None:
         """Test raw string and byte string."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("raw_byte_string", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(
+            self.mach, "raw_byte_string", base_path=self.fixture_abs_path("./")
+        )
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(stdout_value.count(r"\\\\"), 2)
@@ -262,7 +256,8 @@ class JacLanguageTests(TestCase):
         """Test fstring with multiple quotation."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import(
+        Jac.jac_import(
+            self.mach,
             "compiler/passes/main/tests/fixtures/fstrings",
             base_path=self.fixture_abs_path("../../"),
         )
@@ -278,11 +273,35 @@ class JacLanguageTests(TestCase):
         captured_output = io.StringIO()
         sys.stdout = captured_output
 
-        jac_import("deep_import", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(self.mach, "deep_import", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
+        print(self.mach.loaded_modules.keys())
         self.assertEqual(stdout_value.split("\n")[0], "one level deeperslHello World!")
 
+    def test_deep_imports_interp_mode(self) -> None:
+        """Parse micro jac file."""
+        mach = JacMachine(self.fixture_abs_path("./"), interp_mode=True)
+        Jac.attach_program(
+            mach,
+            JacProgram(),
+        )
+        Jac.jac_import(
+            mach, "deep_import_interp", base_path=self.fixture_abs_path("./")
+        )
+        print(mach.jac_program.mod.hub.keys())
+        self.assertEqual(len(mach.jac_program.mod.hub.keys()), 1)
+        mach = JacMachine(self.fixture_abs_path("./"), interp_mode=False)
+        Jac.attach_program(
+            mach,
+            JacProgram(),
+        )
+        Jac.jac_import(
+            mach, "deep_import_interp", base_path=self.fixture_abs_path("./")
+        )
+        print(mach.jac_program.mod.hub.keys())
+        self.assertEqual(len(mach.jac_program.mod.hub.keys()), 5)
+
     def test_deep_imports_mods(self) -> None:
         """Parse micro jac file."""
         targets = [
@@ -295,8 +314,10 @@ class JacLanguageTests(TestCase):
         for i in targets:
             if i in sys.modules:
                 del sys.modules[i]
-        jac_import("deep_import_mods", base_path=self.fixture_abs_path("./"))
-        mods = JacMachine.get().loaded_modules.keys()
+        Jac.jac_import(
+            self.mach, "deep_import_mods", base_path=self.fixture_abs_path("./")
+        )
+        mods = self.mach.loaded_modules.keys()
         for i in targets:
             self.assertIn(i, mods)
         self.assertEqual(len([i for i in mods if i.startswith("deep")]), 6)
@@ -305,8 +326,10 @@ class JacLanguageTests(TestCase):
         """Parse micro jac file."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import(
-            "deep.deeper.deep_outer_import", base_path=self.fixture_abs_path("./")
+        Jac.jac_import(
+            self.mach,
+            "deep.deeper.deep_outer_import",
+            base_path=self.fixture_abs_path("./"),
         )
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
@@ -324,23 +347,11 @@ class JacLanguageTests(TestCase):
         self.assertIn("one level deeperslHello World!", stdout_value)
         self.assertIn("module 'pyfunc' from ", stdout_value)
 
-    # def test_second_deep_outer_imports(self) -> None:
-    #     """Parse micro jac file."""
-    #     captured_output = io.StringIO()
-    #     sys.stdout = captured_output
-    #     jac_import(
-    #         "deep.deeper.deep_outer_import2", base_path=self.fixture_abs_path("./")
-    #     )
-    #     sys.stdout = sys.__stdout__
-    #     stdout_value = captured_output.getvalue()
-    #     self.assertIn("one level deeperslHello World!", stdout_value)
-    #     self.assertIn("module 'pyfunc' from ", stdout_value)
-
     def test_has_lambda_goodness(self) -> None:
         """Test has lambda_goodness."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("has_goodness", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(self.mach, "has_goodness", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(stdout_value.split("\n")[0], "mylist:  [1, 2, 3]")
@@ -350,7 +361,7 @@ class JacLanguageTests(TestCase):
         """Test conn assign on edges."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("edge_ops", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(self.mach, "edge_ops", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("[(3, 5), (14, 1), (5, 1)]", stdout_value)
@@ -361,7 +372,7 @@ class JacLanguageTests(TestCase):
         """Test conn assign on edges."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("disconn", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(self.mach, "disconn", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue().split("\n")
         self.assertIn("c(cc=0)", stdout_value[0])
@@ -378,7 +389,7 @@ class JacLanguageTests(TestCase):
         """Test conn assign on edges."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("simple_archs", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(self.mach, "simple_archs", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(stdout_value.split("\n")[0], "1 2 0")
@@ -388,7 +399,7 @@ class JacLanguageTests(TestCase):
         """Test walking through edges."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("edges_walk", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(self.mach, "edges_walk", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("creator()\n", stdout_value)
@@ -397,20 +408,11 @@ class JacLanguageTests(TestCase):
         self.assertIn("node_a(val=2)", stdout_value)
         self.assertIn("[node_a(val=42), node_a(val=42)]\n", stdout_value)
 
-    def test_impl_grab(self) -> None:
-        """Test walking through edges."""
-        captured_output = io.StringIO()
-        sys.stdout = captured_output
-        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)
-
     def test_tuple_of_tuple_assign(self) -> None:
         """Test walking through edges."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("tuplytuples", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(self.mach, "tuplytuples", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn(
@@ -422,7 +424,9 @@ class JacLanguageTests(TestCase):
         """Test walking through edges."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("deferred_field", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(
+            self.mach, "deferred_field", base_path=self.fixture_abs_path("./")
+        )
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn(
@@ -434,7 +438,9 @@ class JacLanguageTests(TestCase):
         """Test the dot gen of nodes and edges as a builtin."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("builtin_dotgen", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(
+            self.mach, "builtin_dotgen", base_path=self.fixture_abs_path("./")
+        )
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(stdout_value.count("True"), 16)
@@ -443,7 +449,7 @@ class JacLanguageTests(TestCase):
         """Test walking through edges."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("with_context", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(self.mach, "with_context", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("im in", stdout_value)
@@ -458,7 +464,9 @@ class JacLanguageTests(TestCase):
         """Parse micro jac file."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("micro.typed_filter_compr", base_path=self.examples_abs_path(""))
+        Jac.jac_import(
+            self.mach, "micro.typed_filter_compr", base_path=self.examples_abs_path("")
+        )
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn(
@@ -472,7 +480,9 @@ class JacLanguageTests(TestCase):
         """Test walking through edges and nodes."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("edge_node_walk", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(
+            self.mach, "edge_node_walk", base_path=self.fixture_abs_path("./")
+        )
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("creator()\n", stdout_value)
@@ -483,225 +493,116 @@ class JacLanguageTests(TestCase):
 
     def test_annotation_tuple_issue(self) -> None:
         """Test conn assign on edges."""
-        mypass = jac_file_to_pass(self.fixture_abs_path("./slice_vals.jac"))
-        self.assertIn("Annotated[Str, INT, BLAH]", mypass.ir.gen.py)
-        self.assertIn("tuple[int, Optional[type], Optional[tuple]]", mypass.ir.gen.py)
-
-    def test_impl_decl_resolution_fix(self) -> None:
-        """Test walking through edges and nodes."""
-        captured_output = io.StringIO()
-        sys.stdout = captured_output
-        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)
-
-    def test_registry(self) -> None:
-        """Test Jac registry feature."""
-        captured_output = io.StringIO()
-        sys.stdout = captured_output
-        sys.stderr = captured_output
-        jac_import("registry", base_path=self.fixture_abs_path("./"))
-        sys.stdout = sys.__stdout__
-        sys.stderr = sys.__stderr__
-        stdout_value = captured_output.getvalue()
-        self.assertNotIn("Error", stdout_value)
-
-        output_lines = stdout_value.strip().split("\n")
-        outputs = [
-            int(output_lines[i]) if i != 2 else output_lines[i] for i in range(4)
-        ]
-
-        self.assertEqual(outputs[0], 9)
-        self.assertEqual(outputs[1], 2)
-        self.assertEqual(outputs[2], "Person")
-        self.assertEqual(outputs[3], 2)
+        mypass = JacProgram().compile(self.fixture_abs_path("./slice_vals.jac"))
+        self.assertIn("Annotated[Str, INT, BLAH]", mypass.gen.py)
+        self.assertIn("tuple[int, Optional[type], Optional[tuple]]", mypass.gen.py)
 
     def test_enum_inside_arch(self) -> None:
         """Test Enum as member stmt."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("enum_inside_archtype", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(
+            self.mach, "enum_inside_archtype", base_path=self.fixture_abs_path("./")
+        )
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("2 Accessing privileged Data", stdout_value)
 
-    def test_needs_import_1(self) -> None:
-        """Test py ast to Jac ast conversion output."""
-        file_name = self.fixture_abs_path("pyfunc_1.py")
-
-        from jaclang.compiler.passes.main.schedules import py_code_gen_typed
-        from jaclang.compiler.passes.main.pyast_load_pass import PyastBuildPass
-        import ast as py_ast
-        import jaclang.compiler.absyntree as ast
-
-        with open(file_name, "r") as f:
-            file_source = f.read()
-            parsed_ast = py_ast.parse(file_source)
-            try:
-                py_ast_build_pass = PyastBuildPass(
-                    input_ir=ast.PythonModuleAst(
-                        parsed_ast, orig_src=ast.JacSource(file_source, file_name)
-                    ),
-                )
-            except Exception as e:
-                return f"Error While Jac to Py AST conversion: {e}"
-
-        ir = jac_pass_to_pass(py_ast_build_pass, schedule=py_code_gen_typed).ir
-        self.assertEqual(len(ir.get_all_sub_nodes(ast.Architype)), 21)
-        captured_output = io.StringIO()
-        sys.stdout = captured_output
-        jac_import("needs_import_1", base_path=self.fixture_abs_path("./"))
-        sys.stdout = sys.__stdout__
-        stdout_value = captured_output.getvalue()
-        self.assertIn("pyfunc_1 imported", stdout_value)
-
     def test_pyfunc_1(self) -> None:
         """Test py ast to Jac ast conversion."""
         from jaclang.compiler.passes.main import PyastBuildPass
-        import jaclang.compiler.absyntree as ast
+        import jaclang.compiler.unitree as uni
         import ast as py_ast
 
         py_out_path = os.path.join(self.fixture_abs_path("./"), "pyfunc_1.py")
         with open(py_out_path) as f:
             file_source = f.read()
             output = PyastBuildPass(
-                input_ir=ast.PythonModuleAst(
+                ir_in=uni.PythonModuleAst(
                     py_ast.parse(file_source),
-                    orig_src=ast.JacSource(file_source, py_out_path),
+                    orig_src=uni.Source(file_source, py_out_path),
                 ),
-            ).ir.unparse()
-        # print(output)
-        self.assertIn("can greet2(**kwargs: Any)", output)
-        self.assertEqual(output.count("with entry {"), 13)
+                prog=JacProgram(),
+            ).ir_out.unparse()
+        print(output)
+        self.assertIn("def greet2(**kwargs: Any)", output)
+        self.assertEqual(output.count("with entry {"), 14)
+        self.assertIn("assert (x == 5) , 'x should be equal to 5' ;", output)
+        self.assertIn("if not (x == y) {", output)
+        self.assertIn("def greet2(**kwargs: Any) {", output)
+        self.assertIn("squares_dict = { x : (x ** 2) for x in numbers };", output)
         self.assertIn(
-            '"""Enum for shape types"""\nenum ShapeType{ CIRCLE = \'Circle\',\n',
-            output,
-        )
-        self.assertIn("\nUNKNOWN = 'Unknown',\n::py::\nprint('hello')\n::", output)
-        self.assertIn("assert x == 5 , 'x should be equal to 5' ;", output)
-        self.assertIn("if not x == y {", output)
-        self.assertIn("can greet2(**kwargs: Any) {", output)
-        self.assertIn("squares_dict = {x: (x ** 2)  for x in numbers};", output)
-        self.assertIn(
-            '\n\n@ my_decorator \n can say_hello() {\n\n    """Say hello""" ;', output
+            '\n\n"""Say hello"""\n@ my_decorator\n\n def say_hello() {', output
         )
 
-    def test_needs_import_2(self) -> None:
-        """Test py ast to Jac ast conversion output."""
-        file_name = self.fixture_abs_path("pyfunc_2.py")
-
-        from jaclang.compiler.passes.main.schedules import py_code_gen_typed
-        from jaclang.compiler.passes.main.pyast_load_pass import PyastBuildPass
-        import ast as py_ast
-        import jaclang.compiler.absyntree as ast
-
-        with open(file_name, "r") as f:
-            file_source = f.read()
-            parsed_ast = py_ast.parse(file_source)
-            try:
-                py_ast_build_pass = PyastBuildPass(
-                    input_ir=ast.PythonModuleAst(
-                        parsed_ast,
-                        orig_src=ast.JacSource(file_source, file_name),
-                    ),
-                )
-            except Exception as e:
-                return f"Error While Jac to Py AST conversion: {e}"
-
-        ir = jac_pass_to_pass(py_ast_build_pass, schedule=py_code_gen_typed).ir
-        self.assertEqual(
-            len(ir.get_all_sub_nodes(ast.Architype)), 27
-        )  # Because of the Architype from math
-        captured_output = io.StringIO()
-        sys.stdout = captured_output
-        jac_import("needs_import_2", base_path=self.fixture_abs_path("./"))
-        sys.stdout = sys.__stdout__
-        stdout_value = captured_output.getvalue()
-        self.assertIn("pyfunc_2 imported", stdout_value)
-        self.assertEqual(stdout_value.count("<class 'bytes'>"), 3)
-
     def test_pyfunc_2(self) -> None:
         """Test py ast to Jac ast conversion."""
         from jaclang.compiler.passes.main import PyastBuildPass
-        import jaclang.compiler.absyntree as ast
+        import jaclang.compiler.unitree as uni
         import ast as py_ast
 
         py_out_path = os.path.join(self.fixture_abs_path("./"), "pyfunc_2.py")
         with open(py_out_path) as f:
             file_source = f.read()
             output = PyastBuildPass(
-                input_ir=ast.PythonModuleAst(
+                ir_in=uni.PythonModuleAst(
                     py_ast.parse(file_source),
-                    orig_src=ast.JacSource(file_source, py_out_path),
+                    orig_src=uni.Source(file_source, py_out_path),
                 ),
-            ).ir.unparse()
-        self.assertIn("class X {\n    with entry {\n\n        a_b = 67;", output)
+                prog=JacProgram(),
+            ).ir_out.unparse()
+        self.assertIn("class X {\n    with entry {\n        a_b = 67;", output)
         self.assertIn("br = b'Hello\\\\\\\\nWorld'", output)
-        self.assertIn("class Circle {\n    can init(radius: float", output)
-        self.assertIn("<>node = 90;    \n    print(<>node) ;\n}\n", output)
+        self.assertIn("class Circle {\n    def init(radius: float", output)
+        self.assertIn("<>node = 90;\n    \n\n    print(<>node);\n", output)
 
-    def test_needs_import_3(self) -> None:
-        """Test py ast to Jac ast conversion output."""
-        file_name = self.fixture_abs_path("pyfunc_3.py")
-
-        from jaclang.compiler.passes.main.schedules import py_code_gen_typed
-        from jaclang.compiler.passes.main.pyast_load_pass import PyastBuildPass
+    def test_pyfunc_3(self) -> None:
+        """Test py ast to Jac ast conversion."""
+        from jaclang.compiler.passes.main import PyastBuildPass
+        import jaclang.compiler.unitree as uni
         import ast as py_ast
-        import jaclang.compiler.absyntree as ast
 
-        with open(file_name, "r") as f:
+        py_out_path = os.path.join(self.fixture_abs_path("./"), "pyfunc_3.py")
+        with open(py_out_path) as f:
             file_source = f.read()
-            parsed_ast = py_ast.parse(file_source)
-            try:
-                py_ast_build_pass = PyastBuildPass(
-                    input_ir=ast.PythonModuleAst(
-                        parsed_ast,
-                        orig_src=ast.JacSource(file_source, file_name),
-                    ),
-                )
-            except Exception as e:
-                return f"Error While Jac to Py AST conversion: {e}"
-
-        ir = jac_pass_to_pass(py_ast_build_pass, schedule=py_code_gen_typed).ir
-        self.assertEqual(
-            len(ir.get_all_sub_nodes(ast.Architype)), 75
-        )  # Because of the Architype from other imports
-        captured_output = io.StringIO()
-        sys.stdout = captured_output
-        jac_import("needs_import_3", base_path=self.fixture_abs_path("./"))
-        sys.stdout = sys.__stdout__
-        stdout_value = captured_output.getvalue()
-        self.assertIn("pyfunc_3 imported", stdout_value)
+            output = PyastBuildPass(
+                ir_in=uni.PythonModuleAst(
+                    py_ast.parse(file_source),
+                    orig_src=uni.Source(file_source, py_out_path),
+                ),
+                prog=JacProgram(),
+            ).ir_out.unparse()
+        self.assertIn("if (0 <= x <= 5) {", output)
+        self.assertIn("  case _:\n", output)
+        self.assertIn(" case Point ( x = int ( a ), y = 0 ):\n", output)
+        self.assertIn("class Sample {\n    def init", output)
 
-    def test_pyfunc_3(self) -> None:
+    def test_py2jac(self) -> None:
         """Test py ast to Jac ast conversion."""
         from jaclang.compiler.passes.main import PyastBuildPass
-        import jaclang.compiler.absyntree as ast
+        import jaclang.compiler.unitree as ast
         import ast as py_ast
 
-        py_out_path = os.path.join(self.fixture_abs_path("./"), "pyfunc_3.py")
+        py_out_path = os.path.join(self.fixture_abs_path("./"), "py2jac.py")
         with open(py_out_path) as f:
             file_source = f.read()
             output = PyastBuildPass(
-                input_ir=ast.PythonModuleAst(
+                ir_in=ast.PythonModuleAst(
                     py_ast.parse(file_source),
-                    orig_src=ast.JacSource(file_source, py_out_path),
+                    orig_src=ast.Source(file_source, py_out_path),
                 ),
-            ).ir.unparse()
-        self.assertIn("if 0 <= x<= 5 {", output)
-        self.assertIn("  case _:\n", output)
-        self.assertIn(" case Point(x = int(_), y = 0):\n", output)
-        self.assertIn("class Sample {\n    can init", output)
+                prog=None,
+            ).ir_out.unparse()
+        self.assertIn("match Container(inner=Inner(x=a, y=b)) { \n", output)
+        self.assertIn("case Container ( inner = Inner ( x = a, y = 0 ) ):\n", output)
+        self.assertIn("case Container ( inner = Inner ( x = a, y = b ) ):\n", output)
+        self.assertIn("case _:\n", output)
 
     def test_refs_target(self) -> None:
-        """
-        This test added after a bug in jaclib Node.refs() wasn't code gen as expected and it
-        wasn't captured with the tests.
-        """
+        """Test py ast to Jac ast conversion output."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("refs_target", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(self.mach, "refs_target", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("[c(val=0), c(val=1), c(val=2)]", stdout_value)
@@ -709,47 +610,28 @@ class JacLanguageTests(TestCase):
 
     def test_py_kw_as_name_disallowed(self) -> None:
         """Basic precedence test."""
-        prog = jac_str_to_pass("with entry {print.is.not.True(4-5-4);}", "test.jac")
+        (prog := JacProgram()).compile_from_str(
+            "with entry {print.is.not.True(4-5-4);}", "test.jac"
+        )
         self.assertIn("Python keyword is used as name", str(prog.errors_had[0].msg))
 
     def test_double_format_issue(self) -> None:
         """Basic precedence test."""
-        prog = jac_str_to_pass("with entry {print(hello);}", "test.jac")
-        prog.ir.unparse()
-        before = prog.ir.format()
-        prog.ir.format()
-        prog.ir.format()
-        after = prog.ir.format()
+        prog = JacProgram().compile_from_str("with entry {print(hello);}", "test.jac")
+        prog.unparse()
+        before = prog.format()
+        prog.format()
+        prog.format()
+        after = prog.format()
         self.assertEqual(before, after)
 
-    def test_type_fuse_expr(self) -> None:
-        """Basic test for pass."""
-        captured_output = io.StringIO()
-        sys.stdout = captured_output
-        cli.tool(
-            "ir",
-            [
-                "ast",
-                self.examples_abs_path("reference/collection_values.jac"),
-            ],
-        )
-
-        sys.stdout = sys.__stdout__
-        stdout_value = captured_output.getvalue()
-        self.assertIn(
-            "builtins.dict[builtins.int, builtins.int]",
-            stdout_value,
-        )
-        self.assertIn(
-            "typing.Generator[builtins.int, None, None]",
-            stdout_value,
-        )
-
     def test_inherit_check(self) -> None:
         """Test py ast to Jac ast conversion output."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("inherit_check", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(
+            self.mach, "inherit_check", base_path=self.fixture_abs_path("./")
+        )
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual("I am in b\nI am in b\nwww is also in b\n", stdout_value)
@@ -758,7 +640,7 @@ class JacLanguageTests(TestCase):
         """Test tuple unpack."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("tupleunpack", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(self.mach, "tupleunpack", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue().split("\n")
         self.assertIn("1", stdout_value[0])
@@ -768,7 +650,9 @@ class JacLanguageTests(TestCase):
         """Test trailing comma."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("trailing_comma", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(
+            self.mach, "trailing_comma", base_path=self.fixture_abs_path("./")
+        )
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("Code compiled and ran successfully!", stdout_value)
@@ -777,7 +661,7 @@ class JacLanguageTests(TestCase):
         """Test try finally."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("try_finally", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(self.mach, "try_finally", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue().split("\n")
         self.assertIn("try block", stdout_value[0])
@@ -790,7 +674,9 @@ class JacLanguageTests(TestCase):
         """Test arithmetic bug."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("arithmetic_bug", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(
+            self.mach, "arithmetic_bug", base_path=self.fixture_abs_path("./")
+        )
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue().split("\n")
         self.assertEqual("0.0625", stdout_value[0])
@@ -803,138 +689,28 @@ class JacLanguageTests(TestCase):
         """Test lambda expr."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("lambda", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(self.mach, "lambda", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue().split("\n")
         self.assertEqual("9", stdout_value[0])
         self.assertEqual("567", stdout_value[1])
 
-    def test_random_check(self) -> None:
-        """Test py ast to Jac ast conversion output."""
-        from jaclang.compiler.passes.main import PyastBuildPass
-        import jaclang.compiler.absyntree as ast
-        import ast as py_ast
-        from jaclang.settings import settings
-
-        module_paths = ["random", "ast"]
-        for module_path in module_paths:
-            stdlib_dir = sysconfig.get_paths()["stdlib"]
-            file_path = os.path.join(
-                stdlib_dir,
-                module_path + ".py",
-            )
-            with open(file_path) as f:
-                file_source = f.read()
-                jac_ast = PyastBuildPass(
-                    input_ir=ast.PythonModuleAst(
-                        py_ast.parse(file_source),
-                        orig_src=ast.JacSource(file_source, file_path),
-                    )
-                )
-            settings.print_py_raised_ast = True
-            ir = jac_pass_to_pass(jac_ast).ir
-            gen_ast = ir.pp()
-            if module_path == "random":
-                self.assertIn("ModulePath - statistics -", gen_ast)
-            else:
-                self.assertIn("+-- Name - NodeTransformer - Type: No", gen_ast)
-
-    def test_deep_py_load_imports(self) -> None:  # we can get rid of this, isn't?
-        """Test py ast to Jac ast conversion output."""
-        file_name = os.path.join(self.fixture_abs_path("./"), "random_check.jac")
-        from jaclang.compiler.passes.main.schedules import py_code_gen, PyImportPass
-
-        imp = jac_file_to_pass(file_name, schedule=py_code_gen, target=PyImportPass)
-        self.assertEqual(len(imp.import_table), 1)
-
-    def test_access_modifier(self) -> None:
-        """Test for access tags working."""
-        captured_output = io.StringIO()
-        sys.stdout = captured_output
-        sys.stderr = captured_output
-        cli.check(
-            self.fixture_abs_path("../../tests/fixtures/access_modifier.jac"),
-            print_errs=True,
-        )
-        sys.stdout = sys.__stdout__
-        sys.stderr = sys.__stderr__
-        stdout_value = captured_output.getvalue()
-        self.assertEqual(stdout_value.count("Invalid access"), 18)
-
-    def test_deep_convert(self) -> None:
-        """Test py ast to Jac ast conversion output."""
-        file_name = self.fixture_abs_path("pyfunc_1.py")
-
-        from jaclang.compiler.passes.main.schedules import py_code_gen_typed
-        from jaclang.compiler.passes.main.pyast_load_pass import PyastBuildPass
-        import ast as py_ast
-        import jaclang.compiler.absyntree as ast
-        from jaclang.settings import settings
-
-        with open(file_name, "r") as f:
-            parsed_ast = py_ast.parse(f.read())
-            try:
-                py_ast_build_pass = PyastBuildPass(
-                    input_ir=ast.PythonModuleAst(
-                        parsed_ast, orig_src=ast.JacSource(f.read(), file_name)
-                    )
-                )
-            except Exception as e:
-                raise Exception(f"Error While Jac to Py AST conversion: {e}")
-
-        settings.print_py_raised_ast = True
-        ir = jac_pass_to_pass(py_ast_build_pass, schedule=py_code_gen_typed).ir
-        jac_ast = ir.pp()
-        self.assertIn(" |   +-- String - 'Loop completed normally{}'", jac_ast)
-        self.assertEqual(len(ir.get_all_sub_nodes(ast.SubNodeList)), 586)
-        captured_output = io.StringIO()
-        sys.stdout = captured_output
-        jac_import("deep_convert", base_path=self.fixture_abs_path("./"))
-        sys.stdout = sys.__stdout__
-        stdout_value = captured_output.getvalue()
-        self.assertIn("Deep convo is imported", stdout_value)
-
     def test_override_walker_inherit(self) -> None:
         """Test py ast to Jac ast conversion output."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("walker_override", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(
+            self.mach, "walker_override", base_path=self.fixture_abs_path("./")
+        )
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual("baz\nbar\n", stdout_value)
 
-    def test_ds_type_check_pass(self) -> None:
-        """Test conn assign on edges."""
-        mypass = jac_file_to_pass(
-            self.examples_abs_path("micro/simple_walk.jac"),
-            schedule=py_code_gen_typed,
-        )
-        self.assertEqual(len(mypass.errors_had), 0)
-        self.assertEqual(len(mypass.warnings_had), 0)
-
-    def test_ds_type_check_pass2(self) -> None:
-        """Test conn assign on edges."""
-        mypass = jac_file_to_pass(
-            self.examples_abs_path("guess_game/guess_game5.jac"),
-            schedule=py_code_gen_typed,
-        )
-        self.assertEqual(len(mypass.errors_had), 0)
-        self.assertEqual(len(mypass.warnings_had), 0)
-
-    def test_circle_override1_type_check_pass(self) -> None:
-        """Test conn assign on edges."""
-        mypass = jac_file_to_pass(
-            self.examples_abs_path("manual_code/circle.jac"),
-            schedule=py_code_gen_typed,
-        )
-        self.assertEqual(len(mypass.errors_had), 0)
-        self.assertEqual(len(mypass.warnings_had), 0)
-
     def test_self_with_no_sig(self) -> None:  # we can get rid of this, isn't?
         """Test py ast to Jac ast conversion output."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("nosigself", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(self.mach, "nosigself", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(stdout_value.count("5"), 2)
@@ -943,45 +719,28 @@ class JacLanguageTests(TestCase):
         """Test py ast to Jac ast conversion output."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("hash_init_check", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(
+            self.mach, "hash_init_check", base_path=self.fixture_abs_path("./")
+        )
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("Test Passed", stdout_value)
 
     def test_multiline_single_tok(self) -> None:
         """Test conn assign on edges."""
-        mypass = jac_file_to_pass(self.fixture_abs_path("byllmissue.jac"))
-        self.assertIn("2:5 - 4:8", mypass.ir.pp())
-
-    def test_single_impl_annex(self) -> None:
-        """Basic test for pass."""
-        mypass = jac_file_to_pass(
-            self.examples_abs_path("manual_code/circle_pure.jac"),
-            target=passes.JacImportPass,
-        )
-
-        self.assertEqual(mypass.ir.pp().count("AbilityDef - (o)Circle.(c)area"), 1)
-        self.assertIsNone(mypass.ir._sym_tab)
-        mypass = jac_file_to_pass(
-            self.examples_abs_path("manual_code/circle_pure.jac"),
-            target=passes.SymTabBuildPass,
-        )
-        self.assertEqual(
-            len([i for i in mypass.ir.sym_tab.kid if i.name == "circle_pure.impl"]),
-            1,
-        )
+        mypass = JacProgram().compile(self.fixture_abs_path("byllmissue.jac"))
+        self.assertIn("2:5 - 4:8", mypass.pp())
 
     def test_inherit_baseclass_sym(self) -> None:
         """Basic test for symtable support for inheritance."""
-        mypass = jac_file_to_pass(
-            self.examples_abs_path("guess_game/guess_game4.jac"),
-            target=passes.DefUsePass,
+        mypass = JacProgram().compile(
+            self.examples_abs_path("guess_game/guess_game4.jac")
         )
         table = None
-        for i in mypass.ir.sym_tab.kid:
-            if i.name == "GuessTheNumberGame":
-                for j in i.kid:
-                    if j.name == "play":
+        for i in mypass.sym_tab.kid_scope:
+            if i.scope_name == "GuessTheNumberGame":
+                for j in i.kid_scope:
+                    if j.scope_name == "play":
                         table = j
                         break
                 break
@@ -992,7 +751,9 @@ class JacLanguageTests(TestCase):
         """Test importing python."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("edgetypeissue", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(
+            self.mach, "edgetypeissue", base_path=self.fixture_abs_path("./")
+        )
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("[x()]", stdout_value)
@@ -1001,7 +762,9 @@ class JacLanguageTests(TestCase):
         """Test importing python."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("blankwithentry", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(
+            self.mach, "blankwithentry", base_path=self.fixture_abs_path("./")
+        )
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("i work", stdout_value)
@@ -1010,7 +773,7 @@ class JacLanguageTests(TestCase):
         """Test importing python."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("dblhello", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(self.mach, "dblhello", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(stdout_value.count("Hello World!"), 1)
@@ -1020,7 +783,7 @@ class JacLanguageTests(TestCase):
         """Test class method output."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("cls_method", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(self.mach, "cls_method", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue().split("\n")
         self.assertEqual("MyClass", stdout_value[0])
@@ -1032,7 +795,7 @@ class JacLanguageTests(TestCase):
         captured_output = io.StringIO()
         sys.stdout = captured_output
 
-        jac_import("foo", base_path=self.fixture_abs_path("."))
+        Jac.jac_import(self.mach, "foo", base_path=self.fixture_abs_path("."))
 
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
@@ -1046,11 +809,11 @@ class JacLanguageTests(TestCase):
             stdout_value,
         )
         self.assertIn(
-            "Walkers in bar:\n  - Walker: Walker\n  - Walker: bar_walk",
+            "Walkers in bar:\n  - Walker: bar_walk",
             stdout_value,
         )
         self.assertIn("Nodes in bar:\n  - Node: Item", stdout_value)
-        self.assertIn("Edges in bar:\n  - Edge: Edge\n  - Edge: Link", stdout_value)
+        self.assertIn("Edges in bar:\n  - Edge: Link", stdout_value)
         self.assertIn("Item value: 0", stdout_value)
         self.assertIn("Created 5 items.", stdout_value)
 
@@ -1111,11 +874,11 @@ class JacLanguageTests(TestCase):
             with open(bar_file_path, "w") as bar_file:
                 bar_file.write(original_content)
 
-    def test_dynamic_spawn_architype(self) -> None:
+    def test_dynamic_spawn_archetype(self) -> None:
         """Test that the walker and node can be spawned and behaves as expected."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        cli.run(self.fixture_abs_path("dynamic_architype.jac"))
+        cli.run(self.fixture_abs_path("dynamic_archetype.jac"))
 
         output = captured_output.getvalue().strip()
         output_lines = output.split("\n")
@@ -1151,11 +914,11 @@ class JacLanguageTests(TestCase):
                 f"Expected '{val}' to appear 2 times, but found {len(occurrences)}.",
             )
 
-    def test_dynamic_architype_creation(self) -> None:
+    def test_dynamic_archetype_creation(self) -> None:
         """Test that the walker and node can be created dynamically."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        cli.run(self.fixture_abs_path("create_dynamic_architype.jac"))
+        cli.run(self.fixture_abs_path("create_dynamic_archetype.jac"))
 
         output = captured_output.getvalue().strip()
         # Expected outputs for spawned entities
@@ -1167,7 +930,7 @@ class JacLanguageTests(TestCase):
             f"Expected '{expected_spawned_walker}' in output.",
         )
 
-    def test_dynamic_architype_creation_rel_import(self) -> None:
+    def test_dynamic_archetype_creation_rel_import(self) -> None:
         """Test that the walker and node can be created dynamically, with relative import."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
@@ -1198,7 +961,9 @@ class JacLanguageTests(TestCase):
         """Test match case with multiple expressions."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("match_multi_ex", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(
+            self.mach, "match_multi_ex", base_path=self.fixture_abs_path("./")
+        )
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue().split("\n")
         self.assertEqual("Ten", stdout_value[0])
@@ -1208,7 +973,7 @@ class JacLanguageTests(TestCase):
         """Test entry and exit behavior of walker."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("entry_exit", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(self.mach, "entry_exit", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue().split("\n")
         self.assertIn("Entering at the beginning of walker:  Root()", stdout_value[0])
@@ -1221,7 +986,7 @@ class JacLanguageTests(TestCase):
         """Test entry and exit behavior of walker."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("visit_order", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(self.mach, "visit_order", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual("[MyNode(Name='End'), MyNode(Name='Middle')]\n", stdout_value)
@@ -1230,17 +995,21 @@ class JacLanguageTests(TestCase):
         """Test supporting multiple global variable in a statement."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("glob_multivar_statement", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(
+            self.mach, "glob_multivar_statement", base_path=self.fixture_abs_path("./")
+        )
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue().split("\n")
         self.assertIn("Hello World !", stdout_value[0])
         self.assertIn("Welcome to Jaseci!", stdout_value[1])
 
-    def test_architype_def(self) -> None:
-        """Test architype definition bug."""
+    def test_archetype_def(self) -> None:
+        """Test archetype definition bug."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("architype_def_bug", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(
+            self.mach, "archetype_def_bug", base_path=self.fixture_abs_path("./")
+        )
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue().split("\n")
         self.assertIn("MyWalker", stdout_value[0])
@@ -1250,7 +1019,9 @@ class JacLanguageTests(TestCase):
         """Test conn assign on edges."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("visit_sequence", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(
+            self.mach, "visit_sequence", base_path=self.fixture_abs_path("./")
+        )
         sys.stdout = sys.__stdout__
         self.assertEqual(
             "walker entry\nwalker enter to root\n"
@@ -1261,16 +1032,238 @@ class JacLanguageTests(TestCase):
             captured_output.getvalue(),
         )
 
-    def test_nested_impls(self) -> None:
+    def test_connect_traverse_syntax(self) -> None:
+        """Test connect traverse syntax."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        Jac.jac_import(
+            self.mach, "connect_traverse_syntax", base_path=self.fixture_abs_path("./")
+        )
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue().split("\n")
+        self.assertIn("A(val=5), A(val=10)", stdout_value[0])
+        self.assertIn("[Root(), A(val=20)]", stdout_value[1])
+        self.assertIn(
+            "A(val=5), A(val=10)", stdout_value[2]
+        )  # Remove after dropping deprecated syntax support
+        self.assertIn(
+            "[Root(), A(val=20)]", stdout_value[3]
+        )  # Remove after dropping deprecated syntax support
+
+    def test_node_del(self) -> None:
         """Test complex nested impls."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        jac_import("nested_impls", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import(self.mach, "node_del", base_path=self.fixture_abs_path("./"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue().split("\n")
+        self.assertIn("0 : [2, 3, 4, 5, 6, 7, 8, 9, 10]", stdout_value[0])
+        self.assertIn("7, 8 : [2, 3, 4, 5, 6, 7, 9]", stdout_value[1])
+        self.assertIn("before delete : Inner(c=[1, 2, 3], d=4)", stdout_value[2])
+        self.assertIn("after delete : Inner(c=[1, 3], d=4)", stdout_value[3])
+
+    # Helper method to create files within tests
+    def create_temp_jac_file(
+        self, content: str, dir_path: str, filename: str = "test_mod.jac"
+    ) -> str:
+        """Create a temporary Jac file in a specific directory."""
+        full_path = os.path.join(dir_path, filename)
+        os.makedirs(os.path.dirname(full_path), exist_ok=True)
+        with open(full_path, "w") as f:
+            f.write(content)
+        return full_path
+
+    def test_import_from_site_packages(self) -> None:
+        """Test importing a Jac module from simulated site-packages."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Simulate site-packages directory structure
+            mock_site_dir = os.path.join(tmpdir, "site-packages")
+            os.makedirs(mock_site_dir)
+
+            # Create a module within the simulated site-packages
+            site_mod_content = 'with entry { "Site package module loaded!" |> print; }'
+            self.create_temp_jac_file(
+                site_mod_content, mock_site_dir, "site_pkg_mod.jac"
+            )
+
+            # Create the importing script in the main temp directory
+            importer_content = "import site_pkg_mod;"
+            _ = self.create_temp_jac_file(importer_content, tmpdir, "importer_site.jac")
+            with patch("site.getsitepackages", return_value=[mock_site_dir]):
+                captured_output = io.StringIO()
+                sys.stdout = captured_output
+                original_cwd = os.getcwd()
+                try:
+                    Jac.jac_import(self.mach, "importer_site", base_path=tmpdir)
+                finally:
+                    os.chdir(original_cwd)
+                    sys.stdout = sys.__stdout__
+
+                stdout_value = captured_output.getvalue()
+                self.assertIn("Site package module loaded!", stdout_value)
+
+    def test_import_from_jacpath(self) -> None:
+        """Test importing a Jac module from JACPATH."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Simulate JACPATH directory
+            jacpath_dir = os.path.join(tmpdir, "jaclibs")
+            os.makedirs(jacpath_dir)
+
+            # Create a module in the JACPATH directory
+            jacpath_mod_content = 'with entry { "JACPATH module loaded!" |> print; }'
+            self.create_temp_jac_file(
+                jacpath_mod_content, jacpath_dir, "jacpath_mod.jac"
+            )
+
+            # Create the importing script in a different location
+            script_dir = os.path.join(tmpdir, "scripts")
+            os.makedirs(script_dir)
+            importer_content = "import jacpath_mod;"
+            _ = self.create_temp_jac_file(importer_content, script_dir, "importer.jac")
+
+            # Set JACPATH environment variable and run
+            original_jacpath = os.environ.get("JACPATH")
+            os.environ["JACPATH"] = jacpath_dir
+            captured_output = io.StringIO()
+            sys.stdout = captured_output
+            original_cwd = os.getcwd()
+            os.chdir(script_dir)
+            try:
+                cli.run("importer.jac")
+            finally:
+                os.chdir(original_cwd)
+                sys.stdout = sys.__stdout__
+                # Clean up environment variable
+                if original_jacpath is None:
+                    if "JACPATH" in os.environ:
+                        del os.environ["JACPATH"]
+                else:
+                    os.environ["JACPATH"] = original_jacpath
+
+            stdout_value = captured_output.getvalue()
+            self.assertIn("JACPATH module loaded!", stdout_value)
+
+    def test_obj_hasvar_initialization(self) -> None:
+        """Basic test for pass."""
+        (out := JacProgram()).compile(
+            self.fixture_abs_path("uninitialized_hasvars.jac")
+        )
+        self.assertTrue(out.errors_had)
+
+        expected_stdout_values = (
+            "Non default attribute 'var3' follows default attribute",
+            "    4 |     has var1: int;",
+            "    5 |     has var2: int = 42;",
+            "    6 |     has var3: int; # <-- This should be syntax error.",
+            "      |         ^^^^",
+            "    7 | }",
+            'Missing "postinit" method required by un initialized attribute(s).',
+            "   11 | obj Test2 {",
+            "   12 |     has var1: str;",
+            "   13 |     has var2: int by postinit;",
+            "      |         ^^^^",
+            "   14 | }",
+            "Non default attribute 'var4' follows default attribute",
+            "   19 |     has var2: int = 42;",
+            "   20 |     has var3: int by postinit;  # <-- This is fine.",
+            "   21 |     has var4: int;  # <-- This should be syntax error.",
+            "      |         ^^^^",
+            "   22 |",
+            "   23 |     def postinit() {",
+        )
+
+        errors_output = ""
+        for error in out.errors_had:
+            errors_output += error.pretty_print() + "\n"
+
+        for exp in expected_stdout_values:
+            self.assertIn(exp, errors_output)
+
+    def test_async_walker(self) -> None:
+        """Test async walker."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        Jac.jac_import(self.mach, "async_walker", base_path=self.fixture_abs_path("./"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue().split("\n")
+        self.assertNotIn("It is non blocking", stdout_value[4])
+        self.assertIn("W(num=8)", stdout_value[5])
+
+    def test_async_ability(self) -> None:
+        """Test async ability."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        Jac.jac_import(
+            self.mach, "async_ability", base_path=self.fixture_abs_path("./")
+        )
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue().split("\n")
+        self.assertIn("Hello", stdout_value[0])
+        self.assertIn("Hello", stdout_value[1])
+        self.assertIn("World!", stdout_value[2])
+
+    def test_concurrency(self) -> None:
+        """Test concurrency in jaclang."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        Jac.jac_import(self.mach, "concurrency", 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])
-        self.assertIn("Greeting: Hello, World!", stdout_value[1])
-        self.assertIn("Repeated: Hello", stdout_value[2])
-        self.assertIn("Hello, World!", stdout_value[3])
-        self.assertIn("Last message:!", stdout_value[4])
-        self.assertIn("Final message:!", stdout_value[5])
+        self.assertIn("Started", stdout_value[0])
+        self.assertIn("B(name='Hi')", stdout_value[8])
+        self.assertIn("11", stdout_value[9])
+        self.assertIn("13", stdout_value[10])
+
+    def test_import_jac_from_py(self) -> None:
+        """Parse micro jac file."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        from .fixtures import jac_from_py
+
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        self.assertEqual(
+            stdout_value,
+            "Value: -1\nValue: 0\nValue: 1\nValue: 2\nValue: 3\nValue: 4"
+            "\nValue: 5\nValue: 6\nValue: 7\nFinal Value: 8\nDone walking.\n",
+        )
+
+    def test_py_namedexpr(self) -> None:
+        """Ensure NamedExpr nodes are converted to AtomUnit."""
+        from jaclang.compiler.passes.main import PyastBuildPass
+        import jaclang.compiler.unitree as uni
+        import ast as py_ast
+
+        py_out_path = os.path.join(self.fixture_abs_path("./"), "py_namedexpr.py")
+        with open(py_out_path) as f:
+            file_source = f.read()
+            output = PyastBuildPass(
+                ir_in=uni.PythonModuleAst(
+                    py_ast.parse(file_source),
+                    orig_src=uni.Source(file_source, py_out_path),
+                ),
+                prog=JacProgram(),
+            ).ir_out.unparse()
+        self.assertIn("(x := 10)", output)
+
+    def test_py_bool_parentheses(self) -> None:
+        """Ensure boolean expressions preserve parentheses during conversion."""
+        from jaclang.compiler.passes.main import PyastBuildPass
+        import jaclang.compiler.unitree as uni
+        import ast as py_ast
+
+        py_out_path = os.path.join(self.fixture_abs_path("./"), "py_bool_expr.py")
+        with open(py_out_path) as f:
+            file_source = f.read()
+            output = PyastBuildPass(
+                ir_in=uni.PythonModuleAst(
+                    py_ast.parse(file_source),
+                    orig_src=uni.Source(file_source, py_out_path),
+                ),
+                prog=JacProgram(),
+            ).ir_out.unparse()
+        self.assertIn("(prev_token_index is None)", output)
+        self.assertIn("(next_token_index is None)", output)
+        self.assertIn("(tok[ 0 ] > change_end_line)", output)
+        self.assertIn("(tok[ 0 ] == change_end_line)", output)
+        self.assertIn("(tok[ 1 ] > change_end_char)", output)