jaclang 0.0.5__py3-none-any.whl → 0.0.8__py3-none-any.whl

jaclang/jac/passes/blue/blue_pygen_pass.py

@@ -84,8 +84,8 @@ class BluePygenPass(Pass):
         # self.emit_ln(node, "print(__jac_tmp__)\nraise e")
         self.emit_ln(
             node,
-            "e = type(e)(str(e) + '\\nOriginal Snippet:\\n' + __jac_tmp__) "
-            "if 'Original Snippet:' not in str(e) else e",
+            "e.args = (f'{e.args[0]}\\n' + __jac_tmp__,) + e.args[1:] "
+            f"if '{Con.JAC_ERROR_PREAMBLE}' not in str(e) else e.args",
         )
         self.emit_ln(node, "raise e")
         self.indent_level -= 1
@@ -179,26 +179,57 @@ class BluePygenPass(Pass):
             self.emit_ln(node, node.doc.value)
         self.emit(node, node.assignments.meta["py_code"])
 
-    # NOTE: Incomplete for Jac Purple and Red
     def exit_test(self, node: ast.Test) -> None:
         """Sub objects.
 
-        name: Token,
-        doc: Optional["Token"],
-        description: Token,
-        body: "CodeBlock",
+        name: Optional[Name],
+        doc: Optional[Token],
+        body: CodeBlock,
         """
-        self.warning("Test feature not supported in bootstrap Jac.")
+        test_name = node.name.value
+        test_code = "import unittest as __jac_unittest__\n"
+        test_code += "__jac_tc__ = __jac_unittest__.TestCase()\n"
+        test_code += "__jac_suite__ = __jac_unittest__.TestSuite()\n"
+        test_code += "class __jac_check:\n"
+        test_code += "    def __getattr__(self, name):\n"
+        test_code += "        return getattr(__jac_tc__, 'assert'+name)"
+        self.emit_ln_unique(self.preamble, test_code)
+        self.emit_ln(node, f"def test_{test_name}():")
+        self.indent_level += 1
+        if node.doc:
+            self.emit_ln(node, node.doc.value)
+        self.emit_ln(node, "check = __jac_check()")
+        self.emit_ln(node, node.body.meta["py_code"])
+        self.indent_level -= 1
+        self.emit_ln(
+            node,
+            f"__jac_suite__.addTest(__jac_unittest__.FunctionTestCase(test_{test_name}))",
+        )
 
     def exit_module_code(self, node: ast.ModuleCode) -> None:
         """Sub objects.
 
-        doc: Optional["Token"],
-        body: "CodeBlock",
+        doc: Optional[Token],
+        name: Optional[Name],
+        body: CodeBlock,
+
         """
         if node.doc:
             self.emit_ln(node, node.doc.value)
-        self.emit(node, node.body.meta["py_code"])
+        if node.name:
+            self.emit_ln(node, f"if __name__ == '{node.name.meta['py_code']}':")
+            self.indent_level += 1
+            self.emit(node, node.body.meta["py_code"])
+            self.indent_level -= 1
+        else:
+            self.emit(node, node.body.meta["py_code"])
+
+    def exit_py_inline_code(self, node: ast.PyInlineCode) -> None:
+        """Sub objects.
+
+        code: Token,
+        """
+        self.emit_ln(node, node.code.value)
 
     def exit_import(self, node: ast.Import) -> None:
         """Sub objects.
@@ -225,6 +256,7 @@ class BluePygenPass(Pass):
                 self.warning(
                     "Includes import * in target module into current namespace."
                 )
+            return
         if not node.items:
             if not node.alias:
                 self.emit_ln(node, f"import {node.path.meta['py_code']}")
@@ -290,8 +322,6 @@ class BluePygenPass(Pass):
             self.emit_ln(node, node.doc.value)
         if node.body:
             self.emit(node, node.body.meta["py_code"])
-        else:
-            self.decl_def_missing(node.name.meta["py_code"])
         self.indent_level -= 1
 
     def exit_arch_def(self, node: ast.ArchDef) -> None:
@@ -322,15 +352,16 @@ class BluePygenPass(Pass):
     def exit_ability(self, node: ast.Ability) -> None:
         """Sub objects.
 
-        name: Name,
+        name_ref: Name | SpecialVarRef | ArchRef,
         is_func: bool,
         is_async: bool,
         is_static: bool,
+        is_abstract: bool,
         doc: Optional[Token],
-        decorators: Optional["Decorators"],
+        decorators: Optional[Decorators],
         access: Optional[Token],
