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

jaclang/compiler/passes/ecmascript/tests/__init__.py

@@ -0,0 +1 @@
+"""Tests for ECMAScript AST generation."""

jaclang/compiler/passes/ecmascript/tests/fixtures/advanced_language_features.jac

@@ -0,0 +1,170 @@
+"""Advanced Jac constructs combined fixture for ECMAScript generator tests."""
+
+# Lambdas and higher-order helpers
+def lambda_examples() -> dict {
+    adder = lambda a: int, b: int : a + b;
+    scaler = lambda value: int, factor: int : value * factor;
+    numbers = [1, 2, 3, 4];
+    doubled = [scaler(n, 2) for n in numbers];
+    filtered = [n for n in numbers if (keep := n % 2 == 0)];
+    return {
+        "sum": adder(2, 5),
+        "doubled": doubled,
+        "filtered": filtered
+    };
+}
+
+# Async / await usage
+async def fetch_value(value: int) -> int {
+    return value;
+}
+
+async def async_pipeline(data: list) -> dict {
+    total = 0;
+    results = [];
+    for item in data {
+        response = await fetch_value(item);
+        total += response;
+        results.append(response);
+    }
+    status = "large" if total > 10 else "small";
+    return {"total": total, "results": results, "status": status};
+}
+
+# Generators
+def generator_examples(limit: int) {
+    index = 0;
+    while index < limit {
+        yield index * 3;
+        index += 1;
+    }
+}
+
+# Spread and rest patterns
+def spread_and_rest_examples() -> dict {
+    base = [1, 2, 3];
+    extras = [4, 5];
+    combined = [*base, *extras, 6];
+
+    defaults = {"mode": "dev", "retries": 1};
+    overrides = {"retries": 3, "timeout": 30};
+    merged = {**defaults, **overrides};
+
+    def collect(label: str, *items: tuple, **options: dict) -> dict {
+        return {"label": label, "items": list(items), "options": options};
+    }
+
+    bag = collect("demo", *combined, limit=10, strict=True);
+    return {"combined": combined, "merged": merged, "bag": bag};
+}
+
+# Pattern matching / switch lowering
+def pattern_matching_examples(code: int, flag: bool) -> str {
+    match code {
+        case 200:
+            return "ok";
+
+        case 404 | 500:
+            return "error";
+
+        case _:
+            if flag {
+                return "fallback";
+            }
+            return "unknown";
+
+        }
+}
+
+# Template literals and complex expressions
+def template_literal_examples(user: str, score: int) -> str {
+    status = "pass" if score >= 60 else "fail";
+    return f"{user} scored {score} which is a {status}";
+}
+
+# Destructuring & rest patterns
+def advanced_destructuring() -> dict {
+    (first, *middle, last) = [10, 20, 30, 40, 50];
+    point = (100, 200);
+    (x, y) = point;
+    settings = {"limits": {"max": 5}};
+    limit = 0;
+    if settings is not None and "limits" in settings {
+        inner = settings["limits"];
+        if inner is not None and "max" in inner {
+            limit = inner["max"];
+        }
+    }
+    return {"first": first, "middle": middle, "last": last, "point": (x, y), "limit": limit};
+}
+
+# Optional access simulations
+def optional_access_examples(payload: dict) -> dict {
+    result = {"value": 0, "mode": "basic"};
+    if payload is not None and "config" in payload {
+        config = payload["config"];
+        if config is not None and "value" in config {
+            result["value"] = config["value"];
+        }
+        if config is not None and "mode" in config {
+            result["mode"] = config["mode"];
+        }
+    }
+    return result;
+}
+
+# Update expression stand-ins
+def update_expression_examples() -> dict {
+    counter = 0;
+    for _ in range(5) {
+        counter += 1;
+    }
+
+    index = 3;
+    index -= 1;
+    return {"counter": counter, "index": index};
+}
+
+# Do-while style loops
+def do_while_simulation(limit: int) -> int {
+    total = 0;
+    current = 0;
+    while True {
+        total += current;
+        current += 1;
+        if not (current < limit) {
+            break;
+        }
+    }
+    return total;
+}
+
+# Combined advanced report
+def build_advanced_report(values: list) -> dict {
+    lambda_data = lambda_examples();
+    spread_data = spread_and_rest_examples();
+    optional = optional_access_examples({"config": {"value": 7, "mode": "strict"}});
+    destructured = advanced_destructuring();
+
+    async def gather_async() -> dict {
+        return await async_pipeline(values);
+    }
+
+    generator_list = [];
+    for item in generator_examples(len(values)) {
+        generator_list.append(item);
+    }
+
+    return {
+        "lambda": lambda_data,
+        "spread": spread_data,
+        "optional": optional,
+        "destructured": destructured,
+        "pattern": pattern_matching_examples(404, False),
+        "template": template_literal_examples("user", 72),
+        "updates": update_expression_examples(),
+        "loop": do_while_simulation(4),
+        "generator": generator_list,
+        "async_helper": gather_async
+    };
+}

