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

jaclang/tests/test_language.py

@@ -5,11 +5,12 @@ import os
 import sys
 import sysconfig
 import tempfile
+import subprocess
+from pathlib import Path
 from unittest.mock import patch
 
-from jaclang import JacMachineInterface as Jac, JacMachine
+from jaclang import JacMachine as Jac
 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
 
@@ -19,15 +20,16 @@ class JacLanguageTests(TestCase):
 
     def setUp(self) -> None:
         """Set up test."""
-        self.mach = JacMachine(self.fixture_abs_path("./"))
+        Jac.reset_machine()
+        Jac.set_base_path(self.fixture_abs_path("./"))
         Jac.attach_program(
-            self.mach,
             JacProgram(),
         )
         return super().setUp()
 
     def tearDown(self) -> None:
         """Tear down test."""
+        Jac.reset_machine()
         return super().tearDown()
 
     def test_sub_abilities(self) -> None:
@@ -69,7 +71,6 @@ class JacLanguageTests(TestCase):
         captured_output = io.StringIO()
         sys.stdout = captured_output
         Jac.jac_import(
-            self.mach,
             "micro.simple_walk",
             base_path=self.examples_abs_path(""),
             override_name="__main__",
@@ -87,7 +88,7 @@ class JacLanguageTests(TestCase):
         captured_output = io.StringIO()
         sys.stdout = captured_output
         Jac.jac_import(
-            self.mach, "micro.simple_walk_by_edge", base_path=self.examples_abs_path("")
+            "micro.simple_walk_by_edge", base_path=self.examples_abs_path("")
         )
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
@@ -100,7 +101,7 @@ class JacLanguageTests(TestCase):
         """Parse micro jac file."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "guess_game", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("guess_game", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(
@@ -108,15 +109,13 @@ class JacLanguageTests(TestCase):
             "Too high!\nToo low!\nToo high!\nCongratulations! You guessed correctly.\n",
         )
 
-    def test_dotgen(self) -> None:
+    def test_printgraph(self) -> None:
         """Test the dot gen of builtin function."""
         import json
 
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "builtin_dotgen_json", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("builtin_printgraph_json", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         data = json.loads(stdout_value)
@@ -130,11 +129,23 @@ class JacLanguageTests(TestCase):
         edges = data["edges"]
         self.assertEqual(len(edges), 6)
 
+    def test_printgraph_mermaid(self) -> None:
+        """Test the mermaid gen of builtin function."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        Jac.jac_import(
+            "builtin_printgraph_mermaid",
+            base_path=self.fixture_abs_path("./"),
+        )
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        self.assertIn("flowchart LR", stdout_value)
+
     def test_chandra_bugs(self) -> None:
         """Parse micro jac file."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "chandra_bugs", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("chandra_bugs", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(
@@ -146,16 +157,14 @@ class JacLanguageTests(TestCase):
         """Parse micro jac file."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "chandra_bugs2", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("chandra_bugs2", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(
             stdout_value,
             "{'apple': None, 'pineapple': None}\n"
             "This is a long\n"
-            "    line of code.\n"
+            "        line of code.\n"
             "{'a': 'apple', 'b': 'ball', 'c': 'cat', 'd': 'dog', 'e': 'elephant'}\n",
         )
 
@@ -163,7 +172,7 @@ class JacLanguageTests(TestCase):
         """Parse micro jac file."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "ignore_dup", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("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)
@@ -173,16 +182,16 @@ class JacLanguageTests(TestCase):
         """Parse micro jac file."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "hashcheck_dup", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("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 = JacProgram().compile_from_str("with entry {print(4-5-4);}", "test.jac")
+        prog = JacProgram().compile(
+            use_str="with entry {print(4-5-4);}", file_path="test.jac"
+        )
         captured_output = io.StringIO()
         sys.stdout = captured_output
         exec(compile(prog.gen.py_ast[0], "test.py", "exec"))
@@ -194,7 +203,7 @@ class JacLanguageTests(TestCase):
         """Test importing python."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "needs_import", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("needs_import", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("<module 'pyfunc' from", stdout_value)
@@ -204,7 +213,6 @@ class JacLanguageTests(TestCase):
         captured_output = io.StringIO()
         sys.stdout = captured_output
         Jac.jac_import(
-            self.mach,
             "reference.special_comprehensions",
             base_path=self.examples_abs_path(""),
         )
@@ -216,9 +224,7 @@ class JacLanguageTests(TestCase):
         """Test the dot gen of nodes and edges of bubblesort."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "gendot_bubble_sort", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("gendot_bubble_sort", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn(