-        signature: Optional["FuncSignature | TypeSpec | EventSignature"],
-        body: Optional["CodeBlock"],
+        signature: Optional[FuncSignature | TypeSpec | EventSignature],
+        body: Optional[CodeBlock],
         arch_attached: Optional["ArchBlock"] = None,
         """
         ability_name = node.py_resolve_name()
@@ -339,9 +370,15 @@ class BluePygenPass(Pass):
         if node.decorators:
             self.emit(node, node.decorators.meta["py_code"])
         if isinstance(node.signature, (ast.FuncSignature, ast.EventSignature)):
+            if "->" in node.signature.meta["py_code"]:
+                node.signature.meta["py_code"] = node.signature.meta["py_code"].replace(
+                    " ->", ") ->"
+                )
+            else:
+                node.signature.meta["py_code"] += ")"
             if node.arch_attached and not node.is_static:
                 self.emit_ln(
-                    node, f"def {ability_name}(self{node.signature.meta['py_code']}:"
+                    node, f"def {ability_name}(self,{node.signature.meta['py_code']}:"
                 )
             else:
                 if node.arch_attached and node.is_static:
@@ -363,8 +400,8 @@ class BluePygenPass(Pass):
             self.emit(node, node.body.meta["py_code"])
             self.indent_level -= 1
             self.emit_jac_error_handler(node)
-        else:
-            self.decl_def_missing(ability_name)
+        elif node.is_abstract:
+            self.emit_ln(node, "pass")
         self.indent_level -= 1
 
     def exit_ability_def(self, node: ast.AbilityDef) -> None:
@@ -381,40 +418,55 @@ class BluePygenPass(Pass):
 
         members: list["ArchHas | Ability"],
         """
-        has_members = [
-            i for i in node.members if isinstance(i, ast.ArchHas) and not i.is_static
-        ]
-        if has_members:
-            self.emit_ln(node, "def __jac_has(self):")
-            self.indent_level += 1
-            for i in has_members:
-                self.emit_ln(node, f"self._jac_has_{i.h_id}()")
-            self.indent_level -= 1
-
         init_func = None
         for i in node.members:
             if isinstance(i, ast.Ability) and i.py_resolve_name() == "__init__":
                 init_func = i
                 break
-        if init_func and init_func.signature:
-            if init_func.decorators:
-                self.emit(node, init_func.decorators.meta["py_code"])
-            self.emit_ln(
-                node, f"def __init__(self{init_func.signature.meta['py_code']}:"
-            )
-        else:
-            self.emit_ln(node, "def __init__(self, *args, **kwargs):")
+        static_has_members = [
+            i for i in node.members if isinstance(i, ast.ArchHas) and i.is_static
+        ]
+        for i in static_has_members:
+            self.emit(node, i.meta["py_code"])
+            self.emit(node, "\n")
+
+        if init_func and init_func.decorators:
+            self.emit(node, init_func.decorators.meta["py_code"])
+        self.emit_ln(node, "def __init__(self,")
         self.indent_level += 1
+        if has_members := [
+            i for i in node.members if isinstance(i, ast.ArchHas) and not i.is_static
+        ]:
+            for i in has_members:
+                for j in i.vars.vars:
+                    self.emit_ln(node, f"{j.name.value} = None,")
+        if init_func and init_func.signature:
+            if "->" in init_func.signature.meta["py_code"]:
+                init_func.signature.meta["py_code"] = init_func.signature.meta[
+                    "py_code"
+                ].split("->")[0]
+            if len(init_func.signature.meta["py_code"]):
+                self.emit_ln(node, f"{init_func.signature.meta['py_code']},")
+        self.emit_ln(node, " *args, **kwargs):")
         if not init_func:
             self.emit_ln(node, "super().__init__(*args, **kwargs)")
-        if has_members:
-            self.emit_ln(node, "self.__jac_has()")
+        for i in has_members:
+            for j in i.vars.vars:
+                if j.value:
+                    self.emit_ln(
+                        node,
+                        f"self.{j.name.value} = {j.value.meta['py_code']} if {j.name.value} is "
+                        f"None else {j.name.value}",
+                    )
+                else:
+                    self.emit_ln(node, f"self.{j.name.value} = {j.name.value}")
         if init_func and init_func.body:
             self.emit(node, f"{init_func.body.meta['py_code']}")
         self.indent_level -= 1
         for i in node.members:
-            self.emit(node, i.meta["py_code"])
-            self.emit(node, "\n")
+            if i not in has_members + static_has_members:
+                self.emit(node, i.meta["py_code"])
+                self.emit(node, "\n")
 
     def exit_arch_has(self, node: ast.ArchHas) -> None:
         """Sub objects.
@@ -425,17 +477,7 @@ class BluePygenPass(Pass):
         vars: "HasVarList",
         is_frozen: bool,
         """
