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

jaclang/compiler/passes/main/cfg_build_pass.py

@@ -68,7 +68,7 @@ class CFGBuildPass(UniPass):
     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:
+            if node.parent and isinstance(node, uni.CodeBlockStmt) and self.first_exit:
                 bb_stmts = [
                     bbs for bbs in node.parent.kid if isinstance(bbs, uni.UniCFGNode)
                 ]
@@ -199,7 +199,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

@@ -73,7 +73,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
@@ -204,8 +204,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)