jaclang 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

jaclang/jac/passes/blue/decl_def_match_pass.py

@@ -0,0 +1,278 @@
+"""Connect Decls and Defs in AST."""
+import jaclang.jac.absyntree as ast
+from jaclang.jac.lexer import Tokens as Tok
+from jaclang.jac.passes import Pass
+from jaclang.jac.sym_table import DefDeclSymbol, SymbolTable
+
+
+class DeclDefMatchPass(Pass, SymbolTable):
+    """Decls and Def matching pass."""
+
+    def before_pass(self) -> None:
+        """Initialize pass."""
+        self.sym_tab = SymbolTable(scope_name="global")
+
+    def exit_global_vars(self, node: ast.GlobalVars) -> None:
+        """Sub objects.
+
+        doc: Optional[DocString],
+        access: Optional[Token],
+        assignments: AssignmentList,
+        """
+        for i in self.get_all_sub_nodes(node, ast.Assignment):
+            if type(i.target) != ast.Name:
+                self.ice("Only name targets should be possible to in global vars.")
+            else:
+                decl = self.sym_tab.lookup(i.target.value)
+                if decl:
+                    if decl.has_def:
+                        self.error(f"Name {i.target.value} already bound.")
+                    else:
+                        decl.has_def = True
+                        decl.other_node = i
+                        decl.node.body = i  # TODO: I dont think this line makes sense
+                        self.sym_tab.set(decl)
+
+    def exit_test(self, node: ast.Test) -> None:
+        """Sub objects.
+
+        name: Name,
+        doc: Optional[DocString],
+        description: Token,
+        body: CodeBlock,
+        """
+
+    def enter_import(self, node: ast.Import) -> None:
+        """Sub objects.
+
+        lang: Name,
+        path: ModulePath,
+        alias: Optional[Name],
+        items: Optional[ModuleItems],
+        is_absorb: bool,
+        sub_module: Optional[Module],
+        """
+        if not node.is_absorb:
+            self.sym_tab = self.sym_tab.push(node.path.path_str)
+
+    def exit_import(self, node: ast.Import) -> None:
+        """Sub objects.
+
+        lang: Name,
+        path: ModulePath,
+        alias: Optional[Name],
+        items: Optional[ModuleItems],
+        is_absorb: bool,
+        sub_module: Optional[Module],
+        """
+        if not node.is_absorb and not self.sym_tab.parent:
+            self.ice("Import should have a parent sym_table scope.")
+        elif not node.is_absorb:
+            self.sym_tab = self.sym_tab.pop()
+        if node.items:  # now treat imported items as global
+            for i in node.items.items:
+                name = i.alias if i.alias else i.name
+                decl = self.sym_tab.lookup(name.value)
+                if not decl:
+                    self.sym_tab.set(
+                        DefDeclSymbol(name=name.value, node=i, has_def=True)
+                    )
+
+    def exit_module_item(self, node: ast.ModuleItem) -> None:
+        """Sub objects.
+
+        name: Name,
+        alias: Optional[Token],
+        body: Optional[AstNode],
+        """
+        if not self.sym_tab.lookup(node.name.value):
+            self.sym_tab.set(
+                DefDeclSymbol(name=node.name.value, node=node, has_decl=True)
+            )
+
+    def exit_architype(self, node: ast.Architype) -> None:
+        """Sub objects.
+
+        name: Name,
+        arch_type: Token,
+        doc: Optional[DocString],
+        decorators: Optional[Decorators],
+        access: Optional[Token],
+        base_classes: BaseClasses,
+        body: Optional[ArchBlock],
+        """
+        # if no body, check for def
+        #    if no def, register as decl
+        # if complete register as def
+        # nota: can allow static overriding perhaps?
+        # note: if arch has not body ok, imports body is the arch itself
+
+    def exit_arch_def(self, node: ast.ArchDef) -> None:
+        """Sub objects.
+
+        doc: Optional[DocString],
+        mod: Optional[NameList],
+        arch: ObjectRef | NodeRef | EdgeRef | WalkerRef,
+        body: ArchBlock,
+        """
+
+    def enter_ability(self, node: ast.Ability) -> None:
+        """Sub objects.
+
+        name: Name,
+        is_func: bool,
+        doc: Optional[DocString],
+        decorators: Optional["Decorators"],
+        access: Optional[Token],
+        signature: "FuncSignature | TypeSpec | EventSignature",
+        body: Optional["CodeBlock"],
+        arch_attached: Optional["ArchBlock"] = None,
+        """
+        self.sym_tab = self.sym_tab.push(node.name.value)
+
+    def exit_ability(self, node: ast.Ability) -> None:
+        """Sub objects.
+
+        name: Name,
+        is_func: bool,
+        doc: Optional[DocString],
+        decorators: Optional["Decorators"],
+        access: Optional[Token],
+        signature: "FuncSignature | TypeSpec | EventSignature",
+        body: Optional["CodeBlock"],
+        arch_attached: Optional["ArchBlock"] = None,
+        """
+        name = (
+            f"{node.arch_attached.parent.name.value}.{node.name.value}"
+            if node.arch_attached and type(node.arch_attached.parent) == ast.Architype
+            else node.name.value
+        )
+        decl = self.sym_tab.lookup(name)
+        if decl and decl.has_decl:
+            self.error(
+                f"Ability bound with name {name} already defined on "
+                f"Line {decl.node.line} in {decl.node.mod_link.rel_mod_path}."
+            )
+        elif decl and decl.has_def:
+            decl.has_decl = True
+            decl.node = node
+            decl.node.body = (
+                decl.other_node.body
+                if type(decl.other_node) == ast.AbilityDef
+                else self.ice("Expected node of type AbilityDef in symbol table.")
+            )
+            ast.append_node(decl.node, decl.other_node)
+            self.sym_tab.set(decl)
+        else:
+            decl = DefDeclSymbol(name=name, node=node, has_decl=True)
+            if node.body:
+                decl.has_def = True
+                decl.other_node = node
+            self.sym_tab.set(decl)
+        self.sym_tab = self.sym_tab.pop()
+
+    def exit_ability_def(self, node: ast.AbilityDef) -> None:
+        """Sub objects.
+
+        doc: Optional[DocString],
+        target: Optional["NameList"],
+        ability: "ArchRef",
+        signature: "FuncSignature | EventSignature",
+        body: "CodeBlock",
+        """
+        name = node.ability.name.value
+        if node.target:
+            owner = node.target.names[-1]
+            if not isinstance(owner, ast.ArchRef):
+                self.error("Expected reference to Architype!")
+                owner = ""
+            else:
+                owner = owner.name.value
+            name = f"{owner}.{name}"
+        decl = self.sym_tab.lookup(name)
+        if decl and decl.has_def:
+            self.error(
+                f"Ability bound with name {name} already defined on "
+                f"Line {decl.other_node.line} in {decl.other_node.mod_link.rel_mod_path}."
+            )
+        elif decl and decl.has_decl:
+            decl.has_def = True
+            decl.other_node = node
+            decl.node.body = decl.other_node.body
+            ast.append_node(decl.node, decl.other_node)
+            self.sym_tab.set(decl)
+        else:
+            self.sym_tab.set(DefDeclSymbol(name=name, other_node=node, has_def=True))
+
+    def enter_arch_block(self, node: ast.ArchBlock) -> None:
+        """Sub objects.
+
+        members: list['ArchHas | Ability'],
+        """
+        # Tags all function signatures whether method style or not
+        for i in self.get_all_sub_nodes(node, ast.Ability):
+            i.arch_attached = node
+        if (
+            type(node.parent) == ast.Architype
+            and node.parent.arch_type.name == Tok.KW_WALKER
+        ):
+            for i in self.get_all_sub_nodes(node, ast.VisitStmt):
+                i.from_walker = True
+            for i in self.get_all_sub_nodes(node, ast.DisengageStmt):
+                i.from_walker = True
+
+    def exit_enum(self, node: ast.Enum) -> None:
+        """Sub objects.
+
+        name: Name,
+        doc: Optional[DocString],
+        decorators: Optional[Decorators],
+        access: Optional[Token],
+        base_classes: BaseClasses,
+        body: Optional[EnumBlock],
+        """
+        name = node.name.value
+        decl = self.sym_tab.lookup(name)
+        if decl and decl.has_decl:
+            self.error(
+                f"Enum bound with name {name} already defined on Line {decl.node.line}."
+            )
+        elif decl and decl.has_def:
+            decl.has_decl = True
+            decl.node = node
+            decl.node.body = (
+                decl.other_node.body
+                if type(decl.other_node) == ast.EnumDef
+                else self.ice("Expected node of type EnumDef in symbol table.")
+            )
+            ast.append_node(decl.node, decl.other_node)
+            self.sym_tab.set(decl)
+        else:
+            decl = DefDeclSymbol(name=name, node=node, has_decl=True)
+            if node.body:
+                decl.has_def = True
+                decl.other_node = node
+            self.sym_tab.set(decl)
+
+    def exit_enum_def(self, node: ast.EnumDef) -> None:
+        """Sub objects.
+
+        doc: Optional[DocString],
+        enum: "EnumRef",
+        mod: Optional["NameList"],
+        body: "EnumBlock",
+        """
+        name = node.enum.name.value
+        decl = self.sym_tab.lookup(name)
+        if decl and decl.has_def:
+            self.error(
+                f"Enum bound with name {name} already defined on Line {decl.other_node.line}."
+            )
+        elif decl and decl.has_decl:
+            decl.has_def = True
+            decl.other_node = node
+            decl.node.body = decl.other_node.body
+            ast.append_node(decl.node, decl.other_node)
+            self.sym_tab.set(decl)
+        else:
+            self.sym_tab.set(DefDeclSymbol(name=name, other_node=node, has_def=True))