-        if node.is_static:
-            if node.doc:
-                self.emit_ln(node, node.doc.value)
-            self.emit_ln(node, node.vars.meta["py_code"].replace("self.", ""))
-        else:
-            self.emit_ln(node, f"def _jac_has_{node.h_id}(self):")
-            self.indent_level += 1
-            if node.doc:
-                self.emit_ln(node, node.doc.value)
-            self.emit(node, node.vars.meta["py_code"])
-            self.indent_level -= 1
+        self.emit(node, node.vars.meta["py_code"])
 
     def exit_has_var_list(self, node: ast.HasVarList) -> None:
         """Sub objects.
@@ -455,11 +497,11 @@ class BluePygenPass(Pass):
         if node.value:
             self.emit(
                 node,
-                f"self.{node.name.value}: {node.type_tag.meta['py_code']} = {node.value.meta['py_code']}",
+                f"{node.name.value}: {node.type_tag.meta['py_code']} = {node.value.meta['py_code']}",
             )
         else:
             self.emit(
-                node, f"self.{node.name.value}: {node.type_tag.meta['py_code']} = None"
+                node, f"{node.name.value}: {node.type_tag.meta['py_code']} = None"
             )
 
     def exit_type_spec_list(self, node: ast.TypeSpecList) -> None:
@@ -503,6 +545,13 @@ class BluePygenPass(Pass):
         """
         self.emit(node, ".".join([i.meta["py_code"] for i in node.names]))
 
+    def exit_arch_ref_chain(self, node: ast.ArchRefChain) -> None:
+        """Sub objects.
+
+        archs: list[ArchRef],
+        """
+        self.emit(node, ".".join([i.meta["py_code"] for i in node.archs]))
+
     def exit_func_signature(self, node: ast.FuncSignature) -> None:
         """Sub objects.
 
@@ -511,20 +560,7 @@ class BluePygenPass(Pass):
         self.is_arch_attached = False
         """
         if node.params:
-            if (
-                isinstance(node.parent, ast.Ability)
-                and node.parent.arch_attached
-                and not node.parent.is_static
-            ):
-                self.emit(node, ", ")
             self.emit(node, node.params.meta["py_code"])
-        if (
-            isinstance(node.parent, ast.Ability)
-            and node.parent.arch_attached
-            and node.parent.py_resolve_name() == "__init__"
-        ):
-            self.emit(node, ", *args, **kwargs")
-        self.emit(node, ")")
         if node.return_type:
             self.emit(node, f" -> {node.return_type.meta['py_code']}")
 
@@ -582,8 +618,6 @@ class BluePygenPass(Pass):
             self.emit_ln(node, node.doc.value)
         if node.body:
             self.emit(node, node.body.meta["py_code"])
-        else:
-            self.decl_def_missing(node.name.meta["py_code"])
         self.indent_level -= 1
 
     def exit_enum_def(self, node: ast.EnumDef) -> None:
@@ -603,7 +637,7 @@ class BluePygenPass(Pass):
             if isinstance(i, ast.Name):
                 self.emit_ln(node, i.meta["py_code"] + " = __jac_auto__()")
             else:
-                self.emit(node, i.meta["py_code"])
+                self.emit_ln(node, i.meta["py_code"])
 
     def exit_code_block(self, node: ast.CodeBlock) -> None:
         """Sub objects.
@@ -1237,9 +1271,13 @@ class BluePygenPass(Pass):
 
         values: list[Assignment],
         """
