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

jaclang/compiler/program.py

@@ -5,13 +5,14 @@ from __future__ import annotations
 import ast as py_ast
 import marshal
 import types
+from threading import Event
 from typing import Optional, TYPE_CHECKING
 
 import jaclang.compiler.unitree as uni
 from jaclang.compiler.parser import JacParser
+from jaclang.compiler.passes.ecmascript import EsastGenPass
 from jaclang.compiler.passes.main import (
     Alert,
-    BinderPass,
     CFGBuildPass,
     DeclImplMatchPass,
     DefUsePass,
@@ -34,14 +35,10 @@ from jaclang.compiler.passes.tool import (
 )
 from jaclang.runtimelib.utils import read_file_with_encoding
 from jaclang.settings import settings
-from jaclang.utils.log import logging
 
 if TYPE_CHECKING:
     from jaclang.compiler.type_system.type_evaluator import TypeEvaluator
 
-
-logger = logging.getLogger(__name__)
-
 ir_gen_sched = [
     SymTabBuildPass,
     DeclImplMatchPass,
@@ -53,6 +50,7 @@ type_check_sched: list = [
     TypeCheckPass,
 ]
 py_code_gen = [
+    EsastGenPass,
     PyastGenPass,
     PyJacAstLinkPass,
     PyBytecodeGenPass,
@@ -63,7 +61,10 @@ format_sched = [FuseCommentsPass, DocIRGenPass, JacFormatPass]
 class JacProgram:
     """JacProgram to handle the Jac program-related functionalities."""
 
-    def __init__(self, main_mod: Optional[uni.ProgramModule] = None) -> None:
+    def __init__(
+        self,
+        main_mod: Optional[uni.ProgramModule] = None,
+    ) -> None:
         """Initialize the JacProgram object."""
         self.mod: uni.ProgramModule = main_mod if main_mod else uni.ProgramModule()
         self.py_raise_map: dict[str, str] = {}
@@ -87,7 +88,9 @@ class JacProgram:
         result = self.compile(file_path=full_target)
         return marshal.loads(result.gen.py_bytecode) if result.gen.py_bytecode else None
 
-    def parse_str(self, source_str: str, file_path: str) -> uni.Module:
+    def parse_str(
+        self, source_str: str, file_path: str, cancel_token: Event | None = None
+    ) -> uni.Module:
         """Convert a Jac file to an AST."""
         had_error = False
         if file_path.endswith(".py") or file_path.endswith(".pyi"):
@@ -98,6 +101,7 @@ class JacProgram:
                     orig_src=uni.Source(source_str, mod_path=file_path),
                 ),
                 prog=self,
+                cancel_token=cancel_token,
             )
             had_error = len(py_ast_ret.errors_had) > 0
             mod = py_ast_ret.ir_out
@@ -124,25 +128,23 @@ class JacProgram:
         # options in it.
         no_cgen: bool = False,
         type_check: bool = False,
+        cancel_token: Event | None = None,
     ) -> uni.Module:
         """Convert a Jac file to an AST."""
         keep_str = use_str or read_file_with_encoding(file_path)
-        mod_targ = self.parse_str(keep_str, file_path)
-        self.run_schedule(mod=mod_targ, passes=ir_gen_sched)
+        mod_targ = self.parse_str(keep_str, file_path, cancel_token=cancel_token)
+        self.run_schedule(mod=mod_targ, passes=ir_gen_sched, cancel_token=cancel_token)
         if type_check:
-            self.run_schedule(mod=mod_targ, passes=type_check_sched)
+            self.run_schedule(
+                mod=mod_targ, passes=type_check_sched, cancel_token=cancel_token
+            )
         # If the module has syntax errors, we skip code generation.
         if (not mod_targ.has_syntax_errors) and (not no_cgen):
             if settings.predynamo_pass and PreDynamoPass not in py_code_gen:
                 py_code_gen.insert(0, PreDynamoPass)