jaclang/jac/passes/blue/import_pass.py

@@ -0,0 +1,75 @@
+"""Static Import Pass."""
+from os import path
+
+import jaclang.jac.absyntree as ast
+from jaclang.jac.passes import Pass
+from jaclang.jac.passes.blue import SubNodeTabPass
+
+
+class ImportPass(Pass):
+    """Jac statically imports all modules."""
+
+    def before_pass(self) -> None:
+        """Run once before pass."""
+        self.import_table = {}
+
+    def enter_module(self, node: ast.Module) -> None:
+        """Run Importer."""
+        self.cur_node = node
+        self.terminate()  # Turns off auto traversal for deliberate traversal
+        self.run_again = True
+        while self.run_again:
+            self.run_again = False
+            for i in self.get_all_sub_nodes(node, ast.Import):
+                if i.lang.value == "jac" and not i.sub_module:
+                    self.run_again = True
+                    ast.append_node(i, self.import_module(i, node.mod_path))
+                    i.sub_module = i.kid[-1]
+                self.enter_import(i)
+            SubNodeTabPass(mod_path=node.mod_path, input_ir=node)
+
+    def enter_import(self, node: ast.Import) -> None:
+        """Sub objects.
+
+        lang: Name,
+        path: ModulePath,
+        alias: Optional[Name],
+        items: Optional[ModuleItems], # Items matched during def/decl pass
+        is_absorb: bool,
+        self.sub_module = None
+        """
+        self.cur_node = node
+        if node.alias and node.sub_module:
+            node.sub_module.name = node.alias.value
+        # Items matched during def/decl pass
+
+    # Utility functions
+    # -----------------
+
+    def import_module(self, node: ast.Import, mod_path: str) -> ast.AstNode:
+        """Import a module."""
+        from jaclang.jac.transpiler import jac_file_to_pass
+        from jaclang.jac.passes.blue.ast_build_pass import AstBuildPass
+
+        base_dir = path.dirname(mod_path)
+        target = path.normpath(
+            path.normpath(
+                path.join(base_dir, *(node.path.path_str.split("."))) + ".jac"
+            )
+        )
+        if target in self.import_table:
+            # self.warning(f"Circular import detected, module {target} already imported.")
+            return self.import_table[target]
+
+        if not path.exists(target):
+            self.error(f"Could not find module {target}")
+        mod = jac_file_to_pass(
+            file_path=target, base_dir=base_dir, target=AstBuildPass
+        ).ir
+        if isinstance(mod, ast.Module):
+            self.import_table[target] = mod
+            mod.is_imported = True
+        else:
+            self.error(f"Module {target} is not a valid Jac module.")
+            raise Exception(f"Module {target} is not a valid Jac module.")
+        return mod

