jaclang 0.8.8__py3-none-any.whl → 0.8.9__py3-none-any.whl

jaclang/tests/test_cli.py

@@ -128,12 +128,15 @@ class JacCliTests(TestCase):
         sys.stdout = captured_output
         sys.stderr = captured_output
 
-        with contextlib.suppress(Exception):
+        with self.assertRaises(SystemExit) as cm:
             cli.run(self.fixture_abs_path("err_runtime.jac"))
 
         sys.stdout = sys.__stdout__
         sys.stderr = sys.__stderr__
 
+        # Verify exit code is 1
+        self.assertEqual(cm.exception.code, 1)
+
         expected_stdout_values = (
             "Error: list index out of range",
             "    print(some_list[invalid_index]);",
@@ -386,13 +389,13 @@ class JacCliTests(TestCase):
         """Test for graph CLI cmd."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        cli.dot(f"{self.examples_abs_path('reference/connect_expressions.jac')}")
+        cli.dot(f"{self.examples_abs_path('reference/connect_expressions_(osp).jac')}")
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
-        if os.path.exists("connect_expressions.dot"):
-            os.remove("connect_expressions.dot")
-        self.assertIn("11\n13\n15\n>>> Graph content saved to", stdout_value)
-        self.assertIn("connect_expressions.dot\n", stdout_value)
+        if os.path.exists("connect_expressions_(osp).dot"):
+            os.remove("connect_expressions_(osp).dot")
+        self.assertIn(">>> Graph content saved to", stdout_value)
+        self.assertIn("connect_expressions_(osp).dot\n", stdout_value)
 
     def test_py_to_jac(self) -> None:
         """Test for graph CLI cmd."""
@@ -438,27 +441,37 @@ class JacCliTests(TestCase):
         captured_output = io.StringIO()
         sys.stdout = captured_output
         from jaclang.compiler.program import JacProgram
-        
-        filename = self.fixture_abs_path('../../tests/fixtures/params/test_complex_params.jac')
-        cli.jac2py(f"{self.fixture_abs_path('../../tests/fixtures/params/test_complex_params.jac')}")
+
+        filename = self.fixture_abs_path(
+            "../../tests/fixtures/params/test_complex_params.jac"
+        )
+        cli.jac2py(
+            f"{self.fixture_abs_path('../../tests/fixtures/params/test_complex_params.jac')}"
+        )
         py_code = JacProgram().compile(file_path=filename).gen.py
-        
+
         # Create temporary Python file
-        with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as temp_file:
+        with tempfile.NamedTemporaryFile(
+            mode="w", suffix=".py", delete=False
+        ) as temp_file:
             temp_file.write(py_code)
             py_file_path = temp_file.name
-        
+
         try:
-            jac_code = JacProgram().compile(use_str=py_code, file_path=py_file_path).unparse()
+            jac_code = (
+                JacProgram().compile(use_str=py_code, file_path=py_file_path).unparse()
+            )
             # Create temporary Jac file
-            with tempfile.NamedTemporaryFile(mode='w', suffix='.jac', delete=False) as temp_file:
+            with tempfile.NamedTemporaryFile(
+                mode="w", suffix=".jac", delete=False
+            ) as temp_file:
                 temp_file.write(jac_code)
                 jac_file_path = temp_file.name
             cli.run(jac_file_path)
         finally:
-                os.remove(py_file_path)
-                os.remove(jac_file_path)
-        
+            os.remove(py_file_path)
+            os.remove(jac_file_path)
+
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue().split("\n")
         self.assertEqual("ULTIMATE_MIN: 1|def|2.5|0|test|100|0", stdout_value[-7])
@@ -466,7 +479,9 @@ class JacCliTests(TestCase):
         self.assertEqual("SEPARATORS: 42", stdout_value[-5])
         self.assertEqual("EDGE_MIX: 1-test-2-True-1", stdout_value[-4])
         self.assertEqual("RECURSIVE: 7 11", stdout_value[-3])
-        self.assertEqual("VALIDATION: x:1,y:2.5,z:10,args:1,w:True,kwargs:1", stdout_value[-2])
+        self.assertEqual(
+            "VALIDATION: x:1,y:2.5,z:10,args:1,w:True,kwargs:1", stdout_value[-2]
+        )
 
     def test_caching_issue(self) -> None:
         """Test for Caching Issue."""
@@ -645,3 +660,104 @@ class JacCliTests(TestCase):
         )
         stdout, stderr = process.communicate()
         self.assertIn("Hello World!", stdout)
+
+    def test_cli_error_exit_codes(self) -> None:
+        """Test that CLI commands return non-zero exit codes on errors."""
+        # Test run command with syntax error
+        process = subprocess.Popen(
+            ["jac", "run", self.fixture_abs_path("err2.jac")],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        stdout, stderr = process.communicate()
+        self.assertEqual(
+            process.returncode, 1, "run command should exit with code 1 on syntax error"
+        )
+        self.assertIn("Error running", stderr)
+
+        # Test build command with syntax error
+        process = subprocess.Popen(
+            ["jac", "build", self.fixture_abs_path("err2.jac")],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        stdout, stderr = process.communicate()
+        self.assertEqual(
+            process.returncode,
+            1,
+            "build command should exit with code 1 on compilation error",
+        )
+
+        # Test check command with syntax error
+        process = subprocess.Popen(
+            ["jac", "check", self.fixture_abs_path("err2.jac")],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        stdout, stderr = process.communicate()
+        self.assertEqual(
+            process.returncode,
+            1,
+            "check command should exit with code 1 on type check error",
+        )
+
+        # Test format command with non-existent file
+        process = subprocess.Popen(
+            ["jac", "format", "/nonexistent.jac"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        stdout, stderr = process.communicate()
+        self.assertEqual(
+            process.returncode,
+            1,
+            "format command should exit with code 1 on missing file",
+        )
+        self.assertIn("does not exist", stderr)
+
+        # Test check command with invalid file type
+        process = subprocess.Popen(
+            ["jac", "check", "/nonexistent.txt"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        stdout, stderr = process.communicate()
+        self.assertEqual(
+            process.returncode,
+            1,
+            "check command should exit with code 1 on invalid file type",
+        )
+        self.assertIn("Not a .jac file", stderr)
+
+        # Test tool command with non-existent tool
+        process = subprocess.Popen(
+            ["jac", "tool", "nonexistent_tool"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        stdout, stderr = process.communicate()
+        self.assertEqual(
+            process.returncode,
+            1,
+            "tool command should exit with code 1 on non-existent tool",
+        )
+        self.assertIn("not found", stderr)
+
+        # Test successful run returns exit code 0
+        process = subprocess.Popen(
+            ["jac", "run", self.fixture_abs_path("hello.jac")],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        stdout, stderr = process.communicate()
+        self.assertEqual(
+            process.returncode, 0, "run command should exit with code 0 on success"
+        )
+        self.assertIn("Hello World!", stdout)

jaclang/tests/test_language.py

@@ -133,8 +133,17 @@ class JacLanguageTests(TestCase):
 
         for edge in edges:
             label = edge["label"]
-            self.assertIn(label, ["E(val=1)", "E(val=1)", "E(val=1)", "E(val=0)", "E(val=0)", "E(val=0)"])
-
+            self.assertIn(
+                label,
+                [
+                    "E(val=1)",
+                    "E(val=1)",
+                    "E(val=1)",
+                    "E(val=0)",
+                    "E(val=0)",
+                    "E(val=0)",
+                ],
+            )
 
     def test_printgraph_mermaid(self) -> None:
         """Test the mermaid gen of builtin function."""
@@ -201,11 +210,26 @@ class JacLanguageTests(TestCase):
         )
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        exec(compile(prog.gen.py_ast[0], "test.py", "exec"))
+        exec(compile(prog.gen.py_ast[0], "test.jac", "exec"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(stdout_value, "-5\n")
 
+    def test_assignment_list_no_infinite_loop(self) -> None:
+        """Test that assignment list parsing doesn't cause infinite loop."""
+        # This syntax previously caused an infinite loop in two places:
+        # 1. Grammar: assignment_list: (assignment_list COMMA)? (assignment | named_ref)
+        #    Fixed by: assignment_list: (assignment | named_ref) (COMMA (assignment | named_ref))* COMMA?
+        # 2. Error recovery: feed_current_token() had unbounded while loop
+        #    Fixed by: adding max_attempts limit in parser.py
+        code = "with entry { p1, p2 = (10, 20); }"
+        # Compilation should complete quickly (even though syntax is invalid)
+        jac_prog = JacProgram()
+        result = jac_prog.compile(use_str=code, file_path="test.jac")
+        # Should have errors (invalid syntax) but not hang
+        self.assertIsNotNone(result)  # Returns a Module object
+        self.assertGreater(len(jac_prog.errors_had), 0)  # Check errors on program
+
     def test_need_import(self) -> None:
         """Test importing python."""
         captured_output = io.StringIO()
@@ -215,18 +239,6 @@ class JacLanguageTests(TestCase):
         stdout_value = captured_output.getvalue()
         self.assertIn("<module 'pyfunc' from", stdout_value)
 
-    def test_filter_compr(self) -> None:
-        """Testing filter comprehension."""
-        captured_output = io.StringIO()
-        sys.stdout = captured_output
-        Jac.jac_import(
-            "reference.special_comprehensions",
-            base_path=self.examples_abs_path(""),
-        )
-        sys.stdout = sys.__stdout__
-        stdout_value = captured_output.getvalue()
-        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()
@@ -516,7 +528,7 @@ class JacLanguageTests(TestCase):
             ).ir_out.unparse()
         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("assert (x == 5) , 'x should be equal to 5';", output)
         self.assertIn("if not (x == y) {", output)
         self.assertIn("squares_dict = {x : (x ** 2) for x in numbers};", output)
         self.assertIn(
@@ -605,9 +617,34 @@ class JacLanguageTests(TestCase):
                 prog=None,
             ).ir_out.unparse()
         self.assertIn(
-            "def isinstance( <>obj: object , class_or_tuple: _ClassInfo , /)  -> bool {", output)
+            "def isinstance( <>obj: object , class_or_tuple: _ClassInfo , /)  -> bool {",
+            output,
+        )
         self.assertIn(
-            "def len(<>obj: Sized, astt: Any, /, z: int, j: str, a: Any = 90) -> int {", output)
+            "def len(<>obj: Sized, astt: Any, /, z: int, j: str, a: Any = 90) -> int {",
+            output,
+        )
+
+    def test_py2jac_empty_file(self) -> None:
+        """Test py ast to Jac ast conversion."""
+        from jaclang.compiler.passes.main import PyastBuildPass
+        import jaclang.compiler.unitree as ast
+        import ast as py_ast
+
+        py_out_path = os.path.join(self.fixture_abs_path("./"), "py2jac_empty.py")
+        with open(py_out_path) as f:
+            file_source = f.read()
+            converted_ast = PyastBuildPass(
+                ir_in=ast.PythonModuleAst(
+                    py_ast.parse(file_source),
+                    orig_src=ast.Source(file_source, py_out_path),
+                ),
+                prog=None,
+            ).ir_out
+        self.assertIsInstance(
+            converted_ast,
+            ast.Module
+        )
 
     def test_refs_target(self) -> None:
         """Test py ast to Jac ast conversion output."""
