jaclang 0.8.1__py3-none-any.whl → 0.8.3__py3-none-any.whl

jaclang/compiler/passes/main/sem_def_match_pass.py

@@ -0,0 +1,67 @@
+"""Semantic Definition Matching Pass for the Jac compiler.
+
+This pass connects semantic string definitions (SemDefs) in the AST to their corresponding
+declarations. It:
+
+1. Establishes links between semantic string definitions in the main module and their declarations
+2. Handles dotted name resolution for nested symbols
+3. Issues warnings for unmatched semantic definitions
+
+This pass is essential for Jac's semantic annotation system, allowing developers to define
+semantics in one file and link them to their corresponding declarations in another.
+"""
+
+import jaclang.compiler.unitree as uni
+from jaclang.compiler.passes.transform import Transform
+from jaclang.compiler.unitree import Symbol, UniScopeNode
+
+
+class SemDefMatchPass(Transform[uni.Module, uni.Module]):
+    """Jac Semantic definition match pass."""
+
+    def transform(self, ir_in: uni.Module) -> uni.Module:
+        """Connect Decls and Defs."""
+        self.cur_node = ir_in
+
+        self.connect_sems(ir_in.sym_tab, ir_in.sym_tab)
+        for impl_module in ir_in.impl_mod:
+            self.connect_sems(impl_module.sym_tab, ir_in.sym_tab)
+
+        return ir_in
+
+    def find_symbol_from_dotted_name(
+        self, dotted_name: str, target_sym_tab: UniScopeNode
+    ) -> Symbol | None:
+        """Find a symbol in the target symbol table by its dotted name.
+
+        Example:
+            "Foo.bar.baz" will do the following lookups:
+            target_sym_tab.lookup("Foo").lookup("bar").lookup("baz")
+        """
+        parts = dotted_name.lstrip("sem.").split(".")
+        current_sym_tab = target_sym_tab
+        sym: uni.Symbol | None = None
+        for part in parts:
+            if current_sym_tab is None:
+                return None
+            sym = current_sym_tab.lookup(part, deep=False)
+            if sym is None:
+                return None
+            current_sym_tab = sym.fetch_sym_tab
+        return sym
+
+    def connect_sems(
+        self, source_sym_tab: UniScopeNode, target_sym_tab: UniScopeNode
+    ) -> None:
+        """Connect sem strings from source symbol table to declarations in target symbol table.
+
+        When source_sym_tab and target_sym_tab are the same, this connects within the same module.
+        When different, it connects implementations from impl_mod to declarations in the main module.
+        """
+        for sym in source_sym_tab.names_in_scope.values():
+            if not isinstance(sym.decl.name_of, uni.SemDef):
+                continue
+            semdef = sym.decl.name_of
+            target_sym = self.find_symbol_from_dotted_name(sym.sym_name, target_sym_tab)
+            if target_sym is not None:
+                target_sym.decl.name_of.semstr = semdef.value.lit_value

jaclang/compiler/passes/main/sym_tab_build_pass.py

@@ -115,6 +115,14 @@ class SymTabBuildPass(UniPass):
     def exit_impl_def(self, node: uni.ImplDef) -> None:
         self.pop_scope()
 
+    def enter_sem_def(self, node: uni.SemDef) -> None:
+        self.push_scope_and_link(node)
+        assert node.parent_scope is not None
+        node.parent_scope.def_insert(node, single_decl="sem")
+
+    def exit_sem_def(self, node: uni.SemDef) -> None:
+        self.pop_scope()
+
     def enter_enum(self, node: uni.Enum) -> None:
         self.push_scope_and_link(node)
         assert node.parent_scope is not None

jaclang/compiler/passes/main/sym_tab_link_pass.py

@@ -32,11 +32,8 @@ class SymTabLinkPass(Transform[uni.Module, uni.Module]):
     def transform(self, ir_in: uni.Module) -> uni.Module:
         """Link the symbol tables for all modules in the program."""
         # Process all modules in the program hub