-            self.run_schedule(mod=mod_targ, passes=py_code_gen)
-        return mod_targ
-
-    def bind(self, file_path: str, use_str: str | None = None) -> uni.Module:
-        """Bind the Jac module."""
-        keep_str = use_str or read_file_with_encoding(file_path)
-        mod_targ = self.parse_str(keep_str, file_path)
-        BinderPass(ir_in=mod_targ, prog=self)
+            self.run_schedule(
+                mod=mod_targ, passes=py_code_gen, cancel_token=cancel_token
+            )
         return mod_targ
 
     def build(
@@ -159,16 +161,11 @@ class JacProgram:
         self,
         mod: uni.Module,
         passes: list[type[Transform[uni.Module, uni.Module]]],
+        cancel_token: Event | None = None,
     ) -> None:
         """Run the passes on the module."""
-        final_pass: Optional[type[Transform[uni.Module, uni.Module]]] = None
         for current_pass in passes:
-            if current_pass == PyBytecodeGenPass:
-                final_pass = current_pass
-                break
-            current_pass(ir_in=mod, prog=self)  # type: ignore
-        if final_pass:
-            final_pass(mod, prog=self)
+            current_pass(ir_in=mod, prog=self, cancel_token=cancel_token)  # type: ignore
 
     @staticmethod
     def jac_file_formatter(file_path: str) -> str:

jaclang/compiler/tests/test_client_codegen.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from jaclang.compiler.program import JacProgram
+
+
+FIXTURE_DIR = Path(__file__).resolve().parent.parent / "passes" / "ecmascript" / "tests" / "fixtures"
+
+
+def test_js_codegen_generates_js_and_manifest() -> None:
+    fixture = FIXTURE_DIR / "client_jsx.jac"
+    prog = JacProgram()
+    module = prog.compile(str(fixture))
+
+    assert module.gen.js.strip(), "Expected JavaScript output for client declarations"
+    assert "function component" in module.gen.js
+    assert "__jacJsx(" in module.gen.js
+
+    # Client Python code should be omitted in js_only mode
+    assert "def component" not in module.gen.py
+
+    # Metadata should be stored in module.gen.client_manifest
+    assert "__jac_client_manifest__" not in module.gen.py
+    manifest = module.gen.client_manifest
+    assert manifest, "Client manifest should be available in module.gen"
+    assert "component" in manifest.exports
+    assert "ButtonProps" in manifest.exports
+    assert "API_URL" in manifest.globals
+
+    # Module.gen.client_manifest should have the metadata
+    assert "component" in module.gen.client_manifest.exports
+    assert "ButtonProps" in module.gen.client_manifest.exports
+    assert "API_URL" in module.gen.client_manifest.globals
+    assert module.gen.client_manifest.params.get("component", []) == []
+    assert "ButtonProps" not in module.gen.client_manifest.params
+
+
+def test_compilation_skips_python_stubs() -> None:
+    fixture = FIXTURE_DIR / "client_jsx.jac"
+    prog = JacProgram()
+    module = prog.compile(str(fixture))
+
+    assert module.gen.js.strip(), "Expected JavaScript output when emitting both"
+    assert "function component" in module.gen.js
+    assert "__jacJsx(" in module.gen.js
+
+    # Client Python definitions are intentionally omitted
+    assert "def component" not in module.gen.py
+    assert "__jac_client__" not in module.gen.py
+    assert "class ButtonProps" not in module.gen.py
+
+    # Manifest data should be in module.gen.client_manifest
+    assert "__jac_client_manifest__" not in module.gen.py
+    manifest = module.gen.client_manifest
+    assert manifest, "Client manifest should be available in module.gen"
+    assert "component" in manifest.exports
+    assert "ButtonProps" in manifest.exports
+    assert "API_URL" in manifest.globals
+
+    # Module.gen.client_manifest should have the metadata
+    assert "component" in module.gen.client_manifest.exports
+    assert "ButtonProps" in module.gen.client_manifest.exports
+    assert "API_URL" in module.gen.client_manifest.globals
+    assert module.gen.client_manifest.params.get("component", []) == []
+
+
+def test_type_to_typeof_conversion() -> None:
+    """Test that type() calls are converted to typeof in JavaScript."""
+    from tempfile import NamedTemporaryFile
+
+    # Create a temporary test file
+    test_code = '''"""Test type() to typeof conversion."""
+
+cl def check_types() {
+    let x = 42;
+    let y = "hello";
+    let z = True;
+
+    let t1 = type(x);
+    let t2 = type(y);
+    let t3 = type(z);
+    let t4 = type("world");
+
+    return t1;
+}
+'''
+
+    with NamedTemporaryFile(mode='w', suffix='.jac', delete=False) as f:
+        f.write(test_code)
+        f.flush()
+
+        prog = JacProgram()
+        module = prog.compile(f.name)
+
+        assert module.gen.js.strip(), "Expected JavaScript output for client code"
+
+        # Verify type() was converted to typeof
+        assert "typeof" in module.gen.js, "type() should be converted to typeof"
+        assert module.gen.js.count("typeof") == 4, "Should have 4 typeof expressions"
+
+        # Verify no type() calls remain
+        assert "type(" not in module.gen.js, "No type() calls should remain in JavaScript"
+
+        # Verify the typeof expressions are correctly formed
+        assert "typeof x" in module.gen.js
+        assert "typeof y" in module.gen.js
+        assert "typeof z" in module.gen.js
+        assert 'typeof "world"' in module.gen.js
+
+        # Clean up
+        import os
+        os.unlink(f.name)

