jaclang 0.8.0__py3-none-any.whl → 0.8.2__py3-none-any.whl

jaclang/compiler/passes/main/__init__.py

@@ -1,7 +1,5 @@
 """Collection of passes for Jac IR."""
 
-from enum import Enum
-
 from ..transform import Alert, Transform  # noqa: I100
 from .annex_pass import JacAnnexPass  # noqa: I100
 from .sym_tab_build_pass import SymTabBuildPass, UniPass  # noqa: I100
@@ -17,17 +15,6 @@ from .pyjac_ast_link_pass import PyJacAstLinkPass  # noqa: I100
 from .inheritance_pass import InheritancePass  # noqa: I100
 
 
-class CompilerMode(Enum):
-    """Compiler modes."""
-
-    PARSE = "PARSE"
-    NO_CGEN = "NO_CGEN"
-    NO_CGEN_SINGLE = "NO_CGEN_SINGLE"
-    COMPILE = "COMPILE"
-    COMPILE_SINGLE = "COMPILE_SINGLE"
-    TYPECHECK = "TYPECHECK"
-
-
 __all__ = [
     "Alert",
     "Transform",
@@ -42,7 +29,6 @@ __all__ = [
     "PyastBuildPass",
     "PyastGenPass",
     "PyBytecodeGenPass",
-    "CompilerMode",
     "CFGBuildPass",
     "PyJacAstLinkPass",
     "InheritancePass",

jaclang/compiler/passes/main/annex_pass.py

@@ -48,8 +48,6 @@ class JacAnnexPass(Transform[uni.Module, uni.Module]):
 
     def load_annexes(self, jac_program: JacProgram, node: uni.Module) -> None:
         """Parse and attach annex modules to the node."""
-        from jaclang.compiler.program import CompilerMode
-
         if node.stub_only or not self.mod_path.endswith(".jac"):
             return
         if not self.mod_path:
@@ -64,9 +62,7 @@ class JacAnnexPass(Transform[uni.Module, uni.Module]):
                 path.startswith(f"{self.base_path}.")
                 or os.path.dirname(path) == self.impl_folder
             ):
-                mod = jac_program.compile(
-                    file_path=path, mode=CompilerMode.NO_CGEN_SINGLE
-                )
+                mod = jac_program.compile(file_path=path, no_cgen=True)
                 if mod:
                     node.impl_mod.append(mod)
 
@@ -78,8 +74,6 @@ class JacAnnexPass(Transform[uni.Module, uni.Module]):
                     or os.path.dirname(path) == self.test_folder
                 )
             ):
-                mod = jac_program.compile(
-                    file_path=path, mode=CompilerMode.NO_CGEN_SINGLE
-                )
+                mod = jac_program.compile(file_path=path, no_cgen=True)
                 if mod:
                     node.test_mod.append(mod)

jaclang/compiler/passes/main/cfg_build_pass.py

@@ -10,6 +10,8 @@ The CFG provides a foundation for data flow analysis, optimization, and understa
 The pass also includes functionality to coalesce basic blocks and generate visual representations of the CFG.
 """
 
+from typing import Sequence
+
 import jaclang.compiler.unitree as uni
 from jaclang.compiler.passes import UniPass
 
@@ -65,26 +67,48 @@ class CFGBuildPass(UniPass):
             else:
                 target.bb_in = [source]
 
+    def get_code_block_sequence(
+        self, node: uni.CodeBlockStmt
+    ) -> list[uni.UniCFGNode] | None:
+        """Get code block sequence."""
+        sequence: list[uni.UniCFGNode] = []
+        if hasattr(node, "body") and isinstance(node.body, Sequence):
+            for bbs in node.body:
+                if isinstance(bbs, uni.UniCFGNode):
+                    sequence.append(bbs)
+            if sequence:
+                return sequence
+            else:
+                return None
+        else:
+            return None
+
     def enter_node(self, node: uni.UniNode) -> None:
         """Enter BasicBlockStmt nodes."""
         if isinstance(node, uni.UniCFGNode) and not isinstance(node, uni.Semi):
-            if isinstance(node.parent, uni.SubNodeList) and self.first_exit:
-                bb_stmts = [
-                    bbs for bbs in node.parent.kid if isinstance(bbs, uni.UniCFGNode)
-                ]
+            # check if the current node is a CodeBlockStmt in a sequence of statements
+            bb_stmts = self.get_code_block_sequence(node.parent)
+            if (
+                isinstance(node, uni.CodeBlockStmt)
+                and node.parent
+                and (not (isinstance(node, (uni.ElseIf, uni.ElseStmt))))
+                and bb_stmts
+                and self.first_exit
+            ):
+                # bb_stmts = self.get_code_block_sequence(node.parent)
+                # bb_stmts = [
+                #     bbs for bbs in node.parent.body if isinstance(bbs, uni.UniCFGNode)
+                # ]
                 if (
-                    node.parent.parent
-                    and isinstance(node.parent.parent, uni.Archetype)
+                    node.parent
+                    and isinstance(node.parent, uni.Archetype)
                     # and isinstance(node.parent.parent, uni.BasicBlockStmt)
                 ):
-                    parent_obj = node.parent.parent
+                    parent_obj = node.parent
                     if parent_obj:
                         self.link_bbs(parent_obj, node)
                 elif bb_stmts[0] == node:
-                    if (
-                        isinstance(node.parent.parent, uni.ModuleCode)
-                        and self.to_connect
-                    ):
+                    if isinstance(node.parent, uni.ModuleCode) and self.to_connect:
                         for bb in self.to_connect:
                             self.link_bbs(bb, node)
                             self.to_connect.remove(bb)  # if self.to_connect:
@@ -92,7 +116,9 @@ class CFGBuildPass(UniPass):
                         parent_bb = self.get_parent_bb_stmt(node)
                         if parent_bb:
                             self.link_bbs(parent_bb, node)
-                elif self.to_connect:
+                elif self.to_connect and not isinstance(
+                    node, (uni.ElseIf, uni.ElseStmt)
+                ):
                     to_remove = []
                     for parent in self.to_connect:
                         if isinstance(parent, uni.UniCFGNode):
@@ -199,7 +225,7 @@ class CoalesceBBPass(UniPass):
             }
             self.bb_counter += 1
 
-    def dotgen_cfg(self) -> str:
+    def printgraph_cfg(self) -> str:
         """Generate dot graph for CFG."""
         cfg: dict = {}
         dot = "digraph G {\n"

jaclang/compiler/passes/main/def_impl_match_pass.py

@@ -17,6 +17,8 @@ developers to define archetype and ability interfaces in one file while implemen
 their behavior in separate files.
 """
 