-        for mod in self.prog.mod.hub.values():
-            module_paths = mod.get_all_sub_nodes(uni.ModulePath)
-            for node in module_paths:
-                self.process_module_path(mod, node)
-
+        for node in ir_in.get_all_sub_nodes(uni.ModulePath):
+            self.process_module_path(ir_in, node)
         return ir_in
 
     def process_module_path(self, mod: uni.Module, node: uni.ModulePath) -> None:

jaclang/compiler/passes/main/tests/fixtures/sem_def_match.impl.jac

@@ -0,0 +1,12 @@
+
+sem Person = "A class representing a person.";
+sem Person.name = "The name of the person.";
+sem Person.yob = "The year of birth of the person.";
+
+sem Person.calc_age = "Calculate the age of the person.";
+sem Person.calc_age.year = "The year to calculate the age against.";
+
+
+sem OuterClass = "A class containing an inner class.";
+sem OuterClass.InnerClass = "An inner class within OuterClass.";
+sem OuterClass.InnerClass.inner_value = "A value specific to the inner class.";

jaclang/compiler/passes/main/tests/fixtures/sem_def_match.jac

@@ -0,0 +1,31 @@
+
+enum E {
+    A = 0,
+    B = 1,
+}
+
+sem E = "An enum representing some values.";
+sem E.A = "The first value of the enum E.";
+sem E.B = "The second value of the enum E.";
+
+obj Person {
+    has name: str;
+    has yob: int;
+
+    def calc_age(year: int) -> int {
+        return year - self.yob;
+    }
+}
+
+
+obj OuterClass {
+    obj InnerClass {
+        has inner_value: str;
+    }
+}
+
+
+
+with entry {
+    print(E.A);
+}

jaclang/compiler/passes/main/tests/test_cfg_build_pass.py

@@ -1,12 +1,10 @@
 """Test pass module."""
 
-from jaclang.compiler.passes.main import CompilerMode as CMode
 from jaclang.compiler.program import JacProgram
 from jaclang.utils.test import TestCase
 import unittest
 
 
-@unittest.skip("Skipping CFG build pass tests")
 class TestCFGBuildPass(TestCase):
     """Test FuseTypeInfoPass module."""
 
@@ -23,9 +21,7 @@ class TestCFGBuildPass(TestCase):
         with open(file_name, "r") as f:
             file_source = f.read()
 