jaclang/compiler/tests/test_importer.py

@@ -17,6 +17,9 @@ class TestLoader(TestCase):
 
     def test_import_basic_python(self) -> None:
         """Test basic self loading."""
+        Jac.reset_machine()
+        sys.modules.pop("fixtures", None)
+        sys.modules.pop("fixtures.hello_world", None)
         Jac.set_base_path(self.fixture_abs_path(__file__))
         JacMachineInterface.attach_program(
             JacProgram(),
@@ -26,6 +29,9 @@ class TestLoader(TestCase):
 
     def test_modules_correct(self) -> None:
         """Test basic self loading."""
+        Jac.reset_machine()
+        sys.modules.pop("fixtures", None)
+        sys.modules.pop("fixtures.hello_world", None)
         Jac.set_base_path(self.fixture_abs_path(__file__))
         JacMachineInterface.attach_program(
             JacProgram(),
@@ -141,29 +147,25 @@ class TestLoader(TestCase):
         try:
             os.chdir(os.path.dirname(self.fixture_abs_path("jac_import_py_files.py")))
             Jac.set_base_path(self.fixture_abs_path("jac_import_py_files.py"))
-            JacMachineInterface.attach_program(
-            program:=JacProgram(),
-            )
+            JacMachineInterface.attach_program(JacProgram())
             Jac.jac_import("jac_import_py_files", base_path=self.fixture_abs_path("jac_import_py_files.py"), lng="py")
             cli.run(self.fixture_abs_path("jac_import_py_files.py"))
             sys.stdout = sys.__stdout__
             stdout_value = captured_output.getvalue()
             self.assertIn("This is main test file for jac import of python files", stdout_value)
-            self.assertIn("python_module <jaclang.compiler.unitree.Module object", str(program.mod.hub))
-            self.assertIn("jac_module <jaclang.compiler.unitree.Module object", str(program.mod.hub))
+            self.assertIn("python_module <jaclang.compiler.unitree.Module object", str(Jac.program.mod.hub))
+            self.assertIn("jac_module <jaclang.compiler.unitree.Module object", str(Jac.program.mod.hub))
             os.environ["JAC_PYFILE_RAISE"] = "false"
             settings.load_env_vars()
             os.chdir(os.path.dirname(self.fixture_abs_path("jac_import_py_files.py")))
             Jac.set_base_path(self.fixture_abs_path("jac_import_py_files.py"))
-            JacMachineInterface.attach_program(
-            program:=JacProgram(),
-            )
+            JacMachineInterface.attach_program(JacProgram())
             Jac.jac_import("jac_import_py_files", base_path=self.fixture_abs_path("jac_import_py_files.py"), lng="py")
             cli.run(self.fixture_abs_path("jac_import_py_files.py"))
             sys.stdout = sys.__stdout__
             stdout_value = captured_output.getvalue()
             self.assertIn("This is main test file for jac import of python files", stdout_value)
-            self.assertNotIn("python_module <jaclang.compiler.unitree.Module object", str(program.mod.hub))
-            self.assertNotIn("jac_module <jaclang.compiler.unitree.Module object", str(program.mod.hub))
+            self.assertNotIn("python_module <jaclang.compiler.unitree.Module object", str(Jac.program.mod.hub))
+            self.assertIn("jac_module <jaclang.compiler.unitree.Module object", str(Jac.program.mod.hub))
         finally:
             os.chdir(original_cwd)

jaclang/compiler/tests/test_parser.py

@@ -4,6 +4,7 @@ import inspect
 import io
 import os
 import sys
+from pathlib import Path
 
 from jaclang import JacMachineInterface as Jac
 from jaclang.compiler import jac_lark as jl
@@ -215,12 +216,12 @@ class TestLarkParser(TestCaseMicroSuite):
                 }
             """,
             """
-            Missing SEMI
+            Unexpected token 'bar'
+                with entry {
                     foo = Foo(;
                     func(foo bar)
+                             ^^^
                     foo.bar;
-                    ^^^
-                }
             """
         ]
         for idx, alrt in enumerate(prog.errors_had):
@@ -229,4 +230,249 @@ class TestLarkParser(TestCaseMicroSuite):
                 line = line.strip()
                 self.assertIn(line, pretty)
 
+    def _load_combined_jsx_fixture(self) -> tuple[str, JacParser]:
+        """Parse the consolidated JSX fixture once for downstream assertions."""
+        fixture_path = (
+            Path(__file__)
+            .resolve()
+            .parent
+            .parent
+            / "passes"
+            / "ecmascript"
+            / "tests"
+            / "fixtures"
+            / "client_jsx.jac"
+        )
+        source_text = fixture_path.read_text(encoding="utf-8")
+        prse = JacParser(
+            root_ir=Source(source_text, mod_path=str(fixture_path)),
+            prog=JacProgram(),
+        )
+        self.assertFalse(
+            prse.errors_had,
+            f"Parser reported errors for JSX fixture: {[str(e) for e in prse.errors_had]}",
+        )
+        return source_text, prse
+
+    def test_jsx_comprehensive_fixture(self) -> None:
+        """Ensure the consolidated JSX fixture exercises varied grammar shapes."""
+        source_text, prse = self._load_combined_jsx_fixture()
+        tree_repr = prse.ir_out.pp()
+
+        expected_snippets = {
+            "self_closing": "<div />",
+            "attribute_binding": 'id={name}',
+            "namespaced_component": "<Form.Input.Text />",
+            "fragment": "<>",
+            "spread_attribute": "{...props}",
+            "expression_child": '{"Hello " + name + "!"}',
+        }
+        for label, snippet in expected_snippets.items():
+            with self.subTest(label=label):
+                self.assertIn(snippet, source_text)
+
+        ast_markers = {
+            "JsxElement": "JsxElement" in tree_repr,
+            "FragmentTokens": "Token - <>" in tree_repr and "Token - </>" in tree_repr,
+            "JsxSpreadAttribute": "JsxSpreadAttribute" in tree_repr,
+        }
+        for label, present in ast_markers.items():
+            with self.subTest(node=label):
+                self.assertTrue(present, f"{label} missing from AST pretty print")
+
+    def test_client_keyword_tagging(self) -> None:
+        """Test that cl keyword properly tags elements as client declarations.
+
+        Tests:
+        - Single statement with cl prefix
+        - Statement without cl prefix
+        - Block of statements with cl { }
+        - Empty cl blocks
+        - Multiple cl blocks at top level
+        - Various statement types (import, let, obj, test)
+        """
+        # Test 1: Mixed single and block client markers
+        source = """
+cl let foo = 1;
+let bar = 2;
+cl {
+    let baz = 3;
+    test sample {}
+}
+"""
+        module = JacProgram().parse_str(source, "test.jac")
+        body = module.body
+
+        self.assertEqual(
+            [type(stmt).__name__ for stmt in body],
+            ["GlobalVars", "GlobalVars", "GlobalVars", "Test"],
+        )
+        self.assertEqual(
+            [getattr(stmt, "is_client_decl", False) for stmt in body],
+            [True, False, True, True],  # cl let, let, cl{let}, cl{test}
+        )
+
+        # Test 2: Block with different statement types
+        source = """
+cl {
+    import foo;
+    let x = 1;
+    obj MyClass {}
+    test my_test {}
+}
+"""
+        module = JacProgram().parse_str(source, "test.jac")
+        body = module.body
+
+        self.assertEqual(len(body), 4)
+        self.assertTrue(
+            all(
+                getattr(stmt, "is_client_decl", False)
+                for stmt in body
+                if hasattr(stmt, "is_client_decl")
+            )
+        )
+
+        # Test 3: Multiple cl blocks at top level
+        source = """
+cl {
+    let a = 1;
+}
+let b = 2;
+cl {
+    let c = 3;
+}
+"""
+        module = JacProgram().parse_str(source, "test.jac")
+        body = module.body
+
+        self.assertEqual(len(body), 3)
+        self.assertEqual(
+            [getattr(stmt, "is_client_decl", False) for stmt in body],
+            [True, False, True],  # cl{let a}, let b, cl{let c}
+        )
+
+        # Test 4: Empty client block
+        source = """
+cl {}
+let x = 1;
+"""
+        module = JacProgram().parse_str(source, "test.jac")
+        body = module.body
+
+        self.assertEqual(len(body), 1)
+        self.assertFalse(getattr(body[0], "is_client_decl", False))
+
+        # Test 5: Various statement types with single cl marker
+        source = """
+cl import foo;
+cl obj MyClass {}
+cl test my_test {}
+"""
+        module = JacProgram().parse_str(source, "test.jac")
+        body = module.body
+
+        self.assertEqual(len(body), 3)
+        self.assertTrue(
+            all(
+                getattr(stmt, "is_client_decl", False)
+                for stmt in body
+                if hasattr(stmt, "is_client_decl")
+            )
+        )
+
+    def test_anonymous_ability_decl(self) -> None:
+        """Test that abilities can be declared without explicit names.
+
+        Tests:
+        - Anonymous ability with entry event
+        - Anonymous ability with exit event
+        - Named ability still works
+        - Autogenerated names are unique based on location
+        """
+        # Test 1: Anonymous ability with entry event
+        source = """
+walker MyWalker {
+    can with entry {
+        print("hello");
+    }
+}
+"""
+        prog = JacProgram()
+        module = prog.parse_str(source, "test.jac")
+        self.assertFalse(prog.errors_had)
+
+        # Find the walker and its ability
+        walker = module.body[0]
+        abilities = [stmt for stmt in walker.body if type(stmt).__name__ == "Ability"]
+        self.assertEqual(len(abilities), 1)
+
+        ability = abilities[0]
+        self.assertIsNone(ability.name_ref)
+        # Check that py_resolve_name generates a name
+        resolved_name = ability.py_resolve_name()
+        self.assertTrue(resolved_name.startswith("__ability_entry_"))
+        self.assertTrue(resolved_name.endswith("__"))
+
+        # Test 2: Anonymous ability with exit event
+        source = """
+walker MyWalker {
+    can with exit {
+        print("goodbye");
+    }
+}
+"""
+        prog = JacProgram()
+        module = prog.parse_str(source, "test.jac")
+        self.assertFalse(prog.errors_had)
+
+        walker = module.body[0]
+        abilities = [stmt for stmt in walker.body if type(stmt).__name__ == "Ability"]
+        ability = abilities[0]
+        resolved_name = ability.py_resolve_name()
+        self.assertTrue(resolved_name.startswith("__ability_exit_"))
+
+        # Test 3: Named ability still works
+        source = """
+walker MyWalker {
+    can my_ability with entry {
+        print("named");
+    }
+}
+"""
+        prog = JacProgram()
+        module = prog.parse_str(source, "test.jac")
+        self.assertFalse(prog.errors_had)
+
+        walker = module.body[0]
+        abilities = [stmt for stmt in walker.body if type(stmt).__name__ == "Ability"]
+        ability = abilities[0]
+        self.assertIsNotNone(ability.name_ref)
+        self.assertEqual(ability.py_resolve_name(), "my_ability")
+
+        # Test 4: Multiple anonymous abilities generate unique names
+        source = """
+walker MyWalker {
+    can with entry {
+        print("first");
+    }
+    can with entry {
+        print("second");
+    }
+}
+"""
+        prog = JacProgram()
+        module = prog.parse_str(source, "test.jac")
+        self.assertFalse(prog.errors_had)
+
+        walker = module.body[0]
+        abilities = [stmt for stmt in walker.body if type(stmt).__name__ == "Ability"]
+        self.assertEqual(len(abilities), 2)
+
+        name1 = abilities[0].py_resolve_name()
+        name2 = abilities[1].py_resolve_name()
+        # Names should be different due to different locations
+        self.assertNotEqual(name1, name2)
+
+
 TestLarkParser.self_attach_micro_tests()