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

jaclang/tests/fixtures/params/test_failing_kwonly.jac

@@ -0,0 +1,207 @@
+# Test failing keyword-only parameter cases
+
+def strict_kwonly(*, x: int, y: str) -> str {
+    return f"{x}: {y}";
+}
+
+def kwonly_with_defaults(*, req: int, opt: str = "default") -> str {
+    return f"{req}-{opt}";
+}
+
+def mixed_kwonly(a: int, *, kw1: str, kw2: bool = False) -> dict {
+    return {"a": a, "kw1": kw1, "kw2": kw2};
+}
+
+def complex_kwonly(pos: int, /, reg: str, *args: float, kw_req: bool, kw_opt: int = 10, **kwargs: any) -> dict {
+    return {"pos": pos, "reg": reg, "args": list(args), "kw_req": kw_req, "kw_opt": kw_opt, "kwargs": kwargs};
+}
+
+def only_star_separator(*, x: int) -> int {
+    return x * 2;
+}
+
+def nested_kwonly_issues(*, outer: dict, inner: list = []) -> int {
+    return len(outer) + len(inner);
+}
+
+with entry {
+    print("=== TESTING KEYWORD-ONLY FAILURES ===");
+    
+    # Test 1: Calling kw-only with positional arguments
+    try {
+        result = strict_kwonly(42, "test");
+        print("❌ FAIL: Should reject positional for kw-only");
+    } except Exception as e {
+        print("✅ PASS: Caught kw-only positional error:", type(e).__name__);
+    }
+    
+    # Test 2: Missing required keyword-only argument
+    try {
+        result = strict_kwonly(x=42);
+        print("❌ FAIL: Should reject missing required kw-only");
+    } except Exception as e {
+        print("✅ PASS: Caught missing kw-only error:", type(e).__name__);
+    }
+    
+    # Test 3: Missing required in defaults mix
+    try {
+        result = kwonly_with_defaults(opt="custom");
+        print("❌ FAIL: Should reject missing required kw-only");
+    } except Exception as e {
+        print("✅ PASS: Caught missing required in defaults:", type(e).__name__);
+    }
+    
+    # Test 4: Extra unknown keyword arguments (without **kwargs)
+    try {
+        result = strict_kwonly(x=42, y="test", extra="unknown");
+        print("❌ FAIL: Should reject unknown keyword");
+    } except Exception as e {
+        print("✅ PASS: Caught unknown keyword error:", type(e).__name__);
+    }
+    
+    # Test 5: Mixed signature - wrong positional count
+    try {
+        result = mixed_kwonly(1, 2, kw1="test");
+        print("❌ FAIL: Should reject too many positional");
+    } except Exception as e {
+        print("✅ PASS: Caught too many positional error:", type(e).__name__);
+    }
+    
+    # Test 6: Mixed signature - missing kw-only required
+    try {
+        result = mixed_kwonly(42);
+        print("❌ FAIL: Should reject missing kw-only in mixed");
+    } except Exception as e {
+        print("✅ PASS: Caught missing kw-only in mixed:", type(e).__name__);
+    }
+    
+    # Test 7: Complex signature - kw-only as positional
+    try {
+        result = complex_kwonly(1, "reg", 1.5, True);
+        print("❌ FAIL: Should reject kw-only as positional");
+    } except Exception as e {
+        print("✅ PASS: Caught kw-only as positional error:", type(e).__name__);
+    }
+    
+    # Test 8: Complex signature - missing required kw-only
+    try {
+        result = complex_kwonly(1, "reg", 1.5, 2.5);
+        print("❌ FAIL: Should reject missing kw-only in complex");
+    } except Exception as e {
+        print("✅ PASS: Caught missing kw-only in complex:", type(e).__name__);
+    }
+    
+    # Test 9: Only star separator - positional call
+    try {
+        result = only_star_separator(42);
+        print("❌ FAIL: Should reject positional for star-only");
+    } except Exception as e {
+        print("✅ PASS: Caught star-only positional error:", type(e).__name__);
+    }
+    
+    
+    # Test 11: Mutable default issues
+    try {
+        result1 = nested_kwonly_issues(outer={"a": 1});
+        result2 = nested_kwonly_issues(outer={"b": 2});
+        print("✅ INFO: Mutable defaults - result1:", result1, "result2:", result2);
+    } except Exception as e {
+        print("❌ FAIL: Mutable defaults caused error:", type(e).__name__);
+    }
+    
+    # Test 12: Valid calls that should work
+    try {
+        result = strict_kwonly(x=42, y="valid");
+        print("✅ PASS: Valid kw-only call:", result);
+    } except Exception as e {
+        print("❌ FAIL: Valid kw-only call rejected:", type(e).__name__);
+    }
+    
+    try {
+        result = kwonly_with_defaults(req=100);
+        print("✅ PASS: Valid kw-only with defaults:", result);
+    } except Exception as e {
+        print("❌ FAIL: Valid defaults call rejected:", type(e).__name__);
+    }
+    
+    try {
+        result = mixed_kwonly(5, kw1="test");
+        print("✅ PASS: Valid mixed kw-only:", result);
+    } except Exception as e {
+        print("❌ FAIL: Valid mixed call rejected:", type(e).__name__);
+    }
+}
+
+def additional_kwonly_edge_cases() -> None {
+    print("\n=== ADDITIONAL KEYWORD-ONLY EDGE CASES ===");
+    
+    # Test 14: Keyword argument name conflicts with Python keywords
+    def python_keyword_conflicts(*, class_name: str, import_path: str = "default") -> str {
+        return f"{class_name}: {import_path}";
+    }
+    
+    try {
+        result = python_keyword_conflicts(class_name="TestClass");
+        print("✅ PASS: Python keyword as param name:", result);
+    } except Exception as e {
+        print("❌ FAIL: Python keyword param failed:", type(e).__name__);
+    }
+    
+    # Test 15: Very long keyword-only parameter lists
+    def many_kwonly_params(
+        *,
+        p1: int, p2: int, p3: int, p4: int, p5: int,
+        p6: str = "d6", p7: str = "d7", p8: str = "d8"
+    ) -> dict {
+        return {"sum": p1+p2+p3+p4+p5, "strings": [p6, p7, p8]};
+    }
+    
+    try {
+        result = many_kwonly_params(p1=1, p2=2, p3=3, p4=4, p5=5);
+        print("✅ PASS: Many kw-only params:", result);
+    } except Exception as e {
+        print("❌ FAIL: Many kw-only params failed:", type(e).__name__);
+    }
+    
+    # Test 16: Nested function calls as keyword arguments
+    def helper_func() -> str {
+        return "helper_result";
+    }
+    
+    def kwonly_with_function_calls(*, data: str, processed: bool = True) -> str {
+        return f"data={data}, processed={processed}";
+    }
+    
+    try {
+        result = kwonly_with_function_calls(data=helper_func(), processed=False);
+        print("✅ PASS: Function calls as kw args:", result);
+    } except Exception as e {
+        print("❌ FAIL: Function calls as kw args failed:", type(e).__name__);
+    }
+    
+    # Test 17: Empty string and special values
+    try {
+        result = strict_kwonly(x=0, y="");
+        print("✅ PASS: Edge values (0, empty string):", result);
+    } except Exception as e {
+        print("❌ FAIL: Edge values failed:", type(e).__name__);
+    }
+    
+    # Test 18: Really test duplicate keyword detection properly
+    # Note: This might not be detectable at runtime in some languages
+    def test_duplicate_detection() -> None {
+        try {
+            # This should be a syntax error, but let's see what happens
+            call_string = "strict_kwonly(x=42, y='test', x=99)";
+            print("INFO: Would test duplicate keywords, but this is syntax-level");
+        } except Exception as e {
+            print("✅ PASS: Duplicate detection works:", type(e).__name__);
+        }
+    }
+    
+    test_duplicate_detection();
+}
+
+with entry {
+    additional_kwonly_edge_cases();
+}

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;
 }