@@ -771,7 +808,9 @@ class JacLanguageTests(TestCase):
         """Test importing python."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import("test_kwonly_params", base_path=self.fixture_abs_path("./params"))
+        Jac.jac_import(
+            "test_kwonly_params", base_path=self.fixture_abs_path("./params")
+        )
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue().split("\n")
         self.assertEqual("KW_SIMPLE: 42", stdout_value[0])
@@ -784,7 +823,9 @@ class JacLanguageTests(TestCase):
         """Test importing python."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import("test_complex_params", base_path=self.fixture_abs_path("./params"))
+        Jac.jac_import(
+            "test_complex_params", base_path=self.fixture_abs_path("./params")
+        )
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue().split("\n")
         self.assertEqual("ULTIMATE_MIN: 1|def|2.5|0|test|100|0", stdout_value[0])
@@ -792,17 +833,23 @@ class JacLanguageTests(TestCase):
         self.assertEqual("SEPARATORS: 42", stdout_value[2])
         self.assertEqual("EDGE_MIX: 1-test-2-True-1", stdout_value[3])
         self.assertEqual("RECURSIVE: 7 11", stdout_value[4])
-        self.assertEqual("VALIDATION: x:1,y:2.5,z:10,args:1,w:True,kwargs:1", stdout_value[5])
+        self.assertEqual(
+            "VALIDATION: x:1,y:2.5,z:10,args:1,w:True,kwargs:1", stdout_value[5]
+        )
 
     def test_param_failing(self) -> None:
         """Test importing python."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        for i in ["test_failing_posonly", "test_failing_kwonly", "test_failing_varargs"]:
+        for i in [
+            "test_failing_posonly",
+            "test_failing_kwonly",
+            "test_failing_varargs",
+        ]:
             Jac.jac_import(i, base_path=self.fixture_abs_path("./params"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
-        self.assertNotIn('FAILED', stdout_value)
+        self.assertNotIn("FAILED", stdout_value)
 
     def test_double_import_exec(self) -> None:
         """Test importing python."""
@@ -1315,9 +1362,11 @@ class JacLanguageTests(TestCase):
         captured_output = io.StringIO()
         sys.stdout = captured_output
         sys.stderr = captured_output
-        cli.run(self.fixture_abs_path("here_usage_error.jac"))
+        with self.assertRaises(SystemExit) as cm:
+            cli.run(self.fixture_abs_path("here_usage_error.jac"))
         sys.stdout = sys.__stdout__
         sys.stderr = sys.__stderr__
+        self.assertEqual(cm.exception.code, 1)
         stdout_value = captured_output.getvalue()
         self.assertIn("'here' is not defined", stdout_value)
 
@@ -1432,7 +1481,7 @@ class JacLanguageTests(TestCase):
 
     def test_read_file_with_encoding_utf8(self) -> None:
         """Test reading UTF-8 encoded file."""
-        with tempfile.NamedTemporaryFile(mode='w', encoding='utf-8', delete=False) as f:
+        with tempfile.NamedTemporaryFile(mode="w", encoding="utf-8", delete=False) as f:
             test_content = "Hello, 世界! 🌍 Testing UTF-8 encoding."
             f.write(test_content)
             temp_path = f.name
@@ -1445,7 +1494,9 @@ class JacLanguageTests(TestCase):
 
     def test_read_file_with_encoding_utf16(self) -> None:
         """Test reading UTF-16 encoded file when UTF-8 fails."""
-        with tempfile.NamedTemporaryFile(delete=False, mode="w", encoding="utf-16") as f:
+        with tempfile.NamedTemporaryFile(
+            delete=False, mode="w", encoding="utf-16"
+        ) as f:
             test_content = "Hello, 世界! UTF-16 encoding test."
             f.write(test_content)
             temp_path = f.name
@@ -1458,7 +1509,9 @@ class JacLanguageTests(TestCase):
 
     def test_read_file_with_encoding_utf8_bom(self) -> None:
         """Test reading UTF-8 with BOM encoded file."""
-        with tempfile.NamedTemporaryFile(delete=False, mode='w', encoding='utf-8-sig') as f:
+        with tempfile.NamedTemporaryFile(
+            delete=False, mode="w", encoding="utf-8-sig"
+        ) as f:
             test_content = "Hello, UTF-8 BOM test! 🚀"
             f.write(test_content)
             temp_path = f.name
@@ -1501,7 +1554,7 @@ class JacLanguageTests(TestCase):
 
     def test_read_file_with_encoding_special_characters(self) -> None:
         """Test reading file with various special characters."""
-        with tempfile.NamedTemporaryFile(mode='w', encoding='utf-8', delete=False) as f:
+        with tempfile.NamedTemporaryFile(mode="w", encoding="utf-8", delete=False) as f:
             test_content = (
                 "Special chars: åäö ñ ü ç é\n"
                 "Symbols: ©®™ §¶†‡•\n"
@@ -1522,4 +1575,68 @@ class JacLanguageTests(TestCase):
             self.assertIn("∑∏∫", result)
             self.assertIn("😀😍", result)
         finally:
-            os.unlink(temp_path)
+            os.unlink(temp_path)
+
+    def test_funccall_genexpr(self) -> None:
+        """Test function call with generator expression in both Jac and py2jac."""
+        # Test language support
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        Jac.jac_import("funccall_genexpr", base_path=self.fixture_abs_path("./"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue().split("\n")
+        self.assertIn("Result: 30", stdout_value[0])
+        
+        # Test py2jac conversion
+        py_file_path = f"{self.fixture_abs_path('../../tests/fixtures/funccall_genexpr.py')}"
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        cli.py2jac(py_file_path)
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        self.assertIn("result = total((x * x) for x in range(5));", stdout_value)
+
+    def test_attr_pattern_case(self) -> None:
+        """Test attribute pattern matching."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        Jac.jac_import("attr_pattern_case", base_path=self.fixture_abs_path("./"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue().split("\n")
+        self.assertIn("Matched a.b.c Hello Jaseci!", stdout_value[0])
+        
+    def test_known_builtins_matches_actual(self) -> None:
+        """Test that KNOWN_BUILTINS in PyastGenPass matches actual builtins."""
+        from jaclang.compiler.passes.main.pyast_gen_pass import PyastGenPass
+        import jaclang.runtimelib.builtin as builtin_module
+
+        # Get actual builtins from the module (excluding private members)
+        actual_builtins = {
+            name for name in builtin_module.__all__
+            if not name.startswith('_')
+        }
+
+        # Exceptions: builtins that are imported from other sources
+        # - Enum: imported via needs_enum() from standard library's enum module
+        exceptions = {'Enum'}
+        actual_builtins_to_check = actual_builtins - exceptions
+
+        # Get the KNOWN_BUILTINS set from PyastGenPass
+        known_builtins = PyastGenPass.KNOWN_BUILTINS
+
+        # Find missing and extra builtins
+        missing = actual_builtins_to_check - known_builtins
+        extra = known_builtins - actual_builtins_to_check
+
+        # Build error message
+        error_msg = []
+        if missing:
+            error_msg.append(f"Missing from KNOWN_BUILTINS: {sorted(missing)}")
+        if extra:
+            error_msg.append(f"Extra in KNOWN_BUILTINS (not in builtin module): {sorted(extra)}")
+
+        # Assert they match
+        self.assertEqual(
+            known_builtins, actual_builtins_to_check,
+            "\n".join(error_msg) if error_msg else ""
+        )