jaclang/jac/passes/blue/sub_node_tab_pass.py

@@ -0,0 +1,30 @@
+"""Subnode Table building pass."""
+from copy import copy
+
+import jaclang.jac.absyntree as ast
+from jaclang.jac.passes import Pass
+
+
+class SubNodeTabPass(Pass):
+    """AST Enrichment Pass for basic high level semantics."""
+
+    def enter_node(self, node: ast.AstNode) -> None:
+        """Table builder."""
+        super().enter_node(node)
+        node._sub_node_tab = {}  # clears on entry
+
+    def exit_node(self, node: ast.AstNode) -> None:
+        """Table builder."""
+        super().exit_node(node)
+        for i in node.kid:
+            if not i:
+                continue
+            for k, v in i._sub_node_tab.items():
+                if k in node._sub_node_tab:
+                    node._sub_node_tab[k].extend(v)
+                else:
+                    node._sub_node_tab[k] = copy(v)
+            if type(i) in node._sub_node_tab:
+                node._sub_node_tab[type(i)].append(i)
+            else:
+                node._sub_node_tab[type(i)] = [i]

jaclang/jac/passes/blue/tests/__init__.py

@@ -0,0 +1 @@
+"""Tests for Jac passes."""

jaclang/jac/passes/blue/tests/test_ast_build_pass.py

