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

jaclang/tests/fixtures/params/test_failing_posonly.jac

@@ -0,0 +1,116 @@
+# Test failing positional-only parameter cases
+
+def strict_posonly(a: int, b: str, /) -> str {
+    return f"{a}: {b}";
+}
+
+def mixed_posonly(x: int, /, y: str, z: float = 1.0) -> str {
+    return f"{x}-{y}-{z}";
+}
+
+def complex_posonly(a: int, b: str = "def", /, c: float, *args: int, kw: bool, **kwargs: any) -> dict {
+    return {"a": a, "b": b, "c": c, "args": list(args), "kw": kw, "kwargs": kwargs};
+}
+
+def edge_case_posonly(/, x: int) -> int {
+    return x;
+}
+
+def no_regular_params(a: int, /, *, b: str) -> str {
+    return f"{a}: {b}";
+}
+
+with entry {
+    print("=== TESTING POSITIONAL-ONLY FAILURES ===");
+    
+    # Test 1: Calling pos-only with keyword arguments
+    try {
+        result = strict_posonly(a=10, b="test");
+        print("❌ FAIL: Should reject pos-only as keywords");
+    } except Exception as e {
+        print("✅ PASS: Caught pos-only keyword error");
+    }
+    
+    # Test 2: Partial keyword arguments on pos-only
+    try {
+        result = strict_posonly(10, b="test");
+        print("❌ FAIL: Should reject mixed pos-only calling");
+    } except Exception as e {
+        print("✅ PASS: Caught mixed pos-only error");
+    }
+    
+    # Test 3: Too many positional arguments
+    try {
+        result = strict_posonly(1, "test", "extra");
+        print("❌ FAIL: Should reject too many args");
+    } except Exception as e {
+        print("✅ PASS: Caught too many args error");
+    }
+    
+    # Test 4: Missing required positional-only
+    try {
+        result = strict_posonly(42);
+        print("❌ FAIL: Should reject missing required pos-only");
+    } except Exception as e {
+        print("✅ PASS: Caught missing pos-only error");
+    }
+    
+    # Test 5: Mixed signature - wrong keyword usage
+    try {
+        result = mixed_posonly(x=10, y="test");
+        print("❌ FAIL: Should reject pos-only x as keyword");
+    } except Exception as e {
+        print("✅ PASS: Caught mixed signature error");
+    }
+    
+    # Test 6: Complex signature - pos-only as keyword
+    try {
+        result = complex_posonly(a=1, c=2.5, kw=True);
+        print("❌ FAIL: Should reject pos-only a as keyword");
+    } except Exception as e {
+        print("✅ PASS: Caught complex pos-only error");
+    }
+    
+    # Test 7: Edge case - only separator with keyword
+    try {
+        result = edge_case_posonly(x=42);
+        print("✅ PASS: Edge case works:", result);
+    } except Exception as e {
+        print("✅ PASS: Edge case properly rejected");
+    }
+    
+    # Test 8: No regular params - wrong calling pattern
+    try {
+        result = no_regular_params(1, "test");
+        print("❌ FAIL: Should reject positional for keyword-only");
+    } except Exception as e {
+        print("✅ PASS: Caught no-regular-params error");
+    }
+    
+
+    result = strict_posonly("not_int", "test");
+
+    
+    # Test 10: Empty call to required pos-only
+    try {
+        result = strict_posonly();
+        print("❌ FAIL: Should reject empty call");
+    } except Exception as e {
+        print("✅ PASS: Caught empty call error");
+    }
+    
+    # Test 11: Valid calls that should work
+    try {
+        result = strict_posonly(42, "valid");
+        print("✅ PASS: Valid pos-only call:", result);
+    } except Exception as e {
+        print("❌ FAIL: Valid call rejected");
+    }
+    
+    try {
+        result = mixed_posonly(1, "test", 3.14);
+        print("✅ PASS: Valid mixed call:", result);
+    } except Exception as e {
+        print("❌ FAIL: Valid mixed call rejected");
+    }
+}

jaclang/tests/fixtures/params/test_failing_varargs.jac