jaclang/compiler/passes/ecmascript/tests/fixtures/class_separate_impl.impl.jac

@@ -0,0 +1,30 @@
+"""Implementation file for Calculator classes."""
+
+impl Calculator.init(initial_value: float) {
+    self.value = initial_value;
+}
+
+impl Calculator.add(amount: float) -> float {
+    self.value = self.value + amount;
+    return self.value;
+}
+
+impl Calculator.multiply(factor: float) -> float {
+    self.value = self.value * factor;
+    return self.value;
+}
+
+impl Calculator.get_value -> float {
+    return self.value;
+}
+
+impl ScientificCalculator.power(exponent: float) -> float {
+    result = self.value;
+    count = 1;
+    while count < exponent {
+        result = result * self.value;
+        count = count + 1;
+    }
+    self.value = result;
+    return self.value;
+}

jaclang/compiler/passes/ecmascript/tests/fixtures/class_separate_impl.jac

@@ -0,0 +1,14 @@
+"""Test fixture for class with separate impl file."""
+
+obj Calculator {
+    has value: float;
+
+    def init(initial_value: float);
+    def add(amount: float) -> float;
+    def multiply(factor: float) -> float;
+    def get_value -> float;
+}
+
+obj ScientificCalculator(Calculator) {
+    def power(exponent: float) -> float;
+}

jaclang/compiler/passes/ecmascript/tests/fixtures/client_jsx.jac

@@ -0,0 +1,89 @@
+"""Combined JSX fixture covering client declarations and varied JSX patterns."""
+
+cl let API_URL: str = "https://api.example.com";
+
+cl obj ButtonProps {
+    has label: str = "Hello";
+    has count: int = 0;
+}
+
+cl def component() {
+    return <div class="box">
+        <h1>Hello</h1>
+        <p>Welcome!</p>
+    </div>;
+}
+
+def server_only() {
+    return "not included";
+}
+
+with entry {
+    # Common values used across scenarios
+    let name = "World";
+    let age = 30;
+    let count = 42;
+    let props = "dummy_props";
+    let extraProps = "extra_props";
+
+    # Basic JSX shapes
+    let basic_div = <div />;
+    let basic_component = <MyComponent />;
+    let attribute_button = <button id="submit" disabled />;
+    let attr_with_expr = <div id={name} data-age={age}>User Info</div>;
+
+    # Expressions embedded in JSX
+    let greeting = <h1>{"Hello " + name + "!"}</h1>;
+    let button = <button id={name} count={count}>{"Click"}</button>;
+    let computed = <div>{count + 10}</div>;
+
+    # Nested elements and layout
+    let card = <div>
+        <h1>{"Title"}</h1>
+        <p>{"Description"}</p>
+        <button>{"Click"}</button>
+    </div>;
+
+    let layout = <div>
+        <header>
+            <nav>
+                <a>{"Home"}</a>
+                <a>{"About"}</a>
+            </nav>
+        </header>
+        <main>
+            <article>{"Content here"}</article>
+        </main>
+    </div>;
+
+    # Components and namespaces
+    let comp_props = <Button color="blue" size="large">Submit</Button>;
+    let comp_namespaced = <UI.Button />;
+    let comp_deep_namespace = <Form.Input.Text />;
+    let app = <App>
+        <Header />
+        <Main>
+            <Sidebar />
+            <Content />
+        </Main>
+        <Footer />
+    </App>;
+
+    # Fragments
+    let empty_fragment = <></>;
+    let fragment_with_children = <>
+        <h1>{"Title"}</h1>
+        <p>{"Paragraph"}</p>
+    </>;
+    let mixed_fragment = <>
+        {"Some text"}
+        <div>{"Element"}</div>
+        {"More text"}
+        <span>{"Inline"}</span>
+    </>;
+
+    # Spread attributes
+    let spread_div = <div {...props} />;
+    let spread_button = <button {...props} {...extraProps}>{"Click"}</button>;
+    let spread_input = <input type="text" {...props} disabled />;
+}