jaclang/tests/test_reference.py

@@ -50,6 +50,8 @@ class JacReferenceTests(TestCase):
 
     def micro_suite_test(self, filename: str) -> None:
         """Test file."""
+        # Reset machine at the start of each test to ensure clean state
+        Jac.reset_machine()
 
         def execute_and_capture_output(code: str | bytes, filename: str = "") -> str:
             f = io.StringIO()
@@ -83,12 +85,12 @@ class JacReferenceTests(TestCase):
             # print(f"\nPython Output:\n{output_py}")
 
             self.assertGreater(len(output_py), 0)
-            self.assertEqual(len(output_jac.split("\n")), len(output_py.split("\n")))
             # doing like below for concurrent_expressions.jac and other current tests
             for i in output_py.split("\n"):
                 self.assertIn(i, output_jac)
             for i in output_jac.split("\n"):
                 self.assertIn(i, output_py)
+            self.assertEqual(len(output_jac.split("\n")), len(output_py.split("\n")))
             # self.assertEqual(output_py, output_jac)
         except Exception as e:
             # print(f"\nJAC Output:\n{output_jac}")

jaclang/utils/helpers.py

@@ -94,12 +94,19 @@ def auto_generate_refs() -> str:
         os.path.split(os.path.dirname(__file__))[0], "../jaclang/compiler/jac.lark"
     )
     result = extract_headings(file_path)