@@ -0,0 +1,61 @@
+"""Test ast build pass module."""
+import inspect
+
+from jaclang.jac.lexer import JacLexer
+from jaclang.jac.parser import JacParser
+from jaclang.jac.passes.blue import AstBuildPass
+from jaclang.utils.fstring_parser import FStringParser
+from jaclang.utils.test import TestCaseMicroSuite
+
+
+class AstBuildPassTests(TestCaseMicroSuite):
+    """Test pass module."""
+
+    def setUp(self) -> None:
+        """Set up test."""
+        return super().setUp()
+
+    def test_pass_grammar_complete(self) -> None:
+        """Test for enter/exit name diffs with parser."""
+        from jaclang.jac.parser import JacParser
+
+        parser_func_names = []
+        for name, value in [
+            *inspect.getmembers(JacParser),
+            *inspect.getmembers(FStringParser),
+        ]:
+            if (
+                inspect.isfunction(value)
+                and value.__qualname__.split(".")[0]
+                in [JacParser.__name__, FStringParser.__name__]
+                and name not in ["__init__", "error", "transform"]
+            ):
+                parser_func_names.append(name)
+        ast_build_func_names = []
+        for name, value in inspect.getmembers(AstBuildPass):
+            if (
+                (name.startswith("enter_") or name.startswith("exit_"))
+                and inspect.isfunction(value)
+                and not getattr(AstBuildPass.__base__, value.__name__, False)
+                and value.__qualname__.split(".")[0]
+                == AstBuildPass.__name__.replace("enter_", "").replace("exit_", "")
+            ):
+                ast_build_func_names.append(
+                    name.replace("enter_", "").replace("exit_", "")
+                )
+        for name in ast_build_func_names:
+            self.assertIn(name, parser_func_names)
+        for name in parser_func_names:
+            self.assertIn(name, ast_build_func_names)
+
+    def micro_suite_test(self, filename: str) -> None:
+        """Parse micro jac file."""
+        lex = JacLexer(mod_path=f"{filename}", input_ir=self.file_to_str(filename)).ir
+        prse = JacParser(mod_path=f"{filename}", input_ir=lex).ir
+        build_pass = AstBuildPass(mod_path="", input_ir=prse).ir
+        self.assertIsNotNone(build_pass)
+        if build_pass:
+            self.assertGreater(len(str(build_pass.to_dict())), 200)
+
+
+AstBuildPassTests.self_attach_micro_tests()

jaclang/jac/passes/blue/tests/test_blue_pygen_pass.py