jaclang/compiler/passes/ecmascript/tests/fixtures/core_language_features.jac

@@ -0,0 +1,195 @@
+"""Combined core Jac constructs for ECMAScript generator tests."""
+
+let global_counter: int = 0;
+
+# Basic functions and control flow
+def add(a: int, b: int) -> int {
+    return a + b;
+}
+
+def greet(name: str = "World") -> str {
+    return "Hello, " + name;
+}
+
+def classify_number(value: int) -> str {
+    if value < 0 {
+        return "negative";
+    } elif value == 0 {
+        return "zero";
+    }
+    return "positive";
+}
+
+def fibonacci(n: int) -> int {
+    if n <= 1 {
+        return n;
+    }
+    return fibonacci(n - 1) + fibonacci(n - 2);
+}
+
+def loop_examples(limit: int) -> int {
+    total = 0;
+    for i in range(limit) {
+        if i % 2 == 0 {
+            total += i;
+            continue;
+        }
+        total += i * 2;
+    }
+
+    counter = limit;
+    while counter > 0 {
+        total -= 1;
+        counter -= 1;
+    }
+    return total;
+}
+
+# Data structures and assignments
+def collection_examples() -> dict {
+    numbers = [1, 2, 3, 4];
+    person = {"name": "Alice", "age": 30};
+    matrix = [[1, 2], [3, 4]];
+    history = {"first": numbers[0], "last": numbers[-1]};
+    return {
+        "numbers": numbers,
+        "person": person,
+        "matrix": matrix,
+        "history": history
+    };
+}
+
+def destructuring_examples() -> dict {
+    (x, y) = (10, 20);
+    [a, b, c] = [1, 2, 3];
+    (head, *tail) = [5, 6, 7, 8];
+    result = (size := len(tail)) + x + y + a + b + c;
+    return {
+        "tuple": (x, y),
+        "list": [a, b, c],
+        "tail": tail,
+        "result": result,
+        "size": size
+    };
+}
+
+def assignment_examples(value: int) -> dict {
+    current = value;
+    current += 5;
+    current -= 2;
+    current *= 3;
+    current /= 2;
+    parity = (status := current % 2);
+    return {"current": current, "status": status, "parity": parity};
+}
+
+# Exception handling
+def safe_division(a: int, b: int) -> float {
+    global global_counter;
+    try {
+        return a / b;
+    } except ZeroDivisionError as err {
+        global_counter += 1;
+        return 0.0;
+    } finally {
+        global_counter += 1;
+    }
+}
+
+# Boolean and comparison helpers
+def compare_values(x: int, y: int) -> dict {
+    return {
+        "lt": x < y,
+        "le": x <= y,
+        "eq": x == y,
+        "ne": x != y,
+        "ge": x >= y,
+        "gt": x > y,
+        "logic": (x < y and y < 100) or not (x == y)
+    };
+}
+
+# Object definitions
+obj Person {
+    has name: str;
+    has age: int = 0;
+
+    def describe -> str {
+        return self.name + " (" + str(self.age) + ")";
+    }
+}
+
+obj Employee(Person) {
+    has role: str = "Engineer";
+
+    def describe -> str {
+        return self.name + " - " + self.role;
+    }
+}
+
+obj Calculator {
+    has value: float = 0.0;
+
+    def add(x: float) -> float {
+        self.value += x;
+        return self.value;
+    }
+
+    def subtract(x: float) -> float {
+        self.value -= x;
+        return self.value;
+    }
+
+    def reset {
+        self.value = 0.0;
+    }
+}
+
+obj MathUtils {
+    static def square(x: int) -> int {
+        return x * x;
+    }
+}
+
+# Enumerations
+enum Status {
+    ACTIVE = "active",
+    INACTIVE = "inactive",
+    PENDING = "pending"
+}
+
+enum Priority {
+    LOW = 1,
+    MEDIUM = 2,
+    HIGH = 3
+}
+
+def summarize_status() -> dict {
+    states = [Status.ACTIVE, Status.PENDING];
+    return {
+        "first": states[0],
+        "count": len(states),
+        "names": ["ACTIVE", "PENDING"]
+    };
+}
+
+# Utility demonstrating combined features
+def build_report(data: list) -> dict {
+    processed = [];
+    for item in data {
+        if item is None {
+            continue;
+        }
+        processed.append(item * 2);
+    }
+
+    info = collection_examples();
+    stats = compare_values(len(processed), len(info["numbers"]));
+
+    return {
+        "processed": processed,
+        "info": info,
+        "stats": stats,
+        "summary": summarize_status()
+    };
+}