@@ -230,9 +236,7 @@ class JacLanguageTests(TestCase):
         """Test assign_compr."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "assign_compr_dup", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("assign_compr_dup", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(
@@ -244,9 +248,7 @@ class JacLanguageTests(TestCase):
         """Test raw string and byte string."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "raw_byte_string", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("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)
@@ -257,7 +259,6 @@ class JacLanguageTests(TestCase):
         captured_output = io.StringIO()
         sys.stdout = captured_output
         Jac.jac_import(
-            self.mach,
             "compiler/passes/main/tests/fixtures/fstrings",
             base_path=self.fixture_abs_path("../../"),
         )
@@ -273,37 +274,30 @@ class JacLanguageTests(TestCase):
         captured_output = io.StringIO()
         sys.stdout = captured_output
 
-        Jac.jac_import(self.mach, "deep_import", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("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.set_base_path(self.fixture_abs_path("./"))
         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.jac_import("deep_import_interp", base_path=self.fixture_abs_path("./"))
+        self.assertEqual(len(Jac.program.mod.hub.keys()), 1)
+        Jac.set_base_path(self.fixture_abs_path("./"))
         Jac.attach_program(
-            mach,
-            JacProgram(),
+            (prog := 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)
+        prog.build(self.fixture_abs_path("./deep_import_interp.jac"))
+        Jac.jac_import("deep_import_interp", base_path=self.fixture_abs_path("./"))
+        self.assertEqual(len(Jac.program.mod.hub.keys()), 5)
 
     def test_deep_imports_mods(self) -> None:
         """Parse micro jac file."""
+        Jac.reset_machine()
         targets = [
             "deep",
             "deep.deeper",
@@ -314,20 +308,19 @@ class JacLanguageTests(TestCase):
         for i in targets:
             if i in sys.modules:
                 del sys.modules[i]
-        Jac.jac_import(
-            self.mach, "deep_import_mods", base_path=self.fixture_abs_path("./")
-        )
-        mods = self.mach.loaded_modules.keys()
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        Jac.jac_import("deep_import_mods", base_path=self.fixture_abs_path("./"))
+        sys.stdout = sys.__stdout__
+        stdout_value = eval(captured_output.getvalue())
         for i in targets:
-            self.assertIn(i, mods)
-        self.assertEqual(len([i for i in mods if i.startswith("deep")]), 6)
+            self.assertIn(i, stdout_value)
 
     def test_deep_outer_imports_one(self) -> None:
         """Parse micro jac file."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
         Jac.jac_import(
-            self.mach,
             "deep.deeper.deep_outer_import",
             base_path=self.fixture_abs_path("./"),
         )
@@ -351,7 +344,7 @@ class JacLanguageTests(TestCase):
         """Test has lambda_goodness."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "has_goodness", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("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]")
@@ -361,7 +354,7 @@ class JacLanguageTests(TestCase):
         """Test conn assign on edges."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "edge_ops", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("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)
@@ -372,7 +365,7 @@ class JacLanguageTests(TestCase):
         """Test conn assign on edges."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "disconn", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("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])
@@ -389,7 +382,7 @@ class JacLanguageTests(TestCase):
         """Test conn assign on edges."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "simple_archs", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("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")
@@ -399,7 +392,7 @@ class JacLanguageTests(TestCase):
         """Test walking through edges."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "edges_walk", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("edges_walk", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("creator()\n", stdout_value)
@@ -412,7 +405,7 @@ class JacLanguageTests(TestCase):
         """Test walking through edges."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "tuplytuples", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("tuplytuples", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn(
@@ -424,9 +417,7 @@ class JacLanguageTests(TestCase):
         """Test walking through edges."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "deferred_field", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("deferred_field", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn(
@@ -438,9 +429,7 @@ class JacLanguageTests(TestCase):
         """Test the dot gen of nodes and edges as a builtin."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "builtin_dotgen", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("builtin_printgraph", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(stdout_value.count("True"), 16)
@@ -449,7 +438,7 @@ class JacLanguageTests(TestCase):
         """Test walking through edges."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "with_context", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("with_context", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("im in", stdout_value)
@@ -464,9 +453,7 @@ class JacLanguageTests(TestCase):
         """Parse micro jac file."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "micro.typed_filter_compr", base_path=self.examples_abs_path("")
-        )
+        Jac.jac_import("micro.typed_filter_compr", base_path=self.examples_abs_path(""))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn(
@@ -480,9 +467,7 @@ class JacLanguageTests(TestCase):
         """Test walking through edges and nodes."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "edge_node_walk", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("edge_node_walk", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("creator()\n", stdout_value)
@@ -501,9 +486,7 @@ class JacLanguageTests(TestCase):
         """Test Enum as member stmt."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "enum_inside_archtype", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("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)
@@ -524,7 +507,6 @@ class JacLanguageTests(TestCase):
                 ),
                 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)
@@ -553,8 +535,10 @@ class JacLanguageTests(TestCase):
             ).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    def init(radius: float", output)
-        self.assertIn("<>node = 90;\n    \n\n    print(<>node);\n", output)
+        self.assertIn(
+            "class Circle {\n    def init(self: Circle, radius: float", output
+        )
+        self.assertIn("<>node = 90;\n    print(<>node);\n", output)
 
     def test_pyfunc_3(self) -> None:
         """Test py ast to Jac ast conversion."""
@@ -574,7 +558,7 @@ class JacLanguageTests(TestCase):
             ).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(" case Point(x = int(a), y = 0):\n", output)
         self.assertIn("class Sample {\n    def init", output)
 
     def test_py2jac(self) -> None:
@@ -593,16 +577,16 @@ class JacLanguageTests(TestCase):
                 ),
                 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("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:
         """Test py ast to Jac ast conversion output."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "refs_target", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("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)