-        self.emit(
-            node, f"{', '.join([value.meta['py_code'] for value in node.values])}"
-        )
+        if isinstance(node.parent, ast.GlobalVars):
+            for i in node.values:
+                self.emit_ln(node, i.meta["py_code"])
+        else:
+            self.emit(
+                node, f"{', '.join([value.meta['py_code'] for value in node.values])}"
+            )
 
     def exit_index_slice(self, node: ast.IndexSlice) -> None:
         """Sub objects.

jaclang/jac/passes/blue/decl_def_match_pass.py

@@ -2,290 +2,62 @@
 import jaclang.jac.absyntree as ast
 from jaclang.jac.passes import Pass
 from jaclang.jac.passes.blue import SubNodeTabPass
-from jaclang.jac.sym_table import DefDeclSymbol, SymbolTable
+from jaclang.jac.symtable import SymbolHitType, SymbolTable, SymbolType
 
 
-class DeclDefMatchPass(Pass, SymbolTable):
+class DeclDefMatchPass(Pass):
     """Decls and Def matching pass."""
 
     def before_pass(self) -> None:
-        """Initialize pass."""
-        self.sym_tab = SymbolTable(scope_name="global")
+        """Before pass."""
+        self.need_match = []
+        if not self.ir.sym_tab:
+            return self.ice("Expected symbol table on node.")
+        self.connect_decl_def(self.ir.sym_tab)
+        self.terminate()
 
     def after_pass(self) -> None:
         """Rebuild sub node table."""
-        self.ir = SubNodeTabPass(mod_path=self.mod_path, input_ir=self.ir).ir
-
-    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 not isinstance(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.")
+        self.ir = SubNodeTabPass(
+            prior=self, mod_path=self.mod_path, input_ir=self.ir
+        ).ir
+
+    def connect_decl_def(self, sym_tab: SymbolTable) -> None:
+        """Connect Decls and Defs."""
+        for sym in sym_tab.tab.values():
+            if sym.sym_type == SymbolType.IMPL:
+                # currently strips the type info from impls
+                arch_refs = [x[3:] for x in sym.name.split(".")]
+                lookup = sym_tab.lookup(arch_refs[0], sym_hit=SymbolHitType.DECL_DEFN)
+                decl_node = lookup.decl if lookup else None
+                for name in arch_refs[1:]:
+                    if decl_node:
+                        lookup = (
+                            decl_node.sym_tab.lookup(
+                                name, sym_hit=SymbolHitType.DECL_DEFN
+                            )
+                            if decl_node.sym_tab
+                            else None
+                        )
+                        decl_node = lookup.decl if lookup else None
                     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)
+                        break
+                if not decl_node:
+                    self.error(
+                        f"Unable to match implementation {sym.name} to a declaration.",
+                        sym.defn[-1],
                     )
-
-    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[DottedNameList],
-        arch: ObjectRef | NodeRef | EdgeRef | WalkerRef,
-        body: ArchBlock,
-        """
-
-    def enter_ability(self, node: ast.Ability) -> None:
-        """Sub objects.
-
-        name_ref: Name | SpecialVarRef | ArchRef,
-        is_func: bool,
-        is_async: bool,
-        is_static: bool,
-        doc: Optional[Token],
-        decorators: Optional["Decorators"],
-        access: Optional[Token],
-        signature: Optional["FuncSignature | TypeSpec | EventSignature"],
-        body: Optional["CodeBlock"],
-
-        arch_attached: Optional["ArchBlock"] = None,
-        """
-        self.sym_tab = self.sym_tab.push(node.py_resolve_name())
-
-    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,
-        """
-        self.sym_tab = self.sym_tab.pop()
-        ability_name = node.py_resolve_name()
-        name = (
-            f"{node.arch_attached.parent.name.value}.{ability_name}"
-            if node.arch_attached
-            and isinstance(node.arch_attached.parent, ast.Architype)
-            else ability_name
-        )
-        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 isinstance(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)
-
-    def enter_ability_def(self, node: ast.AbilityDef) -> None:
-        """Sub objects.
-
-        doc: Optional[DocString],
-        target: Optional["DottedNameList"],
-        ability: "ArchRef",
-        signature: "FuncSignature | EventSignature",
-        body: "CodeBlock",
-        """
-        self.sym_tab = self.sym_tab.push(node.ability.py_resolve_name())
-
-    def exit_ability_def(self, node: ast.AbilityDef) -> None:
-        """Sub objects.
-
-        doc: Optional[DocString],
-        target: Optional["DottedNameList"],
-        ability: "ArchRef",
-        signature: "FuncSignature | EventSignature",
-        body: "CodeBlock",
-        """
-        self.sym_tab = self.sym_tab.pop()
-        name = node.ability.py_resolve_name()
-        if node.target:
-            owner = node.target.names[-1]
-            if not isinstance(owner, ast.ArchRef):
-                self.error("Expected reference to Architype!")
-                owner = ""
-            else:
-                owner = owner.py_resolve_name()
-            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
-
-    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 isinstance(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[Token],
-        enum: ArchRef,
-        mod: Optional[DottedNameList],
-        body: EnumBlock,
-        """
-        name = node.enum.py_resolve_name()
-        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))
+                    continue
+                elif isinstance(decl_node, ast.Ability) and decl_node.is_abstract:
+                    self.error(
+                        f"Abstract ability {decl_node.py_resolve_name()} should not have a definition.",
+                        decl_node,
+                    )
+                    continue
+                ast.append_node(decl_node, sym.defn[-1].body)  # type: ignore
+                decl_node.body = sym.defn[-1].body  # type: ignore
+                decl_node.sym_tab.tab = sym.defn[-1].sym_tab.tab  # type: ignore
+                sym.decl = decl_node
+
+        for i in sym_tab.kid:
+            self.connect_decl_def(i)

jaclang/jac/passes/blue/import_pass.py

@@ -26,7 +26,7 @@ class ImportPass(Pass):
                     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)
+            SubNodeTabPass(prior=self, mod_path=node.mod_path, input_ir=node)
 
     def enter_import(self, node: ast.Import) -> None:
         """Sub objects.