-    md_str = '# Jac Language Reference\n\n--8<-- "jac/examples/reference/introduction.md"\n\n'
+
+    # Create the reference subdirectory if it doesn't exist
+    docs_ref_dir = os.path.join(
+        os.path.split(os.path.dirname(__file__))[0], "../../docs/docs/learn/jac_ref"
+    )
+    os.makedirs(docs_ref_dir, exist_ok=True)
+
+    # Generate individual markdown files for each section
     for heading, lines in result.items():
         heading = heading.strip()
         heading_snakecase = heading_to_snake(heading)
         content = (
-            f'## {heading}\n**Code Example**\n!!! example "Runnable Example in Jac and JacLib"\n'
+            f'# {heading}\n\n**Code Example**\n!!! example "Runnable Example in Jac and JacLib"\n'
             '    === "Try it!"\n        <div class="code-block">\n'
             "        ```jac\n"
             f'        --8<-- "jac/examples/reference/{heading_snakecase}.jac"\n'
@@ -112,12 +119,21 @@ def auto_generate_refs() -> str:
             '        --8<-- "jac/examples/reference/'
             f'{heading_snakecase}.py"\n        ```\n'
             f'??? info "Jac Grammar Snippet"\n    ```yaml linenums="{lines[0]}"\n    --8<-- '
-            f'"jac/jaclang/compiler/jac.lark:{lines[0]}:{lines[1]}"\n    ```\n'
+            f'"jac/jaclang/compiler/jac.lark:{lines[0]}:{lines[1]}"\n    ```\n\n'
             "**Description**\n\n--8<-- "
             f'"jac/examples/reference/'
             f'{heading_snakecase}.md"\n'
         )