@@ -610,14 +594,14 @@ class JacLanguageTests(TestCase):
 
     def test_py_kw_as_name_disallowed(self) -> None:
         """Basic precedence test."""
-        (prog := JacProgram()).compile_from_str(
-            "with entry {print.is.not.True(4-5-4);}", "test.jac"
+        (prog := JacProgram()).compile(
+            use_str="with entry {print.is.not.True(4-5-4);}", file_path="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 = JacProgram().compile_from_str("with entry {print(hello);}", "test.jac")
+        prog = JacProgram().compile("with entry {print(hello);}", "test.jac")
         prog.unparse()
         before = prog.format()
         prog.format()
@@ -629,9 +613,7 @@ class JacLanguageTests(TestCase):
         """Test py ast to Jac ast conversion output."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "inherit_check", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("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)
@@ -640,7 +622,7 @@ class JacLanguageTests(TestCase):
         """Test tuple unpack."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "tupleunpack", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("tupleunpack", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue().split("\n")
         self.assertIn("1", stdout_value[0])
@@ -650,9 +632,7 @@ class JacLanguageTests(TestCase):
         """Test trailing comma."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "trailing_comma", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("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)
@@ -661,7 +641,7 @@ class JacLanguageTests(TestCase):
         """Test try finally."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "try_finally", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("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])
@@ -674,9 +654,7 @@ class JacLanguageTests(TestCase):
         """Test arithmetic bug."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "arithmetic_bug", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("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])
@@ -689,7 +667,7 @@ class JacLanguageTests(TestCase):
         """Test lambda expr."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "lambda", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("lambda", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue().split("\n")
         self.assertEqual("9", stdout_value[0])
@@ -699,9 +677,7 @@ class JacLanguageTests(TestCase):
         """Test py ast to Jac ast conversion output."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "walker_override", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("walker_override", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual("baz\nbar\n", stdout_value)
@@ -710,7 +686,7 @@ class JacLanguageTests(TestCase):
         """Test py ast to Jac ast conversion output."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "nosigself", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("nosigself", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(stdout_value.count("5"), 2)
@@ -719,9 +695,7 @@ class JacLanguageTests(TestCase):
         """Test py ast to Jac ast conversion output."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "hash_init_check", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("hash_init_check", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("Test Passed", stdout_value)
@@ -751,9 +725,7 @@ class JacLanguageTests(TestCase):
         """Test importing python."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "edgetypeissue", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("edgetypeissue", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("[x()]", stdout_value)
@@ -762,9 +734,7 @@ class JacLanguageTests(TestCase):
         """Test importing python."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "blankwithentry", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("blankwithentry", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("i work", stdout_value)
@@ -773,7 +743,7 @@ class JacLanguageTests(TestCase):
         """Test importing python."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "dblhello", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("dblhello", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(stdout_value.count("Hello World!"), 1)