@@ -0,0 +1,117 @@
+"""Test ast build pass module."""
+import inspect
+
+from jaclang.jac.passes.blue import BluePygenPass
+from jaclang.jac.transpiler import jac_file_to_pass, transpile_jac_blue
+from jaclang.jac.utils import get_ast_nodes_as_snake_case as ast_snakes
+from jaclang.utils.test import TestCaseMicroSuite
+
+
+class BluePygenPassTests(TestCaseMicroSuite):
+    """Test pass module."""
+
+    def setUp(self) -> None:
+        """Set up test."""
+        return super().setUp()
+
+    def test_jac_cli(self) -> None:
+        """Basic test for pass."""
+        code_gen = jac_file_to_pass(
+            self.fixture_abs_path("../../../../../cli/cli.jac"), target=BluePygenPass
+        )
+        self.assertFalse(code_gen.errors_had)
+
+    def test_pipe_operator(self) -> None:
+        """Basic test for pass."""
+        code_gen = jac_file_to_pass(
+            self.fixture_abs_path("codegentext.jac"), target=BluePygenPass
+        )
+        self.assertFalse(code_gen.errors_had)
+        self.assertIn(
+            'say((dump(print(len)))({"name": "value"}))', code_gen.ir.meta["py_code"]
+        )
+        self.assertIn(
+            '{"name": "value"}(len(print(print(print))))', code_gen.ir.meta["py_code"]
+        )
+        self.assertIn("a = (5 + 10) * 2", code_gen.ir.meta["py_code"])
+
+    def test_atomic_pipe_operator(self) -> None:
+        """Basic test for pass."""
+        code_gen = jac_file_to_pass(
+            self.fixture_abs_path("codegentext.jac"), target=BluePygenPass
+        )
+        self.assertFalse(code_gen.errors_had)
+        self.assertIn(
+            'say((dump(print)(len))({"name": "value"}))', code_gen.ir.meta["py_code"]
+        )
+
+    def test_pipe_operator_multi_param(self) -> None:
+        """Basic test for pass."""
+        code_gen = jac_file_to_pass(
+            self.fixture_abs_path("codegentext.jac"), target=BluePygenPass
+        )
+        self.assertFalse(code_gen.errors_had)
+        self.assertIn("self.func(*args, **kwargs)", code_gen.ir.meta["py_code"])
+        self.assertIn("inspect.signature(func)", code_gen.ir.meta["py_code"])
+        self.assertIn("self.registry.items()", code_gen.ir.meta["py_code"])
+
+    def test_with_stmt(self) -> None:
+        """Basic test for pass."""
+        code_gen = jac_file_to_pass(
+            self.fixture_abs_path("codegentext.jac"), target=BluePygenPass
+        )
+        self.assertFalse(code_gen.errors_had)
+        self.assertIn(
+            'with open("file.txt") as f, open("file2.txt") as f:',
+            code_gen.ir.meta["py_code"],
+        )
+
+    def test_empty_codeblock(self) -> None:
+        """Basic test for pass."""
+        code_gen = jac_file_to_pass(
+            self.fixture_abs_path("codegentext.jac"), target=BluePygenPass
+        )
+        self.assertFalse(code_gen.errors_had)
+        self.assertIn("pass", code_gen.ir.meta["py_code"])
+
+    def test_enum_gen(self) -> None:
+        """Basic test for pass."""
+        code_gen = jac_file_to_pass(
+            self.fixture_abs_path("codegentext.jac"), target=BluePygenPass
+        )
+        self.assertFalse(code_gen.errors_had)
+        self.assertIn(
+            "from enum import Enum as __jac_Enum__, auto as __jac_auto__",
+            code_gen.ir.meta["py_code"],
+        )
+        self.assertIn("class Color(__jac_Enum__):", code_gen.ir.meta["py_code"])
+        self.assertIn("GREEN = __jac_auto__()", code_gen.ir.meta["py_code"])
+        self.assertIn("RED = 1", code_gen.ir.meta["py_code"])
+
+    def test_pass_ast_complete(self) -> None:
+        """Test for enter/exit name diffs with parser."""
+        ast_func_names = [
+            x for x in ast_snakes() if x not in ["ast_node", "o_o_p_access_node"]
+        ]
+        pygen_func_names = []
+        for name, value in inspect.getmembers(BluePygenPass):
+            if (
+                (name.startswith("enter_") or name.startswith("exit_"))
+                and inspect.isfunction(value)
+                and not getattr(BluePygenPass.__base__, value.__name__, False)
+                and value.__qualname__.split(".")[0]
+                == BluePygenPass.__name__.replace("enter_", "").replace("exit_", "")
+            ):
+                pygen_func_names.append(name.replace("enter_", "").replace("exit_", ""))
+        for name in pygen_func_names:
+            self.assertIn(name, ast_func_names)
+        for name in ast_func_names:
+            self.assertIn(name, pygen_func_names)
+
+    def micro_suite_test(self, filename: str) -> None:
+        """Parse micro jac file."""
+        code_gen = transpile_jac_blue(filename, "")
+        self.assertGreater(len(code_gen), 10)
+
+
+BluePygenPassTests.self_attach_micro_tests()