-        ir = (prog := JacProgram()).compile_from_str(
-            source_str=file_source, file_path=file_name, mode=CMode.COMPILE
-        )
+        ir = (prog := JacProgram()).compile(use_str=file_source, file_path=file_name)
 
         cfg_pass = CoalesceBBPass(
             ir_in=ir,
@@ -71,9 +67,7 @@ class TestCFGBuildPass(TestCase):
         with open(file_name, "r") as f:
             file_source = f.read()
 
-        ir = (prog := JacProgram()).compile_from_str(
-            source_str=file_source, file_path=file_name, mode=CMode.COMPILE
-        )
+        ir = (prog := JacProgram()).compile(use_str=file_source, file_path=file_name)
 
         cfg_pass = CoalesceBBPass(
             ir_in=ir,

jaclang/compiler/passes/main/tests/test_decl_impl_match_pass.py

@@ -4,7 +4,7 @@ import io
 import sys
 
 import jaclang.compiler.unitree as uni
-from jaclang import JacMachineInterface as Jac, JacMachine
+from jaclang import JacMachine as Jac
 from jaclang.cli import cli
 from jaclang.compiler.program import JacProgram
 from jaclang.utils.test import TestCase
@@ -15,9 +15,8 @@ class DeclImplMatchPassTests(TestCase):
 
     def setUp(self) -> None:
         """Set up test."""
-        self.mach = JacMachine(self.fixture_abs_path("./"))
+        Jac.set_base_path(self.fixture_abs_path("./"))
         Jac.attach_program(
-            self.mach,
             JacProgram(),
         )
         return super().setUp()
@@ -110,7 +109,7 @@ class DeclImplMatchPassTests(TestCase):
         """Test walking through edges and nodes."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "mtest", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("mtest", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("2.0\n", stdout_value)
@@ -119,7 +118,7 @@ class DeclImplMatchPassTests(TestCase):
         """Test walking through edges."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "impl_grab", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("impl_grab", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("1.414", stdout_value)
@@ -128,7 +127,7 @@ class DeclImplMatchPassTests(TestCase):
         """Test complex nested impls."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "nested_impls", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("nested_impls", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue().split("\n")
         self.assertIn("Hello,from bar in kk", stdout_value[0])
@@ -142,7 +141,7 @@ class DeclImplMatchPassTests(TestCase):
         """Parse micro jac file."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "atest", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("atest", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(stdout_value, "42\n")
@@ -151,7 +150,7 @@ class DeclImplMatchPassTests(TestCase):
         """Parse micro jac file."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        Jac.jac_import(self.mach, "enumerations", base_path=self.fixture_abs_path("./"))
+        Jac.jac_import("enumerations", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(stdout_value, "1\n")

jaclang/compiler/passes/main/tests/test_import_pass.py

@@ -7,7 +7,6 @@ import unittest
 
 import jaclang.compiler.unitree as uni
 from jaclang.cli import cli
-from jaclang.compiler.passes.main import CompilerMode as CMode
 from jaclang.compiler.program import JacProgram
 from jaclang.utils.test import TestCase
 
@@ -21,7 +20,7 @@ class ImportPassPassTests(TestCase):
 
     def test_pygen_jac_cli(self) -> None:
         """Basic test for pass."""
-        (out := JacProgram()).compile(self.fixture_abs_path("base.jac"))
+        (out := JacProgram()).build(self.fixture_abs_path("base.jac"))
         self.assertFalse(out.errors_had)
         mod = out.mod.hub[self.fixture_abs_path("impl/imps.jac")]
         self.assertIn("56", str(mod.to_dict()))
@@ -38,7 +37,7 @@ class ImportPassPassTests(TestCase):
 
     def test_import_include_auto_impl(self) -> None:
         """Basic test for pass."""
-        (prog := JacProgram()).compile(self.fixture_abs_path("incautoimpl.jac"))
+        (prog := JacProgram()).build(self.fixture_abs_path("incautoimpl.jac"))
         num_modules = len(list(prog.mod.hub.values())[1].impl_mod) + 1
         mod_names = [i.name for i in list(prog.mod.hub.values())[1].impl_mod]
         self.assertEqual(num_modules, 5)
@@ -50,7 +49,7 @@ class ImportPassPassTests(TestCase):
 
     def test_annexalbe_by_discovery(self) -> None:
         """Basic test for pass."""
-        (prog := JacProgram()).compile(self.fixture_abs_path("incautoimpl.jac"))
+        (prog := JacProgram()).build(self.fixture_abs_path("incautoimpl.jac"))
         count = 0
         all_mods = prog.mod.hub.values()
         self.assertEqual(len(all_mods), 6)
@@ -66,10 +65,7 @@ class ImportPassPassTests(TestCase):
     @unittest.skip("TODO: Fix when we have the type checker")
     def test_py_raise_map(self) -> None:
         """Basic test for pass."""
-        (build := JacProgram()).compile(
-            self.fixture_abs_path("py_imp_test.jac"),
-            mode=CMode.TYPECHECK,
-        )
+        (build := JacProgram()).build(self.fixture_abs_path("py_imp_test.jac"))
         p = {
             "math": r"jaclang/vendor/mypy/typeshed/stdlib/math.pyi$",
             "pygame_mock": r"pygame_mock/__init__.pyi$",
@@ -91,9 +87,7 @@ class ImportPassPassTests(TestCase):
     @unittest.skip("TODO: Fix when we have the type checker")
     def test_py_raised_mods(self) -> None:
         """Basic test for pass."""
-        (prog := JacProgram()).compile(
-            self.fixture_abs_path("py_imp_test.jac"), mode=CMode.TYPECHECK
-        )
+        (prog := JacProgram()).build(self.fixture_abs_path("py_imp_test.jac"))
         for i in list(
             filter(
                 lambda x: x.is_raised_from_py,
@@ -125,13 +119,6 @@ class ImportPassPassTests(TestCase):
         self.assertIn("bar", stdout_value)
         self.assertIn("baz", stdout_value)
 
-    def test_raise_syntax_error(self) -> None:
-        """Test raise error on the parser , dont go to the next pass."""
-        (state := JacProgram()).compile(self.fixture_abs_path("main_err.jac"))
-        self.assertTrue(state.errors_had)
-        self.assertEqual(len(state.errors_had), 1)
-        self.assertIn("Syntax Error", state.errors_had[0].msg)
-
     def test_circular_import(self) -> None:
         """Test circular import."""
         (state := JacProgram()).compile(self.fixture_abs_path("circular_import.jac"))

jaclang/compiler/passes/main/tests/test_pyast_gen_pass.py

@@ -6,9 +6,8 @@ import sys
 import types
 
 import jaclang.compiler.unitree as uni
-from jaclang.compiler.passes.main import CompilerMode as CMode, PyastGenPass
+from jaclang.compiler.passes.main import PyastGenPass
 from jaclang.compiler.program import JacProgram
-from jaclang.runtimelib.machine import JacMachine
 from jaclang.utils.test import AstSyncTestMixin, TestCaseMicroSuite
 
 
@@ -53,7 +52,6 @@ class PyastGenPassTests(TestCaseMicroSuite, AstSyncTestMixin):
             sys.stdout = captured_output
             module = types.ModuleType("__main__")
             module.__dict__["__file__"] = code_gen.loc.mod_path
-            module.__dict__["__jac_mach__"] = JacMachine()
             exec(prog, module.__dict__)
             sys.stdout = sys.__stdout__
             stdout_value = captured_output.getvalue()
@@ -123,9 +121,7 @@ class ValidateTreeParentTest(TestCaseMicroSuite):
 
     def micro_suite_test(self, filename: str) -> None:
         """Parse micro jac file."""
-        code_gen = JacProgram().compile(
-            self.fixture_abs_path(filename), mode=CMode.PARSE
-        )
+        code_gen = JacProgram().compile(self.fixture_abs_path(filename))
         self.assertTrue(self.parent_scrub(code_gen))
         code_gen = JacProgram().compile(self.fixture_abs_path(filename))
         self.assertTrue(self.parent_scrub(code_gen))

jaclang/compiler/passes/main/tests/test_sem_def_match_pass.py

@@ -0,0 +1,38 @@
+"""Test pass module."""
+
+import jaclang.compiler.unitree as uni
+from jaclang.compiler.program import JacProgram
+from jaclang.utils.test import TestCase
+
+
+class SemDefMatchPassTests(TestCase):
+    """Test pass module."""
+
+    def test_sem_def_match(self) -> None:
+        """Basic test for pass."""
+        (out := JacProgram()).compile(self.fixture_abs_path("sem_def_match.jac"))
+        self.assertFalse(out.errors_had)
+        mod = out.mod.hub[self.fixture_abs_path("sem_def_match.jac")]
+
+        self.assertEqual(mod.lookup("E").decl.name_of.semstr, "An enum representing some values.")  # type: ignore
+        self.assertEqual(mod.lookup("E").fetch_sym_tab.lookup("A").decl.name_of.semstr, "The first value of the enum E.")  # type: ignore
+        self.assertEqual(mod.lookup("E").fetch_sym_tab.lookup("B").decl.name_of.semstr, "The second value of the enum E.")  # type: ignore
+
+        self.assertEqual(mod.lookup("Person").decl.name_of.semstr, "A class representing a person.")  # type: ignore
+
+        person_scope = mod.lookup("Person").fetch_sym_tab  # type: ignore
+        self.assertEqual(person_scope.lookup("name").decl.name_of.semstr, "The name of the person.")  # type: ignore
+        self.assertEqual(person_scope.lookup("yob").decl.name_of.semstr, "The year of birth of the person.")  # type: ignore
+
+        sym_calc_age = person_scope.lookup("calc_age")  # type: ignore
+        self.assertEqual(sym_calc_age.decl.name_of.semstr, "Calculate the age of the person.")  # type: ignore
+
+        calc_age_scope = sym_calc_age.fetch_sym_tab  # type: ignore
+        self.assertEqual(calc_age_scope.lookup("year").decl.name_of.semstr, "The year to calculate the age against.")  # type: ignore
+
+        self.assertEqual(mod.lookup("OuterClass").decl.name_of.semstr, "A class containing an inner class.")  # type: ignore
+        outer_scope = mod.lookup("OuterClass").fetch_sym_tab  # type: ignore
+        self.assertEqual(outer_scope.lookup("InnerClass").decl.name_of.semstr, "An inner class within OuterClass.")  # type: ignore
+        inner_scope = outer_scope.lookup("InnerClass").fetch_sym_tab  # type: ignore
+        self.assertEqual(inner_scope.lookup("inner_value").decl.name_of.semstr, "A value specific to the inner class.")  # type: ignore
+

jaclang/compiler/passes/main/tests/test_sub_node_pass.py

@@ -1,7 +1,6 @@
 """Test sub node pass module."""
 
 from jaclang.compiler.passes import UniPass
-from jaclang.compiler.passes.main import CompilerMode as CMode
 from jaclang.compiler.program import JacProgram
 from jaclang.utils.test import TestCase
 
@@ -16,8 +15,7 @@ class SubNodePassTests(TestCase):
     def test_sub_node_pass(self) -> None:
         """Basic test for pass."""
         code_gen = (out := JacProgram()).compile(
-            file_path=self.examples_abs_path("manual_code/circle.jac"),
-            mode=CMode.PARSE,
+            file_path=self.examples_abs_path("manual_code/circle.jac")
         )
         for i in code_gen.kid[1].kid:
             for k, v in i._sub_node_tab.items():

jaclang/compiler/passes/main/tests/test_sym_tab_link_pass.py

@@ -2,7 +2,6 @@
 
 import os
 
-from jaclang.compiler.passes.main import CompilerMode as CMode
 from jaclang.compiler.program import JacProgram
 from jaclang.utils.test import TestCase
 
@@ -23,7 +22,7 @@ class SymTabLinkPassTests(TestCase):
             "symtab_link_tests",
             "no_dupls.jac",
         )
-        mod = JacProgram().compile(file_path, mode=CMode.TYPECHECK)
+        mod = JacProgram().build(file_path)
         self.assertEqual(
             len(mod.sym_tab.names_in_scope.values()),
             3,
@@ -33,20 +32,24 @@ class SymTabLinkPassTests(TestCase):
                 i,
                 str(mod.sym_tab.names_in_scope.values()),
             )
-        self.assertEqual(len(mod.sym_tab.names_in_scope["a"].uses), 2)
-        self.assertEqual(
-            len(
-                list(
-                    mod.sym_tab.kid_scope[0]
-                    .kid_scope[0]
-                    .kid_scope[0]
-                    .kid_scope[0]
-                    .inherited_scope[0]
-                    .base_symbol_table.names_in_scope.values()
-                )[0].uses,
-            ),
-            3,
-        )
+        # TODO: def use is called on single file so this breaks
+        # Def Use pass will go away with full type checking
+        # self.assertEqual(
+        #     len(mod.sym_tab.names_in_scope["a"].uses), 4
+        # )
+        # self.assertEqual(
+        #     len(
+        #         list(
+        #             mod.sym_tab.kid_scope[0]
+        #             .kid_scope[0]
+        #             .kid_scope[0]
+        #             .kid_scope[0]
+        #             .inherited_scope[0]
+        #             .base_symbol_table.names_in_scope.values()
+        #         )[0].uses,
+        #     ),
+        #     3,
+        # )
 
     def test_package(self) -> None:
         """Test package."""
@@ -57,6 +60,6 @@ class SymTabLinkPassTests(TestCase):
             "main.jac",
         )
         prog = JacProgram()
-        prog.compile(file_path, mode=CMode.COMPILE)
+        prog.compile(file_path)
         self.assertEqual(prog.errors_had, [])
         self.assertEqual(prog.warnings_had, [])