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

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()