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

jaclang/tests/fixtures/chandra_bugs2.jac

@@ -1,14 +1,14 @@
 import re;
 
 
-glob a : int = 5;
+glob a: int = 5;
 
 
 with entry {
     arguments = { x : None for x in re.findall(r'\{([A-Za-z0-9_]+)\}', "Apple {apple} pineapple {pineapple}") };
-    a : int = 5;
+    a: int = 5;
     if False {
-        with open(f"Apple{apple}.txt") as f {
+        with open(f"Apple{apple}.txt") as f  {
             # Fix syntax highlighting
             print(
                 f.read()

jaclang/tests/fixtures/create_dynamic_archetype.jac

@@ -2,23 +2,23 @@ import from jaclang.runtimelib.machine { JacMachine }
 # Dynamically create a node archetype
  glob source_code =
     """
-    node dynamic_node {
-    has value:int;
-    can print_value with entry {
-    print("Dynamic Node Value:", f'{self.value}');
-    }
-    }
-    """;
+node dynamic_node {
+has value:int;
+can print_value with entry {
+print("Dynamic Node Value:", f'{self.value}');
+}
+}
+""";
 
 # Create a new walker archetype dynamically
  glob walker_code =
     """
-    walker dynamic_walker {
-    can visit_nodes with entry {
-    visit [-->];
-    }
-    }
-    """;
+walker dynamic_walker {
+can visit_nodes with entry {
+visit [-->];
+}
+}
+""";
 
 
 with entry {

jaclang/tests/fixtures/maxfail_run_test.jac

@@ -1,17 +1,17 @@
 glob x = 5, y = 2;
 
 test a {
-    check almostEqual(5, x);
+    assert almostEqual(5, x);
 }
 
 test b {
-    check "l" in "llm";
+    assert "l" in "llm";
 }
 
 test c {
-    check x - y == 3;
+    assert x - y == 3;
 }
 
 test d {
-    check 1 == 2;
+    assert 1 == 2;
 }

jaclang/tests/fixtures/params/param_syntax_err.jac

@@ -0,0 +1,9 @@
+
+
+def foo(a:int,/,/){}
+def foo(a:int,/,*,*){}
+def foo(a:int,/,*,**kwargs:int,*){}
+def foo(a:int,/,*,**kwargs:int,*){}
+def foo(a:int,/,*,**kwargs:int,/){}
+def foo(a:int,/,*,**kwargs:int,/){}
+def foo(a:int,/,*,/,**kwargs:int,/){}

jaclang/tests/fixtures/params/test_complex_params.jac

@@ -0,0 +1,42 @@
+# Test complex parameter combinations
+
+def ultimate_signature(
+    pos_only: int,
+    pos_def: str = "def",
+    /,
+    reg_def: bool = True,
+    *args: int,
+    kw_req: str,
+    kw_opt: int = 100,
+    **kwargs: any
+) -> str {
+    return f"{pos_only}|{pos_def}|{reg_def}|{len(args)}|{kw_req}|{kw_opt}|{len(kwargs)}";
+}
+
+def separators_only(/, *, x: int) -> int {
+    return x;
+}
+
+def edge_case_mix(a: int, /, b: str, *args: float, c: bool, **kwargs: str) -> str {
+    return f"{a}-{b}-{len(args)}-{c}-{len(kwargs)}";
+}
+
+def recursive_test(data: int, /, depth: int = 0, *, max_depth: int = 2) -> int {
+    if depth >= max_depth {
+        return data;
+    }
+    return recursive_test(data + 1, depth + 1, max_depth=max_depth);
+}
+
+def validation_test(x: int, y: str = "test", /, z: float, *args: int, w: bool, **kwargs: str) -> str {
+    return f"x:{x},y:{y},z:{z},args:{len(args)},w:{w},kwargs:{len(kwargs)}";
+}
+
+with entry {
+    print("ULTIMATE_MIN:", ultimate_signature(1, reg_def=2.5, kw_req="test"));
+    print("ULTIMATE_FULL:", ultimate_signature(1, "custom", 3.14, False, 10, 20, kw_req="req", kw_opt=200, extra="data"));
+    print("SEPARATORS:", separators_only(x=42));
+    print("EDGE_MIX:", edge_case_mix(1, "test", 1.1, 2.2, c=True, name="edge"));
+    print("RECURSIVE:", recursive_test(5), recursive_test(10, max_depth=1));
+    print("VALIDATION:", validation_test(1, 2.5, 10, 20, w=True, debug="on"));
+}

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");
+    }
+}