jaclang/jac/passes/blue/tests/test_decl_def_match_pass.py

@@ -0,0 +1,43 @@
+"""Test pass module."""
+from jaclang.jac.passes.blue import DeclDefMatchPass
+from jaclang.jac.transpiler import jac_file_to_pass
+from jaclang.utils.test import TestCase
+
+
+class DeclDefMatchPassTests(TestCase):
+    """Test pass module."""
+
+    def setUp(self) -> None:
+        """Set up test."""
+        return super().setUp()
+
+    def test_import_values_avail(self) -> None:
+        """Basic test for pass."""
+        state = jac_file_to_pass(
+            self.fixture_abs_path("base.jac"), "", DeclDefMatchPass
+        )
+        self.assertFalse(state.errors_had)
+        self.assertIn("mine", state.sym_tab.tab)
+        self.assertIsNotNone(state.sym_tab.tab["mine"].node.body)
+
+    def test_ability_connected_to_decl(self) -> None:
+        """Basic test for pass."""
+        state = jac_file_to_pass(
+            self.fixture_abs_path("base.jac"), "", DeclDefMatchPass
+        )
+        self.assertFalse(state.errors_had)
+        self.assertIn("Test.say_hi", state.sym_tab.tab)
+        self.assertIsNotNone(state.sym_tab.tab["Test.say_hi"].node.body)
+        self.assertIn("Test.init", state.sym_tab.tab)
+        self.assertIsNotNone(state.sym_tab.tab["Test.init"].node.body)
+
+    def test_collision_error_correct(self) -> None:
+        """Basic test for multi defs."""
+        state = jac_file_to_pass(
+            self.fixture_abs_path("decls.jac"), "", DeclDefMatchPass
+        )
+        self.assertTrue(state.errors_had)
+        self.assertIn("/impl/defs2.jac", state.errors_had[0])
+        self.assertIn("/impl/defs1.jac", state.errors_had[0])
+        self.assertIn("/impl/defs2.jac", state.errors_had[1])
+        self.assertIn("/impl/defs1.jac", state.errors_had[1])

jaclang/jac/passes/blue/tests/test_import_pass.py

@@ -0,0 +1,18 @@
+"""Test pass module."""
+from jaclang.jac.passes.blue import ImportPass
+from jaclang.jac.transpiler import jac_file_to_pass
+from jaclang.utils.test import TestCase
+
+
+class ImportPassPassTests(TestCase):
+    """Test pass module."""
+
+    def setUp(self) -> None:
+        """Set up test."""
+        return super().setUp()
+
+    def test_pygen_jac_cli(self) -> None:
+        """Basic test for pass."""
+        state = jac_file_to_pass(self.fixture_abs_path("base.jac"), "", ImportPass)
+        self.assertFalse(state.errors_had)
+        self.assertIn("56", str(state.ir.to_dict()))

jaclang/jac/passes/blue/tests/test_sub_node_pass.py

@@ -0,0 +1,26 @@
+"""Test sub node pass module."""
+
+from jaclang.jac.passes.blue import SubNodeTabPass
+from jaclang.jac.transpiler import jac_file_to_pass
+from jaclang.utils.test import TestCase
+
+
+class SubNodePassTests(TestCase):
+    """Test pass module."""
+
+    def setUp(self) -> None:
+        """Set up test."""
+        return super().setUp()
+
+    def test_sub_node_pass(self) -> None:
+        """Basic test for pass."""
+        code_gen = jac_file_to_pass(
+            file_path=self.fixture_abs_path("../../../../../cli/cli.jac"),
+            base_dir="",
+            target=SubNodeTabPass,
+        )
+        for i in code_gen.ir.kid[1].kid:
+            for k, v in i._sub_node_tab.items():
+                for n in v:
+                    self.assertIn(n, code_gen.get_all_sub_nodes(i, k, brute_force=True))
+        self.assertFalse(code_gen.errors_had)