@@ -783,7 +753,7 @@ class JacLanguageTests(TestCase):
         """Test class method output."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "cls_method", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("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])
@@ -792,10 +762,14 @@ class JacLanguageTests(TestCase):
 
     def test_list_methods(self) -> None:
         """Test list_modules, list_walkers, list_nodes, and list_edges."""
+        Jac.reset_machine()
+        Jac.set_base_path(self.fixture_abs_path("."))
+        sys.modules.pop("foo", None)
+        sys.modules.pop("bar", None)
         captured_output = io.StringIO()
         sys.stdout = captured_output
 
-        Jac.jac_import(self.mach, "foo", base_path=self.fixture_abs_path("."))
+        Jac.jac_import("foo", base_path=self.fixture_abs_path("."))
 
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
@@ -819,6 +793,9 @@ class JacLanguageTests(TestCase):
 
     def test_walker_dynamic_update(self) -> None:
         """Test dynamic update of a walker during runtime."""
+        Jac.reset_machine()
+        Jac.set_base_path(self.fixture_abs_path("."))
+        sys.modules.pop("bar", None)
         session = self.fixture_abs_path("bar_walk.session")
         bar_file_path = self.fixture_abs_path("bar.jac")
         update_file_path = self.fixture_abs_path("walker_update.jac")
@@ -832,6 +809,7 @@ class JacLanguageTests(TestCase):
         )
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
+        os.remove(session) if os.path.exists(session) else None
         expected_output = "Created 5 items."
         self.assertIn(expected_output, stdout_value.split("\n"))
         # Define the new behavior to be added
@@ -961,9 +939,7 @@ class JacLanguageTests(TestCase):
         """Test match case with multiple expressions."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "match_multi_ex", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("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])
@@ -973,7 +949,7 @@ class JacLanguageTests(TestCase):
         """Test entry and exit behavior of walker."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "entry_exit", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("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])
@@ -986,7 +962,7 @@ class JacLanguageTests(TestCase):
         """Test entry and exit behavior of walker."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "visit_order", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("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)
@@ -995,9 +971,7 @@ class JacLanguageTests(TestCase):
         """Test supporting multiple global variable in a statement."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "glob_multivar_statement", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("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])
@@ -1007,9 +981,7 @@ class JacLanguageTests(TestCase):
         """Test archetype definition bug."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "archetype_def_bug", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("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])
@@ -1019,9 +991,7 @@ class JacLanguageTests(TestCase):
         """Test conn assign on edges."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(
-            self.mach, "visit_sequence", base_path=self.fixture_abs_path("./")
-        )
+        Jac.jac_import("visit_sequence", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         self.assertEqual(
             "walker entry\nwalker enter to root\n"
@@ -1036,9 +1006,7 @@ class JacLanguageTests(TestCase):
         """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("./")
-        )
+        Jac.jac_import("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])
@@ -1054,7 +1022,7 @@ class JacLanguageTests(TestCase):
         """Test complex nested impls."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "node_del", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("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])
@@ -1094,7 +1062,7 @@ class JacLanguageTests(TestCase):
                 sys.stdout = captured_output
                 original_cwd = os.getcwd()
                 try:
-                    Jac.jac_import(self.mach, "importer_site", base_path=tmpdir)
+                    Jac.jac_import("importer_site", base_path=tmpdir)
                 finally:
                     os.chdir(original_cwd)
                     sys.stdout = sys.__stdout__
@@ -1183,19 +1151,18 @@ class JacLanguageTests(TestCase):
         """Test async walker."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "async_walker", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("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])
+        self.assertIn("Let's start the task", stdout_value[0])
+        self.assertIn("It is Coroutine task True", stdout_value[1])
+        self.assertIn("Coroutine task is completed", stdout_value[6])
 