+from typing import Sequence
+
 import jaclang.compiler.unitree as uni
 from jaclang.compiler.constant import Tokens as Tok
 from jaclang.compiler.passes.transform import Transform
@@ -124,7 +126,7 @@ class DeclImplMatchPass(Transform[uni.Module, uni.Module]):
 
             valid_decl.body = sym.decl.name_of
             sym.decl.name_of.decl_link = valid_decl
-            for idx, a in enumerate(sym.decl.name_of.target.items):
+            for idx, a in enumerate(sym.decl.name_of.target):
                 if idx < len(name_of_links) and name_of_links[idx]:
                     a.name_spec.name_of = name_of_links[idx].name_of
                     a.name_spec.sym = name_of_links[idx].sym
@@ -159,7 +161,7 @@ class DeclImplMatchPass(Transform[uni.Module, uni.Module]):
 
             if params_decl and params_defn:
                 # Check if the parameter count is matched.
-                if len(params_defn.items) != len(params_decl.items):
+                if len(params_defn) != len(params_decl):
                     self.log_error(
                         f"Parameter count mismatch for ability {sym.sym_name}.",
                         sym.decl.name_of.name_spec,
@@ -170,10 +172,11 @@ class DeclImplMatchPass(Transform[uni.Module, uni.Module]):
                     )
                 else:
                     # Copy the parameter names from the declaration to the definition.
-                    for idx in range(len(params_defn.items)):
-                        params_decl.items[idx] = params_defn.items[idx]
-                    for idx in range(len(params_defn.kid)):
-                        params_decl.kid[idx] = params_defn.kid[idx]
+                    for idx in range(len(params_defn)):
+                        if (par := params_decl[idx].parent) is not None:
+                            loc_in_kid = par.kid.index(params_decl[idx])
+                            par.kid[loc_in_kid] = params_defn[idx]
+                        params_decl[idx] = params_defn[idx]
 
     def check_archetypes(self, ir_in: uni.Module) -> None:
         """Check all archetypes for issues with attributes and methods."""
@@ -182,15 +185,13 @@ class DeclImplMatchPass(Transform[uni.Module, uni.Module]):
 
     def check_archetype(self, node: uni.Archetype) -> None:
         """Check a single archetype for issues."""
-        if node.arch_type.name == Tok.KW_OBJECT and isinstance(
-            node.body, uni.SubNodeList
-        ):
+        if node.arch_type.name == Tok.KW_OBJECT and isinstance(node.body, Sequence):
             self.cur_node = node
             found_default_init = False
-            for stmnt in node.body.items:
+            for stmnt in node.body:
                 if not isinstance(stmnt, uni.ArchHas):
                     continue
-                for var in stmnt.vars.items:
+                for var in stmnt.vars:
                     if (var.value is not None) or (var.defer):
                         found_default_init = True
                     else:
@@ -204,10 +205,10 @@ class DeclImplMatchPass(Transform[uni.Module, uni.Module]):
             post_init_vars: list[uni.HasVar] = []
             postinit_method: uni.Ability | None = None
 
-            for item in node.body.items:
+            for item in node.body:
 
                 if isinstance(item, uni.ArchHas):
-                    for var in item.vars.items:
+                    for var in item.vars:
                         if var.defer:
                             post_init_vars.append(var)
 