@@ -0,0 +1,300 @@
+# Test failing variable arguments cases (*args, **kwargs)
+
+def simple_args_only(*args: int) -> int {
+    return sum(args);
+}
+
+def simple_kwargs_only(**kwargs: str) -> int {
+    return len(kwargs);
+}
+
+def args_with_required(req: str, *args: int) -> str {
+    return f"{req}: {sum(args)}";
+}
+
+def kwargs_with_required(req: int, **kwargs: str) -> dict {
+    return {"req": req, "kwargs": kwargs};
+}
+
+def full_varargs_signature(
+    pos: int,
+    /,
+    reg: str,
+    def_param: float = 1.0,
+    *args: int,
+    kw_req: bool,
+    kw_opt: str = "default",
+    **kwargs: any
+) -> dict {
+    return {
+        "pos": pos, "reg": reg, "def_param": def_param,
+        "args": list(args), "kw_req": kw_req, "kw_opt": kw_opt, "kwargs": kwargs
+    };
+}
+
+def conflicting_names(name: str, *args: str, name_kw: str, **kwargs: str) -> dict {
+    return {"name": name, "args": list(args), "name_kw": name_kw, "kwargs": kwargs};
+}
+
+def type_sensitive_varargs(*args: int, **kwargs: int) -> dict {
+    return {"args_sum": sum(args), "kwargs_sum": sum(kwargs.values())};
+}
+
+def edge_case_empty_varargs(required: str, *args: float, **kwargs: bool) -> str {
+    return f"{required}: args={len(args)}, kwargs={len(kwargs)}";
+}
+
+def double_star_issues(**kwargs: dict) -> int {
+    total = 0;
+    for (k, v) in kwargs.items() {
+        if isinstance(v, dict) {
+            total += len(v);
+        } else {
+            total += 1;
+        }
+    }
+    return total;
+}
+
+def additional_varargs_edge_cases() -> None {
+    print("\n=== ADDITIONAL VARARGS EDGE CASES ===");
+    
+    # Test 16: Empty containers passed to varargs
+    def test_empty_containers(*args: list, **kwargs: dict) -> dict {
+        return {"args_count": len(args), "kwargs_count": len(kwargs)};
+    }
+    
+    try {
+        result = test_empty_containers([], {}, third_arg=[]);
+        print("✅ PASS: Empty containers:", result);
+    } except Exception as e {
+        print("❌ FAIL: Empty containers failed");
+    }
+    
+    # Test 17: Nested data structures
+    def complex_data_varargs(*args: dict, **kwargs: list) -> dict {
+        return {"total_keys": sum(args), "total_items": len(kwargs)};
+    }
+    
+    try {
+        result = complex_data_varargs(
+            12,
+            16,
+            list1=[1, 2, 3],
+            list2=[4, 5]
+        );
+        print("✅ PASS: Complex data structures:", result);
+    } except Exception as e {
+        print("❌ FAIL: Complex data structures failed");
+    }
+    
+    # Test 18: Special character handling in kwargs keys
+    def special_chars_kwargs(**kwargs: str) -> dict {
+        return {"keys": list(kwargs.keys()), "count": len(kwargs)};
+    }
+    
+    try {
+        # Note: Most of these won't work as valid identifiers, but let's test what we can
+        result = special_chars_kwargs(normal="value", with_underscore="test");
+        print("✅ PASS: Special chars in kwargs:", result);
+    } except Exception as e {
+        print("❌ FAIL: Special chars failed");
+    }
+    
+    # Test 19: Very large argument counts
+    def stress_test_args(*args: int) -> dict {
+        return {"count": len(args), "sum": sum(args), "avg": sum(args)/len(args) if args else 0};
+    }
+    
+    try {
+        large_args = list(range(100));  # 100 arguments
+        result = stress_test_args(*large_args);
+        print("✅ PASS: Large arg count:", f"count={result['count']}, avg={result['avg']}");
+    } except Exception as e {
+        print("❌ FAIL: Large arg count failed");
+    }
+    
+    # Test 20: Mixing unpacking with explicit args
+    def mixed_unpacking_test(first: str, *args: int, last: str, **kwargs: bool) -> dict {
+        _sum = sum(args);
+        _kwargs_true_count = 0;
+        for v in kwargs.values() {
+            if v {
+                _kwargs_true_count += 1;
+            }
+        }
+        return {
+            "first": first,
+            "args_sum": _sum,
+            "last": last,
+            "kwargs_true_count": _kwargs_true_count
+        };
+    }
+    
+    try {
+        numbers = [10, 20, 30];
+        flags = {"debug": True, "verbose": False, "strict": True};
+        result = mixed_unpacking_test("start", *numbers, last="end", **flags);
+        print("✅ PASS: Mixed unpacking:", result);
+    } except Exception as e {
+        print("❌ FAIL: Mixed unpacking failed");
+    }
+    
+    # Test 21: Recursive function with varargs
+    def recursive_varargs(depth: int, *args: str, **kwargs: int) -> dict {
+        if depth <= 0 or not args {
+            return {"depth": depth, "args": list(args), "kwargs": kwargs};
+        }
+        
+        new_args = args[1:];  # Remove first arg
+        new_kwargs = {k: v+1 for (k, v) in kwargs.items()};  # Increment all values
+        
+        return recursive_varargs(depth-1, *new_args, **new_kwargs);
+    }
+    
+    try {
+        result = recursive_varargs(3, "a", "b", "c", "d", x=1, y=2);
+        print("✅ PASS: Recursive varargs:", result);
+    } except Exception as e {
+        print("❌ FAIL: Recursive varargs failed");
+    }
+}
+
+with entry {
+    print("=== TESTING VARIABLE ARGUMENTS FAILURES ===");
+    
+    # Test 1: Wrong types in *args (if type checking enabled)
+    try {
+        result = simple_args_only(1, 2, "not_int", 4);
+        print("❌ FAIL: Should catch mixed types in *args");
+    } except Exception as e {
+        print("✅ PASS: Caught *args type error");
+    }
+    
+    # Test 2: Wrong types in **kwargs (if type checking enabled)
+    try {
+        result = simple_kwargs_only(12,a="string", b=123, c="string");
+        print("❌ FAIL: Should catch mixed types in **kwargs");
+    } except Exception as e {
+        print("✅ PASS: Caught **kwargs type error");
+    }
+    
+    # Test 3: Missing required before *args
+    try {
+        result = args_with_required(1, 2, 3, apple=90);
+    } except Exception as e {
+        print("✅ PASS: Caught required param type error");
+    }
+    
+    # Test 4: Missing required before **kwargs
+    try {
+        result = kwargs_with_required(name="test", value="data");
+        print("❌ FAIL: Should catch wrong types for required");
+    } except Exception as e {
+        print("✅ PASS: Caught required before kwargs error");
+    }
+    
+    # Test 5: Complex signature - pos-only passed as keyword
+    try {
+        result = full_varargs_signature(
+            pos=1, reg="test", kw_req=True
+        );
+        print("❌ FAIL: Should reject pos-only as keyword in varargs");
+    } except Exception as e {
+        print("✅ PASS: Caught pos-only in varargs error");
+    }
+    
+    # Test 6: Complex signature - missing required kw-only
+    try {
+        result = full_varargs_signature(1, "test", 2.0, 10, 20);
+        print("❌ FAIL: Should reject missing kw-only in varargs");
+    } except Exception as e {
+        print("✅ PASS: Caught missing kw-only in varargs");
+    }
+    
+    # Test 7: Name conflicts between params and kwargs
+    try {
+        result = conflicting_names("test", "arg1", name_kw="kw_test", name="conflict");
+        print("❌ FAIL: Should catch parameter name conflicts");
+    } except Exception as e {
+        print("✅ PASS: Caught name conflict error");
+    }
+    
+    # Test 8: Type-sensitive varargs with wrong types
+    try {
+        result = type_sensitive_varargs(1, 2, 3, a="not_int", b=4.5);
+        print("❌ FAIL: Should catch type mismatch in kwargs");
+    } except Exception as e {
+        print("✅ PASS: Caught varargs type sensitivity error");
+    }
+    
+
+    # Test 9: Double unpacking issues
+    try {
+        data = {"a": {"nested": "dict"}, "b": "simple"};
+        result = double_star_issues(**data);
+        print("✅ INFO: Double star result:", result);
+    } except Exception as e {
+        print("✅ PASS: Caught double star error");
+    }
+    
+    # Test 10: Empty varargs but required params missing
+    try {
+        result = edge_case_empty_varargs();
+        print("❌ FAIL: Should catch missing required with empty varargs");
+    } except Exception as e {
+        print("✅ PASS: Caught missing required in empty varargs");
+    }
+    
+    
+    # Test 11: Keyword argument conflicts with *args collection
+    try {
+        items = [1, 2, 3];
+        result = args_with_required("test", *items, args="conflict");
+        print("❌ FAIL: Should catch args name conflict");
+    } except Exception as e {
+        print("✅ PASS: Caught args conflict error");
+    }
+    
+    # Test 12: **kwargs conflicts with explicit keywords
+    try {
+        extra_data = {"kw_req": True, "extra": "data"};
+        result = full_varargs_signature(1, "test", kw_req=False, **extra_data);
+        print("❌ FAIL: Should catch kwargs conflict with explicit");
+    } except Exception as e {
+        print("✅ PASS: Caught kwargs explicit conflict");
+    }
+    
+    # Test 13: Valid calls that should work
+    try {
+        result = simple_args_only(1, 2, 3, 4, 5);
+        print("✅ PASS: Valid *args call:", result);
+    } except Exception as e {
+        print("❌ FAIL: Valid *args call rejected");
+    }
+    
+    try {
+        result = simple_kwargs_only(a="test", b="data", c="more");
+        print("✅ PASS: Valid **kwargs call:", result);
+    } except Exception as e {
+        print("❌ FAIL: Valid **kwargs call rejected");
+    }
+    
+    try {
+        result = full_varargs_signature(
+            1,                    # pos (pos-only)
+            "regular",           # reg
+            2.5,                 # def_param
+            10, 20, 30,          # *args
+            kw_req=True,         # kw_req (required kw-only)
+            kw_opt="custom",     # kw_opt (optional kw-only)
+            extra="data",        # **kwargs
+            more="info"
+        );
+        print("✅ PASS: Valid complex varargs call keys:", list(result.keys()));
+    } except Exception as e {
+        print("❌ FAIL: Valid complex varargs rejected");
+    }
+    
+    additional_varargs_edge_cases();
+}