jaclang/compiler/passes/ecmascript/tests/test_esast_gen_pass.py

@@ -0,0 +1,167 @@
+"""Test ECMAScript AST generation using consolidated Jac fixtures."""
+
+import json
+from pathlib import Path
+from typing import Iterable
+
+from jaclang.compiler.passes.ecmascript import EsastGenPass, es_node_to_dict
+from jaclang.compiler.passes.ecmascript import estree as es
+from jaclang.compiler.passes.ecmascript.es_unparse import es_to_js
+from jaclang.compiler.program import JacProgram
+from jaclang.utils.test import TestCase
+
+
+def walk_es_nodes(node: es.Node) -> Iterable[es.Node]:
+    """Yield every ESTree node in a depth-first traversal."""
+    yield node
+    for value in vars(node).values():
+        if isinstance(value, es.Node):
+            yield from walk_es_nodes(value)
+        elif isinstance(value, list):
+            for item in value:
+                if isinstance(item, es.Node):
+                    yield from walk_es_nodes(item)
+
+
+class EsastGenPassTests(TestCase):
+    """Validate ECMAScript AST output from consolidated fixtures."""
+
+    CORE_FIXTURE = "core_language_features.jac"
+    ADVANCED_FIXTURE = "advanced_language_features.jac"
+    CLIENT_FIXTURE = "client_jsx.jac"
+
+    TargetPass = EsastGenPass
+
+    def get_fixture_path(self, filename: str) -> str:
+        """Return absolute path to a fixture file."""
+        fixtures_dir = Path(__file__).parent / "fixtures"
+        return str(fixtures_dir / filename)
+
+    def compile_to_esast(self, filename: str) -> es.Program:
+        """Compile Jac source to an ESTree program."""
+        prog = JacProgram()
+        ir = prog.compile(file_path=filename, no_cgen=True)
+
+        self.assertFalse(
+            prog.errors_had,
+            f"Compilation errors in {filename}: {[str(e) for e in prog.errors_had]}",
+        )
+
+        es_pass = EsastGenPass(ir, prog)
+        es_ir = es_pass.ir_out
+
+        self.assertTrue(hasattr(es_ir.gen, "es_ast"), "es_ast attribute missing")
+        self.assertIsInstance(es_ir.gen.es_ast, es.Program)
+        return es_ir.gen.es_ast
+
+    def test_core_fixture_ast_shape(self) -> None:
+        """Core fixture should expose fundamental declarations in the ESTree."""
+        es_ast = self.compile_to_esast(self.get_fixture_path(self.CORE_FIXTURE))
+
+        func_decls = [
+            node for node in es_ast.body if isinstance(node, es.FunctionDeclaration)
+        ]
+        func_names = {func.id.name for func in func_decls if func.id}
+        self.assertTrue({"add", "greet", "fibonacci"}.issubset(func_names))
+
+        class_decls = [
+            node for node in es_ast.body if isinstance(node, es.ClassDeclaration)
+        ]
+        class_names = {cls.id.name for cls in class_decls if cls.id}
+        self.assertIn("Person", class_names)
+        self.assertIn("Employee", class_names)
+
+        var_decls = [
+            node for node in es_ast.body if isinstance(node, es.VariableDeclaration)
+        ]
+        self.assertGreaterEqual(len(var_decls), 2, "Expected const enums and globals")
+
+        ast_json = json.dumps(es_node_to_dict(es_ast))
+        self.assertIn("TryStatement", ast_json, "Expected try/except in core fixture")
+        self.assertIn(
+            "BinaryExpression",
+            ast_json,
+            "Binary expressions should appear in core fixture",
+        )
+
+    def test_advanced_fixture_contains_async_and_spread_nodes(self) -> None:
+        """Advanced fixture should surface async, await, and spread constructs."""
+        es_ast = self.compile_to_esast(self.get_fixture_path(self.ADVANCED_FIXTURE))
+
+        func_names = {
+            node.id.name
+            for node in es_ast.body
+            if isinstance(node, es.FunctionDeclaration) and node.id
+        }
+        self.assertIn("lambda_examples", func_names)
+        self.assertIn("build_advanced_report", func_names)
+
+        node_types = {type(node).__name__ for node in walk_es_nodes(es_ast)}
+        self.assertIn("AwaitExpression", node_types)
+        self.assertIn("SpreadElement", node_types)
+        self.assertIn("ConditionalExpression", node_types)
+
+        ast_json = json.dumps(es_node_to_dict(es_ast))
+        self.assertIn("CallExpression", ast_json)
+        self.assertIn("ReturnStatement", ast_json)
+
+    def test_client_fixture_generates_client_bundle(self) -> None:
+        """Client fixture should retain JSX lowering behaviour."""
+        es_ast = self.compile_to_esast(self.get_fixture_path(self.CLIENT_FIXTURE))
+        js_code = es_to_js(es_ast)
+
+        self.assertIn(
+            'const API_URL = "https://api.example.com";',
+            js_code,
+            "Client global should remain const.",
+        )
+        self.assertIn("function component()", js_code)
+        self.assertIn("__jacJsx", js_code)
+        self.assertNotIn("server_only", js_code)
+
+    def test_es_ast_serializes_to_json(self) -> None:
+        """ESTree should serialize cleanly to JSON for downstream tooling."""
+        es_ast = self.compile_to_esast(self.get_fixture_path(self.CORE_FIXTURE))
+        ast_dict = es_node_to_dict(es_ast)
+
+        serialized = json.dumps(ast_dict)
+        self.assertIn('"type": "Program"', serialized)
+        self.assertGreater(len(serialized), 1000)
+
+    def test_class_separate_impl_file(self) -> None:
+        """Test that separate impl files work correctly for class archetypes."""
+        es_ast = self.compile_to_esast(
+            self.get_fixture_path("class_separate_impl.jac")
+        )
+        js_code = es_to_js(es_ast)
+
+        # Check that the Calculator class exists
+        class_decls = [
+            node for node in es_ast.body if isinstance(node, es.ClassDeclaration)
+        ]
+        class_names = {cls.id.name for cls in class_decls if cls.id}
+        self.assertIn("Calculator", class_names)
+        self.assertIn("ScientificCalculator", class_names)
+
+        # Check that methods from impl file are present
+        calculator_class = next(
+            (cls for cls in class_decls if cls.id and cls.id.name == "Calculator"),
+            None,
+        )
+        self.assertIsNotNone(calculator_class)
+        if calculator_class:
+            method_names = {
+                m.key.name
+                for m in calculator_class.body.body
+                if isinstance(m, es.MethodDefinition) and isinstance(m.key, es.Identifier)
+            }
+            self.assertIn("add", method_names)
+            self.assertIn("multiply", method_names)
+            self.assertIn("get_value", method_names)
+
+        # Check JavaScript output contains the methods
+        self.assertIn("class Calculator", js_code)
+        self.assertIn("class ScientificCalculator", js_code)
+        self.assertIn("add(", js_code)
+        self.assertIn("multiply(", js_code)
+        self.assertIn("power(", js_code)