jaclang/compiler/passes/main/def_use_pass.py

@@ -38,6 +38,7 @@ class DefUsePass(UniPass):
                 + node.get_all_sub_nodes(uni.IgnoreStmt)
                 + node.get_all_sub_nodes(uni.DisengageStmt)
                 + node.get_all_sub_nodes(uni.EdgeOpRef)
+                + node.get_all_sub_nodes(uni.EventSignature)
             ):
                 i.from_walker = True
 
@@ -57,19 +58,15 @@ class DefUsePass(UniPass):
         node.sym_tab.def_insert(node)
 
     def enter_has_var(self, node: uni.HasVar) -> None:
-        if isinstance(node.parent, uni.SubNodeList) and isinstance(
-            node.parent.parent, uni.ArchHas
-        ):
+        if isinstance(node.parent, uni.ArchHas):
             node.sym_tab.def_insert(
-                node,
-                single_decl="has var",
-                access_spec=node.parent.parent,
+                node, single_decl="has var", access_spec=node.parent
             )
         else:
             self.ice("Inconsistency in AST, has var should be under arch has")
 
     def enter_assignment(self, node: uni.Assignment) -> None:
-        for i in node.target.items:
+        for i in node.target:
             if isinstance(i, uni.AtomTrailer):
                 i.sym_tab.chain_def_insert(i.as_attr_list)
             elif isinstance(i, uni.AstSymbolNode):

jaclang/compiler/passes/main/import_pass.py

@@ -63,8 +63,6 @@ class JacImportDepsPass(Transform[uni.Module, uni.Module]):
 
     def import_jac_module(self, node: uni.ModulePath) -> None:
         """Import a module."""
-        from jaclang.compiler.passes.main import CompilerMode as CMode
-
         target = node.resolve_relative_path()
         # If the module is a package (dir)
         if os.path.isdir(target):
@@ -73,7 +71,7 @@ class JacImportDepsPass(Transform[uni.Module, uni.Module]):
             # And the import is a from import and I am the from module
             if node == import_node.from_loc:
                 # Import all from items as modules or packages
-                for i in import_node.items.items:
+                for i in import_node.items:
                     if isinstance(i, uni.ModuleItem):
                         from_mod_target = node.resolve_relative_path(i.name.value)
                         # If package
@@ -83,15 +81,11 @@ class JacImportDepsPass(Transform[uni.Module, uni.Module]):
                         else:
                             if from_mod_target in self.prog.mod.hub:
                                 return
-                            self.load_mod(
-                                self.prog.compile(
-                                    file_path=from_mod_target, mode=CMode.PARSE
-                                )
-                            )
+                            self.load_mod(self.prog.compile(file_path=from_mod_target))
         else:
             if target in self.prog.mod.hub:
                 return
-            self.load_mod(self.prog.compile(file_path=target, mode=CMode.PARSE))
+            self.load_mod(self.prog.compile(file_path=target))
 
     def load_mod(self, mod: uni.Module) -> None:
         """Attach a module to a node."""
@@ -102,13 +96,11 @@ class JacImportDepsPass(Transform[uni.Module, uni.Module]):
 
     def import_jac_mod_from_dir(self, target: str) -> uni.Module:
         """Import a module from a directory."""
-        from jaclang.compiler.passes.main import CompilerMode as CMode
-
         jac_init_path = os.path.join(target, "__init__.jac")
         if os.path.exists(jac_init_path):
             if jac_init_path in self.prog.mod.hub:
                 return self.prog.mod.hub[jac_init_path]
-            return self.prog.compile(file_path=jac_init_path, mode=CMode.PARSE)
+            return self.prog.compile(file_path=jac_init_path)
         elif os.path.exists(py_init_path := os.path.join(target, "__init__.py")):
             with open(py_init_path, "r") as f:
                 file_source = f.read()
@@ -204,8 +196,8 @@ class PyImportDepsPass(JacImportDepsPass):
         """Process the imports in form of `import X`."""
         # Expected that each ImportStatement will import one item
         # In case of this assertion fired then we need to revisit this item
-        assert len(imp_node.items.items) == 1
-        imported_item = imp_node.items.items[0]
+        assert len(imp_node.items) == 1
+        imported_item = imp_node.items[0]
         assert isinstance(imported_item, uni.ModulePath)
 
         imported_mod = self.__import_py_module(

jaclang/compiler/passes/main/inheritance_pass.py

@@ -36,11 +36,11 @@ class InheritancePass(Transform[uni.Module, uni.Module]):
 
     def process_archetype_inheritance(self, node: uni.Archetype) -> None:
         """Fill archetype symbol tables with abilities from parent archetypes."""
-        if node.base_classes is None:
+        if not node.base_classes:
             return
 
         self.cur_node = node
-        for item in node.base_classes.items:
+        for item in node.base_classes:
             # Handle different types of base class references
             if isinstance(item, uni.Name):
                 self.inherit_from_name(node, item)