jaclang/tests/fixtures/params/test_kwonly_params.jac

@@ -0,0 +1,29 @@
+# Test keyword-only parameters
+
+def simple_kwonly(*, x: int) -> int {
+    return x;
+}
+
+def kwonly_with_defaults(*, x: int = 10, y: str = "def") -> str {
+    return f"{x}-{y}";
+}
+
+def regular_plus_kwonly(normal: int, *, kw: str) -> str {
+    return f"{normal}|{kw}";
+}
+
+def mixed_kwonly(pos: int, reg: str = "def", *, kw1: float, kw2: bool = True) -> str {
+    return f"{pos}-{reg}-{kw1}-{kw2}";
+}
+
+def all_kwonly(*, a: int, b: str = "test", c: float = 1.0) -> str {
+    return f"{a}:{b}:{c}";
+}
+
+with entry {
+    print("KW_SIMPLE:", simple_kwonly(x=42));
+    print("KW_DEF:", kwonly_with_defaults(), kwonly_with_defaults(x=20));
+    print("REG_KW:", regular_plus_kwonly(10, kw="test"));
+    print("MIXED_KW:", mixed_kwonly(1, kw1=2.5), mixed_kwonly(2, "custom", kw1=3.5, kw2=False));
+    print("ALL_KW:", all_kwonly(a=100), all_kwonly(a=200, b="hi", c=9.9));
+}