-    def test_async_ability(self) -> None:
+    def test_async_function(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("./")
-        )
+        Jac.jac_import("async_function", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue().split("\n")
         self.assertIn("Hello", stdout_value[0])
@@ -1206,7 +1173,7 @@ class JacLanguageTests(TestCase):
         """Test concurrency in jaclang."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "concurrency", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("concurrency", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue().split("\n")
         self.assertIn("Started", stdout_value[0])
@@ -1267,3 +1234,109 @@ class JacLanguageTests(TestCase):
         self.assertIn("(tok[ 0 ] > change_end_line)", output)
         self.assertIn("(tok[ 0 ] == change_end_line)", output)
         self.assertIn("(tok[ 1 ] > change_end_char)", output)
+
+    def test_here_visitor_usage(self) -> None:
+        """Test visitor, here keyword usage in jaclang."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        Jac.jac_import("here_visitor_usage", base_path=self.fixture_abs_path("./"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue().split("\n")
+        self.assertIn("Here value is  10", stdout_value[0])
+        self.assertIn("Visitor name is  Walker 1", stdout_value[1])
+
+    def test_here_visitor_error(self) -> None:
+        """Test visitor, here keyword usage in jaclang."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        sys.stderr = captured_output
+        cli.run(self.fixture_abs_path("here_usage_error.jac"))
+        sys.stdout = sys.__stdout__
+        sys.stderr = sys.__stderr__
+        stdout_value = captured_output.getvalue()
+        self.assertIn("'here' is not defined", stdout_value)
+
+    def test_edge_ability(self) -> None:
+        """Test visitor, here keyword usage in jaclang."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        cli.run(self.fixture_abs_path("edge_ability.jac"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue().split("\n")
+        self.assertIn("MyEdge from walker MyEdge(path=1)", stdout_value[0])
+        self.assertIn("MyWalker from edge MyWalker()", stdout_value[1])
+        self.assertIn("MyWalker from node MyWalker()", stdout_value[6])
+        self.assertIn("MyEdge from walker MyEdge(path=2)", stdout_value[16])
+
+    def test_backward_edge_visit(self) -> None:
+        """Test backward edge visit in jaclang."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        cli.run(self.fixture_abs_path("backward_edge_visit.jac"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue().split("\n")
+        self.assertIn("MyWalker() from node MyNode(val=0)", stdout_value[0])
+        self.assertIn("MyWalker() from edge MyEdge(path=0)", stdout_value[1])
+        self.assertIn("MyWalker() from edge MyEdge(path=3)", stdout_value[6])
+        self.assertIn("MyWalker() from node MyNode(val=40)", stdout_value[9])
+
+    def test_visit_traversal(self) -> None:
+        """Test visit traversal semantic in jaclang."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        cli.run(self.fixture_abs_path("visit_traversal.jac"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue().split("\n")
+        self.assertIn("MyWalker() from node MyNode(val=0)", stdout_value[0])
+        self.assertIn("MyWalker() from node MyNode(val=20)", stdout_value[2])
+        self.assertIn("MyWalker() from node MyNode(val=60)", stdout_value[4])
+        self.assertIn("MyWalker() from node MyNode(val=40)", stdout_value[6])
+        self.assertIn("MyWalker() from node MyNode(val=90)", stdout_value[7])
+        self.assertIn("MyWalker() from node MyNode(val=70)", stdout_value[9])
+
+    def test_async_ability(self) -> None:
+        """Test async ability."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        Jac.jac_import("async_ability", base_path=self.fixture_abs_path("./"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue().split("\n")
+        self.assertIn("Let's start the task", stdout_value[0])
+        self.assertIn("It is Coroutine task True", stdout_value[1])
+        self.assertIn("I am here man MyNode(val=5)", stdout_value[2])
+        self.assertIn("Async function", stdout_value[3])
+        self.assertIn("foo3", stdout_value[4])
+        self.assertIn("foo1", stdout_value[5])
+        self.assertIn("foo2", stdout_value[6])
+        self.assertIn("Coroutine task is completed", stdout_value[17])
+
+    def test_unicode_string_literals(self) -> None:
+        """Test unicode characters in string literals are preserved correctly."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        Jac.jac_import("unicode_strings", base_path=self.fixture_abs_path("./"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue().split("\n")
+        self.assertIn("1. ✓ 1st (due: True)", stdout_value[0])
+        self.assertIn("🌟 Star", stdout_value[2])
+        self.assertIn("Multi-line with ✓ unicode and ○ symbols", stdout_value[3])
+        self.assertIn("Raw string with ✓ and ○", stdout_value[4])
+        self.assertIn("Tab ✓", stdout_value[5])
+        self.assertIn("Newline ○", stdout_value[6])
+
+    def test_sitecustomize_meta_importer(self) -> None:
+        """Verify Jac modules importable without importing jaclang."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            Path(tmpdir, "mymod.jac").write_text('with entry {print("via meta");}')
+            env = os.environ.copy()
+            project_root = Path(__file__).resolve().parents[2]
+            env["PYTHONPATH"] = os.pathsep.join([str(project_root), tmpdir])
+            proc = subprocess.run(
+                [sys.executable, "-c", "import mymod"],
+                capture_output=True,
+                text=True,
+                cwd=tmpdir,
+                env=env,
+            )
+            self.assertEqual(proc.returncode, 0, proc.stderr)
+            self.assertEqual(proc.stdout.strip(), "via meta")