jaclang 0.8.8__py3-none-any.whl → 0.8.10__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", 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()
@@ -334,7 +346,10 @@ class JacLanguageTests(TestCase):
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("one level deeperslHello World!", stdout_value)
-        self.assertIn("module 'pyfunc' from ", stdout_value)
+        self.assertTrue(
+            "module 'pyfunc' from " in stdout_value
+            or "module 'jaclang.tests.fixtures.pyfunc' from " in stdout_value
+        )
 
     def test_deep_outer_imports_from_loc(self) -> None:
         """Parse micro jac file."""
@@ -345,7 +360,10 @@ class JacLanguageTests(TestCase):
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("one level deeperslHello World!", stdout_value)
-        self.assertIn("module 'pyfunc' from ", stdout_value)
+        self.assertTrue(
+            "module 'jaclang.tests.fixtures.pyfunc' from " in stdout_value
+            or "module 'pyfunc' from " in stdout_value
+        )
 
     def test_has_lambda_goodness(self) -> None:
         """Test has lambda_goodness."""
@@ -516,7 +534,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(
@@ -539,7 +557,7 @@ class JacLanguageTests(TestCase):
                 ),
                 prog=JacProgram(),
             ).ir_out.unparse()
-        self.assertIn("class X {\n    with entry {\n        a_b = 67;", output)
+        self.assertIn("class X {\n    with entry {\n        let a_b = 67;", output)
         self.assertIn("br = b'Hello\\\\\\\\nWorld'", output)
         self.assertIn(
             "class Circle {\n    def init(self: Circle, radius: float", output
@@ -605,9 +623,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 +814,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 +829,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 +839,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 +1368,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 +1487,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 +1500,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 +1515,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 +1560,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 +1581,33 @@ 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])
+        

jaclang/tests/test_reference.py

@@ -3,6 +3,7 @@
 import io
 import os
 from contextlib import redirect_stdout
+import sys
 from typing import Callable, Optional
 
 import jaclang
@@ -50,6 +51,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()
@@ -63,6 +66,12 @@ class JacReferenceTests(TestCase):
                 )
             return f.getvalue()
 
+        def normalize_function_addresses(text: str) -> str:
+            """Normalize function memory addresses in output for consistent comparison."""
+            import re
+            # Replace <function Name at 0xADDRESS> with <function Name at 0x...>
+            return re.sub(r'<function (\w+) at 0x[0-9a-f]+>', r'<function \1 at 0x...>', text)
+
         try:
             if "tests.jac" in filename or "check_statements.jac" in filename:
                 return
@@ -74,21 +83,29 @@ class JacReferenceTests(TestCase):
             )
             output_jac = execute_and_capture_output(code_content, filename=filename)
             Jac.reset_machine()
+            # Clear byllm modules from cache to ensure consistent behavior between JAC and Python runs
+            # when byllm is used
+            sys.modules.pop("byllm", None)
+            sys.modules.pop("byllm.lib", None)
             filename = filename.replace(".jac", ".py")
             with open(filename, "r") as file:
                 code_content = file.read()
             output_py = execute_and_capture_output(code_content, filename=filename)
 
-            # print(f"\nJAC Output:\n{output_jac}")
-            # print(f"\nPython Output:\n{output_py}")
+            # Normalize function addresses before comparison
+            output_jac = normalize_function_addresses(output_jac)
+            output_py = normalize_function_addresses(output_py)
+
+            print(f"\nJAC Output:\n{output_jac}")
+            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}")