jaclang/tests/fixtures/py2jac_params.py

@@ -0,0 +1,8 @@
+from typing_extensions import TypeAlias
+import collections.abc
+
+_ClassInfo: TypeAlias = type | tuple[object, ...]
+Sized = collections.abc.Sized
+
+def isinstance(obj: object, class_or_tuple: _ClassInfo, /) -> bool: ...
+def len(obj: Sized,astt ,/, z: int, j: str,a= 90) -> int: ...

jaclang/tests/fixtures/run_test.jac

@@ -1,17 +1,17 @@
 glob a = 5, b = 2;
 
 test t1 {
-    check almostEqual(a, 6);
+    assert almostEqual(a, 6);
 }
 
 test t2 {
-    check a != b;
+    assert a != b;
 }
 
 test t3 {
-    check "d" in "abc";
+    assert "d" in "abc";
 }
 
 test t4 {
-    check a - b == 3;
+    assert a - b == 3;
 }

jaclang/tests/test_cli.py

@@ -7,6 +7,7 @@ import os
 import re
 import subprocess
 import sys
+import tempfile
 import traceback
 import unittest
 from jaclang.cli import cli
@@ -65,7 +66,9 @@ class JacCliTests(TestCase):
         self.assertIn("Hello Peter Peter", stdout_value)
         self.assertIn("Peter squared is Peter Peter", stdout_value)
         self.assertIn("PETER!  wrong poem", stdout_value)
-        self.assertIn("Hello Peter , yoo mother is Mary. Myself, I am Peter.", stdout_value)
+        self.assertIn(
+            "Hello Peter , yoo mother is Mary. Myself, I am Peter.", stdout_value
+        )
         self.assertIn("Left aligned: Apple | Price: 1.23", stdout_value)
         self.assertIn("name = Peter 🤔", stdout_value)
 
@@ -205,19 +208,6 @@ class JacCliTests(TestCase):
         self.assertIn("Sub objects.", stdout_value)
         self.assertGreater(stdout_value.count("def exit_"), 10)
 