-        md_str += f"{content}\n"
+
+        # Write individual file
+        output_file = os.path.join(docs_ref_dir, f"{heading_snakecase}.md")
+        with open(output_file, "w") as f:
+            f.write(content)
+
+    # Return just the introduction for the main jac_ref.md file
+    md_str = (
+        '# Jac Language Reference\n\n--8<-- "jac/examples/reference/introduction.md"\n'
+    )
     return md_str
 
 

jaclang/utils/tests/test_lang_tools.py

@@ -112,7 +112,7 @@ class JacAstToolTests(TestCase):
         """Testing for sym, sym. AstTool."""
         jac_file = os.path.normpath(
             os.path.join(
-                os.path.dirname(jaclang.__file__), "../examples/reference/atom.jac"
+                os.path.dirname(jaclang.__file__), "../examples/reference/while_statements.jac"
             )
         )
         out = self.tool.ir(["sym", jac_file])
@@ -122,25 +122,14 @@ class JacAstToolTests(TestCase):
         )
         check_list = [
             "########",
-            "# atom #",
+            "# while_statements #",
             "########",
-            "SymTable::Module(atom)",
-            "|   +-- list1",
-            "|   +-- x",
-            "|   +-- impl.x",
-            "|   +-- c",
-            "|   +-- d",
-            "|   +-- a",
-            "|   +-- b",
-            "+-- SymTable::ImplDef(impl.x)",
-            " SymTable::Enum(x)",
-            "+-- line 19, col 13",
+            "SymTable::Module(while_statements)",
         ]
         for i in check_list:
             self.assertIn(i, out)
         out = self.tool.ir(["sym.", jac_file])
-        self.assertIn('[label="impl.x"];', out)
-        self.assertNotIn('[label="str"];', out)
+        self.assertIn('[label="', out)
 
     def test_uninode_doc(self) -> None:
         """Testing for Autodoc for Uninodes."""

{jaclang-0.8.8.dist-info → jaclang-0.8.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jaclang
-Version: 0.8.8
+Version: 0.8.9
 Summary: Jac is a unique and powerful programming language that runs on top of Python, offering an unprecedented level of intelligence and intuitive understanding.
 License: MIT
 Keywords: jac,jaclang,jaseci,python,programming-language,machine-learning,artificial-intelligence