-    def test_jac_cmd_line(self) -> None:
-        """Basic test for pass."""
-        process = subprocess.Popen(
-            ["jac"],
-            stdin=subprocess.PIPE,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-        )
-        stdout_value, _ = process.communicate(input="exit\n")
-        self.assertEqual(process.returncode, 0, "Process did not exit successfully")
-        self.assertIn("Welcome to the Jac CLI!", stdout_value)
-
     def test_ast_print(self) -> None:
         """Testing for print AstTool."""
         captured_output = io.StringIO()
@@ -270,7 +260,7 @@ class JacCliTests(TestCase):
             '[label="MultiString" shape="oval" style="filled" fillcolor="#fccca4"]',
             stdout_value,
         )
-    
+
     def test_cfg_printgraph(self) -> None:
         """Testing for print CFG."""
         captured_output = io.StringIO()
@@ -282,8 +272,8 @@ class JacCliTests(TestCase):
         stdout_value = captured_output.getvalue()
         correct_graph = (
             "digraph G {\n"
-            '  0 [label="BB0\\n\\nprint ( \\"im still here\\" ) ;\", shape=box];\n'
-            '  1 [label="BB1\\n\\"Hello World!\\" |> print ;\", shape=box];\n'
+            '  0 [label="BB0\\n\\nprint ( \\"im still here\\" ) ;", shape=box];\n'
+            '  1 [label="BB1\\n\\"Hello World!\\" |> print ;", shape=box];\n'
             "}\n\n"
         )
 
@@ -415,6 +405,69 @@ class JacCliTests(TestCase):
         self.assertIn("class MyClass {", stdout_value)
         self.assertIn('"""Print function."""', stdout_value)
 
+    def test_lambda_arg_annotation(self) -> None:
+        """Test for lambda argument annotation."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        cli.jac2py(
+            f"{self.fixture_abs_path('../../tests/fixtures/lambda_arg_annotation.jac')}"
+        )
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        self.assertIn("x = lambda a, b: b + a", stdout_value)
+        self.assertIn("y = lambda: 567", stdout_value)
+        self.assertIn("f = lambda x: 'even' if x % 2 == 0 else 'odd'", stdout_value)
+
+    def test_lambda_self(self) -> None:
+        """Test for lambda argument annotation."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        cli.jac2py(f"{self.fixture_abs_path('../../tests/fixtures/lambda_self.jac')}")
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        self.assertIn("def travel(self, here: City) -> None:", stdout_value)
+        self.assertIn("def foo(a: int) -> None:", stdout_value)
+        self.assertIn("x = lambda a, b: b + a", stdout_value)
+        self.assertIn("def visit_city(self, c: City) -> None:", stdout_value)
+        self.assertIn(
+            "sorted(users, key=lambda x: x['email'], reverse=True)", stdout_value
+        )
+
+    def test_param_arg(self) -> None:
+        """Test for lambda argument annotation."""
+        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')}")
+        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:
+            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()
+            # Create temporary Jac 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)
+        
+        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])
+        self.assertEqual("ULTIMATE_FULL: 1|custom|3.14|3|req|200|1", stdout_value[-6])
+        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])
+
     def test_caching_issue(self) -> None:
         """Test for Caching Issue."""
         test_file = self.fixture_abs_path("test_caching_issue.jac")
@@ -424,7 +477,7 @@ class JacCliTests(TestCase):
                 f.write(
                     f"""
                 test mytest{{
-                    check 10 == {x};
+                    assert 10 == {x};
                 }}
                 """
                 )
@@ -560,3 +613,35 @@ class JacCliTests(TestCase):
         stdout, stderr = process.communicate()
         self.assertIn("Hello, World!", stdout)
         self.assertIn("Sum: 8", stdout)
+
+    def test_jac_run_py_bugs(self) -> None:
+        """Test jac run python files."""
+        process = subprocess.Popen(
+            [
+                "jac",
+                "run",
+                self.fixture_abs_path("jac_run_py_bugs.py"),
+            ],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        stdout, stderr = process.communicate()
+        self.assertIn("Hello, my name is Alice and I am 30 years old.", stdout)
+        self.assertIn("MyModule initialized!", stdout)
+
+    def test_cli_defaults_to_run_with_file(self) -> None:
+        """jac myfile.jac should behave like jac run myfile.jac."""
+        process = subprocess.Popen(
+            [
+                "jac",
+                self.fixture_abs_path("hello.jac"),
+            ],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        stdout, stderr = process.communicate()
+        self.assertIn("Hello World!", stdout)