jaclang 0.7.5__py3-none-any.whl → 0.7.6__py3-none-any.whl

jaclang/compiler/passes/main/def_use_pass.py

@@ -10,28 +10,15 @@ import ast as ast3
 
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.constant import Tokens as Tok
-from jaclang.compiler.passes.main.sym_tab_build_pass import SymTabPass
+from jaclang.compiler.passes import Pass
 
 
-class DefUsePass(SymTabPass):
+class DefUsePass(Pass):
     """Jac Ast build pass."""
 
     def after_pass(self) -> None:
         """After pass."""
 
-    def inherit_baseclasses_sym(self, node: ast.Architype | ast.Enum) -> None:
-        """Inherit base classes symbol tables."""
-        if node.base_classes:
-            for cls in node.base_classes.items:
-                if (
-                    isinstance(cls, ast.AstSymbolNode)
-                    and (found := self.use_lookup(cls))
-                    and found
-                    and found.decl.sym_tab
-                    and node.sym_tab
-                ):
-                    node.sym_tab.inherit.append(found.decl.sym_tab)
-
     def enter_architype(self, node: ast.Architype) -> None:
         """Sub objects.
 
@@ -44,7 +31,7 @@ class DefUsePass(SymTabPass):
         semstr: Optional[String] = None,
         decorators: Optional[SubNodeList[Expr]] = None,
         """
-        self.inherit_baseclasses_sym(node)
+        node.sym_tab.inherit_baseclasses_sym(node)
 
         def inform_from_walker(node: ast.AstNode) -> None:
             for i in (
@@ -72,7 +59,7 @@ class DefUsePass(SymTabPass):
         semstr: Optional[String] = None,
         decorators: Optional[SubNodeList[Expr]] = None,
         """
-        self.inherit_baseclasses_sym(node)
+        node.sym_tab.inherit_baseclasses_sym(node)
 
     def enter_arch_ref(self, node: ast.ArchRef) -> None:
         """Sub objects.
@@ -80,14 +67,14 @@ class DefUsePass(SymTabPass):
         name_ref: NameType,
         arch: Token,
         """
-        self.use_lookup(node)
+        node.sym_tab.use_lookup(node)
 
     def enter_arch_ref_chain(self, node: ast.ArchRefChain) -> None:
         """Sub objects.
 
         archs: list[ArchRef],
         """
-        self.chain_use_lookup(node.archs)
+        node.sym_tab.chain_use_lookup(node.archs)
 
     def enter_param_var(self, node: ast.ParamVar) -> None:
         """Sub objects.
@@ -97,7 +84,7 @@ class DefUsePass(SymTabPass):
         type_tag: SubTag[ExprType],
         value: Optional[ExprType],
         """
-        self.def_insert(node)
+        node.sym_tab.def_insert(node)
 
     def enter_has_var(self, node: ast.HasVar) -> None:
         """Sub objects.
@@ -109,7 +96,7 @@ class DefUsePass(SymTabPass):
         if isinstance(node.parent, ast.SubNodeList) and isinstance(
             node.parent.parent, ast.ArchHas
         ):
-            self.def_insert(
+            node.sym_tab.def_insert(
                 node,
                 single_decl="has var",
                 access_spec=node.parent.parent,
@@ -128,9 +115,9 @@ class DefUsePass(SymTabPass):
         """
         for i in node.target.items:
             if isinstance(i, ast.AtomTrailer):
-                self.chain_def_insert(self.unwind_atom_trailer(i))
+                i.sym_tab.chain_def_insert(i.as_attr_list)
             elif isinstance(i, ast.AstSymbolNode):
-                self.def_insert(i)
+                i.sym_tab.def_insert(i)
             else:
                 self.error("Assignment target not valid")
 
@@ -143,9 +130,9 @@ class DefUsePass(SymTabPass):
         conditional: Optional[ExprType],
         """
         if isinstance(node.target, ast.AtomTrailer):
-            self.chain_def_insert(self.unwind_atom_trailer(node.target))
+            node.target.sym_tab.chain_def_insert(node.target.as_attr_list)
         elif isinstance(node.target, ast.AstSymbolNode):
-            self.def_insert(node.target)
+            node.target.sym_tab.def_insert(node.target)
         else:
             self.error("Named target not valid")
 
@@ -156,8 +143,8 @@ class DefUsePass(SymTabPass):
         right: AtomType,
         is_scope_contained: bool,
         """
-        chain = self.unwind_atom_trailer(node)
-        self.chain_use_lookup(chain)
+        chain = node.as_attr_list
+        node.sym_tab.chain_use_lookup(chain)
 
     def enter_func_call(self, node: ast.FuncCall) -> None:
         """Sub objects.
@@ -179,7 +166,7 @@ class DefUsePass(SymTabPass):
 
         var: Token,
         """
-        self.use_lookup(node)
+        node.sym_tab.use_lookup(node)
 
     def enter_edge_op_ref(self, node: ast.EdgeOpRef) -> None:
         """Sub objects.
@@ -232,7 +219,7 @@ class DefUsePass(SymTabPass):
         pos_start: int,
         pos_end: int,
         """
-        self.use_lookup(node)
+        node.sym_tab.use_lookup(node)
 
     def enter_int(self, node: ast.Int) -> None:
         """Sub objects.
@@ -245,7 +232,7 @@ class DefUsePass(SymTabPass):
         pos_start: int,
         pos_end: int,
         """
-        self.use_lookup(node)
+        node.sym_tab.use_lookup(node)
 
     def enter_string(self, node: ast.String) -> None:
         """Sub objects.
@@ -258,7 +245,7 @@ class DefUsePass(SymTabPass):
         pos_start: int,
         pos_end: int,
         """
-        self.use_lookup(node)
+        node.sym_tab.use_lookup(node)
 
     def enter_bool(self, node: ast.Bool) -> None:
         """Sub objects.
@@ -271,7 +258,7 @@ class DefUsePass(SymTabPass):
         pos_start: int,
         pos_end: int,
         """
-        self.use_lookup(node)
+        node.sym_tab.use_lookup(node)
 
     def enter_builtin_type(self, node: ast.BuiltinType) -> None:
         """Sub objects.
@@ -285,7 +272,7 @@ class DefUsePass(SymTabPass):
         pos_end: int,
         typ: type,
         """
-        self.use_lookup(node)
+        node.sym_tab.use_lookup(node)
 
     def enter_name(self, node: ast.Name) -> None:
         """Sub objects.
@@ -297,7 +284,8 @@ class DefUsePass(SymTabPass):
         pos_start: int,
         pos_end: int,
         """
-        self.use_lookup(node)
+        if not isinstance(node.parent, ast.AtomTrailer):
+            node.sym_tab.use_lookup(node)
 
     def enter_in_for_stmt(self, node: ast.InForStmt) -> None:
         """Sub objects.
@@ -309,9 +297,9 @@ class DefUsePass(SymTabPass):
         else_body: Optional[ElseStmt],
         """
         if isinstance(node.target, ast.AtomTrailer):
-            self.chain_def_insert(self.unwind_atom_trailer(node.target))
+            node.target.sym_tab.chain_def_insert(node.target.as_attr_list)
         elif isinstance(node.target, ast.AstSymbolNode):
-            self.def_insert(node.target)
+            node.target.sym_tab.def_insert(node.target)
         else:
             self.error("For loop assignment target not valid")
 
@@ -327,7 +315,7 @@ class DefUsePass(SymTabPass):
         )
         for i in items:
             if isinstance(i, ast.AtomTrailer):
-                self.unwind_atom_trailer(i)[-1].name_spec.py_ctx_func = ast3.Del
+                i.as_attr_list[-1].name_spec.py_ctx_func = ast3.Del
             elif isinstance(i, ast.AstSymbolNode):
                 i.name_spec.py_ctx_func = ast3.Del
             else:
@@ -341,8 +329,8 @@ class DefUsePass(SymTabPass):
         """
         if node.alias:
             if isinstance(node.alias, ast.AtomTrailer):
-                self.chain_def_insert(self.unwind_atom_trailer(node.alias))
+                node.alias.sym_tab.chain_def_insert(node.alias.as_attr_list)
             elif isinstance(node.alias, ast.AstSymbolNode):
-                self.def_insert(node.alias)
+                node.alias.sym_tab.def_insert(node.alias)
             else:
                 self.error("For expr as target not valid")

jaclang/compiler/passes/main/fuse_typeinfo_pass.py

@@ -11,6 +11,7 @@ from typing import Callable, TypeVar
 
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.passes import Pass
+from jaclang.compiler.symtable import SymbolTable
 from jaclang.settings import settings
 from jaclang.utils.helpers import pascal_to_snake
 from jaclang.vendor.mypy.nodes import Node as VNode  # bit of a hack
@@ -183,18 +184,6 @@ class FuseTypeInfoPass(Pass):
         """Pass handler for name nodes."""
         self.__collect_type_from_symbol(node)
 
-        # Assign correct symbols to sym_link in case of
-        # AtomTrailer Object
-        if isinstance(node.parent, ast.AtomTrailer):
-            target_node = node.parent.target
-            if isinstance(target_node, ast.AstSymbolNode):
-                parent_symbol_table = target_node.type_sym_tab
-                if isinstance(parent_symbol_table, ast.SymbolTable):
-                    owner = parent_symbol_table.owner
-                    if isinstance(owner, ast.AstSymbolNode):
-                        target_node.name_spec.sym = owner.sym
-                        node.sym = parent_symbol_table.lookup(node.sym_name)
-
     @__handle_node
     def enter_module_path(self, node: ast.ModulePath) -> None:
         """Pass handler for ModulePath nodes."""
@@ -442,3 +431,36 @@ class FuseTypeInfoPass(Pass):
     ) -> None:
         """Get type info from mypy type TupleType."""
         node.name_spec.sym_type = "builtins.tuple"
+
+    def exit_assignment(self, node: ast.Assignment) -> None:
+        """Add new symbols in the symbol table in case of self."""
+        # This will fix adding new items to the class through self
+        # self.x = 5  # will add x to self datatype symbol table
+        for target in node.target.items:
+            if (
+                isinstance(target, ast.AtomTrailer)
+                and isinstance(target.target, ast.SpecialVarRef)
+                and target.target.sym_name == "self"
+            ):
+                self_obj = target.target
+                right_obj = target.right
+                if self_obj.type_sym_tab and isinstance(right_obj, ast.AstSymbolNode):
+                    self_obj.type_sym_tab.def_insert(right_obj)
+
+    def exit_name(self, node: ast.Name) -> None:
+        """Add new symbols in the symbol table in case of atom trailer."""
+        if isinstance(node.parent, ast.AtomTrailer):
+            target_node = node.parent.target
+            if isinstance(target_node, ast.AstSymbolNode):
+                parent_symbol_table = target_node.type_sym_tab
+                if isinstance(parent_symbol_table, SymbolTable):
+                    node.sym = parent_symbol_table.lookup(node.sym_name)
+
+    # def exit_in_for_stmt(self, node: ast.InForStmt):
+    #     print(node.loc.mod_path, node.loc)
+    #     print(node.target, node.target.loc)
+    #     # node.sym_tab.def_insert()
+    #     # exit()
+
+    # def after_pass(self) -> None:
+    #     exit()

jaclang/compiler/passes/main/sub_node_tab_pass.py

@@ -6,7 +6,6 @@ pass and is not required for any other pass to work.
 """
 
 from copy import copy
-from typing import Optional
 
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.passes import Pass
@@ -15,10 +14,6 @@ from jaclang.compiler.passes import Pass
 class SubNodeTabPass(Pass):
     """AST Enrichment Pass for basic high level semantics."""
 
-    def before_pass(self) -> None:
-        """Initialize pass."""
-        self.cur_module: Optional[ast.Module] = None
-
     def enter_node(self, node: ast.AstNode) -> None:
         """Table builder."""
         super().enter_node(node)

jaclang/compiler/passes/main/sym_tab_build_pass.py

@@ -4,172 +4,19 @@ This pass builds the symbol table tree for the Jaseci Ast. It also adds symbols
 for globals, imports, architypes, and abilities declarations and definitions.
 """
 
-import ast as ast3
 import builtins
-from typing import Optional, Sequence
 
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.constant import Tokens as Tok
 from jaclang.compiler.passes import Pass
-from jaclang.compiler.symtable import Symbol, SymbolAccess, SymbolTable
-
-
-class SymTabPass(Pass):
-    """Jac Ast build pass."""
-
-    def inherit_sym_tab(self, scope: SymbolTable, sym_tab: SymbolTable) -> None:
-        """Inherit symbol table."""
-        for i in sym_tab.tab.values():
-            self.def_insert(i.decl, access_spec=i.access, table_override=scope)
-
-    def def_insert(
-        self,
-        node: ast.AstSymbolNode,
-        access_spec: Optional[ast.AstAccessNode] | SymbolAccess = None,
-        single_decl: Optional[str] = None,
-        table_override: Optional[SymbolTable] = None,
-    ) -> Optional[Symbol]:
-        """Insert into symbol table."""
-        table = table_override if table_override else node.sym_tab
-        if node.sym and table == node.sym.parent_tab:
-            return node.sym
-        if table:
-            table.insert(
-                node=node, single=single_decl is not None, access_spec=access_spec
-            )
-        self.update_py_ctx_for_def(node)
-        return node.sym
-
-    def update_py_ctx_for_def(self, node: ast.AstSymbolNode) -> None:
-        """Update python context for definition."""
-        node.name_spec.py_ctx_func = ast3.Store
-        if isinstance(node.name_spec, ast.AstSymbolNode):
-            node.name_spec.py_ctx_func = ast3.Store
-        if isinstance(node, (ast.TupleVal, ast.ListVal)) and node.values:
-            # Handling of UnaryExpr case for item is only necessary for
-            # the generation of Starred nodes in the AST for examples
-            # like `(a, *b) = (1, 2, 3, 4)`.
-            def fix(item: ast.TupleVal | ast.ListVal | ast.UnaryExpr) -> None:
-                if isinstance(item, ast.UnaryExpr):
-                    if isinstance(item.operand, ast.AstSymbolNode):
-                        item.operand.name_spec.py_ctx_func = ast3.Store
-                elif isinstance(item, (ast.TupleVal, ast.ListVal)):
-                    for i in item.values.items if item.values else []:
-                        if isinstance(i, ast.AstSymbolNode):
-                            i.name_spec.py_ctx_func = ast3.Store
-                        elif isinstance(i, ast.AtomTrailer):
-                            self.chain_def_insert(self.unwind_atom_trailer(i))
-                        if isinstance(i, (ast.TupleVal, ast.ListVal, ast.UnaryExpr)):
-                            fix(i)
-
-            fix(node)
-
-    def use_lookup(
-        self,
-        node: ast.AstSymbolNode,
-        sym_table: Optional[SymbolTable] = None,
-    ) -> Optional[Symbol]:
-        """Link to symbol."""
-        if node.sym:
-            return node.sym
-        if not sym_table:
-            sym_table = node.sym_tab
-        if sym_table:
-            lookup = sym_table.lookup(name=node.sym_name, deep=True)
-            lookup.add_use(node.name_spec) if lookup else None
-        return node.sym
-
-    def chain_def_insert(self, node_list: Sequence[ast.AstSymbolNode]) -> None:
-        """Link chain of containing names to symbol."""
-        if not node_list:
-            return
-        cur_sym_tab = node_list[0].sym_tab
-        node_list[-1].name_spec.py_ctx_func = ast3.Store
-        if isinstance(node_list[-1].name_spec, ast.AstSymbolNode):
-            node_list[-1].name_spec.py_ctx_func = ast3.Store
-
-        node_list = node_list[:-1]  # Just performs lookup mappings of pre assign chain
-        for i in node_list:
-            if cur_sym_tab is None:
-                break
-            cur_sym_tab = (
-                lookup.decl.sym_tab
-                if (
-                    lookup := self.use_lookup(
-                        i,
-                        sym_table=cur_sym_tab,
-                    )
-                )
-                else None
-            )
+from jaclang.compiler.symtable import SymbolTable
 
-    def chain_use_lookup(self, node_list: Sequence[ast.AstSymbolNode]) -> None:
-        """Link chain of containing names to symbol."""
-        if not node_list:
-            return
-        cur_sym_tab = node_list[0].sym_tab
-        for i in node_list:
-            if cur_sym_tab is None:
-                break
-            cur_sym_tab = (
-                lookup.decl.sym_tab
-                if (
-                    lookup := self.use_lookup(
-                        i,
-                        sym_table=cur_sym_tab,
-                    )
-                )
-                else None
-            )
 
-    def unwind_atom_trailer(self, node: ast.AtomTrailer) -> list[ast.AstSymbolNode]:
-        """Sub objects.
-
-        target: ExprType,
-        right: AtomType,
-        is_scope_contained: bool,
-        """
-        left = node.right if isinstance(node.right, ast.AtomTrailer) else node.target
-        right = node.target if isinstance(node.right, ast.AtomTrailer) else node.right
-        trag_list: list[ast.AstSymbolNode] = (
-            [right] if isinstance(right, ast.AstSymbolNode) else []
-        )
-        if not trag_list:
-            self.ice("Something went very wrong with atom trailer not valid")
-        while isinstance(left, ast.AtomTrailer) and left.is_attr:
-            if isinstance(left.right, ast.AstSymbolNode):
-                trag_list.insert(0, left.right)
-            else:
-                raise self.ice("Something went very wrong with atom trailer not valid")
-            left = left.target
-        if isinstance(left, ast.AstSymbolNode):
-            trag_list.insert(0, left)
-        return trag_list
-
-    def already_declared_err(
-        self,
-        name: str,
-        typ: str,
-        original: ast.AstNode,
-        other_nodes: Optional[list[ast.AstNode]] = None,
-    ) -> None:
-        """Already declared error."""
-        err_msg = (
-            f"Name used for {typ} '{name}' already declared at "
-            f"{original.loc.mod_path}, line {original.loc.first_line}"
-        )
-        if other_nodes:
-            for i in other_nodes:
-                err_msg += f", also see {i.loc.mod_path}, line {i.loc.first_line}"
-        self.warning(err_msg)
-
-
-class SymTabBuildPass(SymTabPass):
+class SymTabBuildPass(Pass):
     """Jac Symbol table build pass."""
 
     def before_pass(self) -> None:
         """Before pass."""
-        super().before_pass()
         self.cur_sym_tab: list[SymbolTable] = []
 
     def push_scope(self, name: str, key_node: ast.AstNode, fresh: bool = False) -> None:
@@ -177,19 +24,20 @@ class SymTabBuildPass(SymTabPass):
         if fresh:
             self.cur_sym_tab.append(SymbolTable(name, key_node))
         else:
-            self.cur_sym_tab.append(self.cur_scope().push_scope(name, key_node))
+            self.cur_sym_tab.append(self.cur_scope.push_scope(name, key_node))
 
     def pop_scope(self) -> SymbolTable:
         """Pop scope."""
         return self.cur_sym_tab.pop()
 
+    @property
     def cur_scope(self) -> SymbolTable:
         """Return current scope."""
         return self.cur_sym_tab[-1]
 
     def sync_node_to_scope(self, node: ast.AstNode) -> None:
         """Sync node to scope."""
-        node.sym_tab = self.cur_scope()
+        node.sym_tab = self.cur_scope
 
     def enter_module(self, node: ast.Module) -> None:
         """Sub objects.
@@ -215,7 +63,7 @@ class SymTabBuildPass(SymTabPass):
                 pos_end=0,
             )
             self.sync_node_to_scope(builtin)
-            self.def_insert(builtin)
+            builtin.sym_tab.def_insert(builtin)
         # self.def_insert(ast.Name.gen_stub_from_node(node.name, "root"))
 
     def exit_module(self, node: ast.Module) -> None:
@@ -250,7 +98,7 @@ class SymTabBuildPass(SymTabPass):
         for i in self.get_all_sub_nodes(node, ast.Assignment):
             for j in i.target.items:
                 if isinstance(j, ast.AstSymbolNode):
-                    self.def_insert(j, access_spec=node, single_decl="global var")
+                    j.sym_tab.def_insert(j, access_spec=node, single_decl="global var")
                 else:
                     self.ice("Expected name type for globabl vars")
 
@@ -276,7 +124,14 @@ class SymTabBuildPass(SymTabPass):
         description: Token,
         body: CodeBlock,
         """
+        self.push_scope(node.sym_name, node)
         self.sync_node_to_scope(node)
+        import unittest
+
+        for i in [j for j in dir(unittest.TestCase()) if j.startswith("assert")]:
+            node.sym_tab.def_insert(
+                ast.Name.gen_stub_from_node(node, i, set_name_of=node)
+            )
 
     def exit_test(self, node: ast.Test) -> None:
         """Sub objects.
@@ -286,9 +141,6 @@ class SymTabBuildPass(SymTabPass):
         description: Token,
         body: CodeBlock,
         """
-        self.def_insert(node, single_decl="test")
-        self.push_scope(node.name.value, node)
-        self.sync_node_to_scope(node)
         self.pop_scope()
 
     def enter_module_code(self, node: ast.ModuleCode) -> None:
@@ -340,22 +192,16 @@ class SymTabBuildPass(SymTabPass):
         """
         if not node.is_absorb:
             for i in node.items.items:
-                self.def_insert(i, single_decl="import item")
+                i.sym_tab.def_insert(i, single_decl="import item")
         elif node.is_absorb and node.hint.tag.value == "jac":
             source = node.items.items[0]
-            if (
-                not isinstance(source, ast.ModulePath)
-                or not source.sub_module
-                or not source.sub_module.sym_tab
-            ):
+            if not isinstance(source, ast.ModulePath) or not source.sub_module:
                 self.error(
                     f"Module {node.from_loc.path_str if node.from_loc else 'from location'}"
                     f" not found to include *, or ICE occurred!"
                 )
             else:
-                self.inherit_sym_tab(
-                    scope=self.cur_scope(), sym_tab=source.sub_module.sym_tab
-                )
+                node.sym_tab.inherit_sym_tab(source.sub_module.sym_tab)
 
     def enter_module_path(self, node: ast.ModulePath) -> None:
         """Sub objects.
@@ -374,9 +220,9 @@ class SymTabBuildPass(SymTabPass):
         sub_module: Optional[Module] = None,
         """
         if node.alias:
-            self.def_insert(node.alias, single_decl="import")
+            node.alias.sym_tab.def_insert(node.alias, single_decl="import")
         elif node.path and isinstance(node.path[0], ast.Name):
-            self.def_insert(node.path[0])
+            node.path[0].sym_tab.def_insert(node.path[0])
         else:
             pass  # Need to support pythonic import symbols with dots in it
 
@@ -401,7 +247,7 @@ class SymTabBuildPass(SymTabPass):
         body: Optional[ArchBlock],
         """
         self.sync_node_to_scope(node)
-        self.def_insert(node, access_spec=node, single_decl="architype")
+        node.sym_tab.def_insert(node, access_spec=node, single_decl="architype")
         self.push_scope(node.name.value, node)
         self.sync_node_to_scope(node)
 
@@ -427,7 +273,7 @@ class SymTabBuildPass(SymTabPass):
         body: ArchBlock,
         """
         self.sync_node_to_scope(node)
-        self.def_insert(node, single_decl="arch def")
+        node.sym_tab.def_insert(node, single_decl="arch def")
         self.push_scope(node.sym_name, node)
         self.sync_node_to_scope(node)
 
@@ -455,12 +301,16 @@ class SymTabBuildPass(SymTabPass):
         body: Optional[CodeBlock],
         """
         self.sync_node_to_scope(node)
-        self.def_insert(node, access_spec=node, single_decl="ability")
+        node.sym_tab.def_insert(node, access_spec=node, single_decl="ability")
         self.push_scope(node.sym_name, node)
         self.sync_node_to_scope(node)
         if node.is_method:
-            self.def_insert(ast.Name.gen_stub_from_node(node, "self"))
-            self.def_insert(ast.Name.gen_stub_from_node(node, "super"))
+            node.sym_tab.def_insert(ast.Name.gen_stub_from_node(node, "self"))
+            node.sym_tab.def_insert(
+                ast.Name.gen_stub_from_node(
+                    node, "super", set_name_of=node.owner_method
+                )
+            )
 
     def exit_ability(self, node: ast.Ability) -> None:
         """Sub objects.
@@ -486,7 +336,7 @@ class SymTabBuildPass(SymTabPass):
         body: CodeBlock,
         """
         self.sync_node_to_scope(node)
-        self.def_insert(node, single_decl="ability def")
+        node.sym_tab.def_insert(node, single_decl="ability def")
         self.push_scope(node.sym_name, node)
         self.sync_node_to_scope(node)
 
@@ -546,7 +396,7 @@ class SymTabBuildPass(SymTabPass):
         body: Optional['EnumBlock'],
         """
         self.sync_node_to_scope(node)
-        self.def_insert(node, access_spec=node, single_decl="enum")
+        node.sym_tab.def_insert(node, access_spec=node, single_decl="enum")
         self.push_scope(node.sym_name, node)
         self.sync_node_to_scope(node)
 
@@ -570,7 +420,7 @@ class SymTabBuildPass(SymTabPass):
         body: EnumBlock,
         """
         self.sync_node_to_scope(node)
-        self.def_insert(node, single_decl="enum def")
+        node.sym_tab.def_insert(node, single_decl="enum def")
         self.push_scope(node.sym_name, node)
         self.sync_node_to_scope(node)
 

jaclang/compiler/passes/tool/tests/fixtures/genai/essay_review.jac

@@ -1,4 +1,4 @@
-import:py from jaclang.core.llms, Anthropic;
+import:py from mtllm.llms, Anthropic;
 
 glob llm = Anthropic(model_name="claude-3-sonnet-20240229");
 

jaclang/compiler/passes/tool/tests/fixtures/genai/expert_answer.jac

@@ -1,4 +1,4 @@
-import:py from jaclang.core.llms, Anthropic;
+import:py from mtllm.llms, Anthropic;
 
 glob llm = Anthropic(model_name="claude-3-sonnet-20240229");
 

jaclang/compiler/passes/tool/tests/fixtures/genai/joke_gen.jac

@@ -1,4 +1,4 @@
-import:py from jaclang.core.llms, Anthropic;
+import:py from mtllm.llms, Anthropic;
 
 glob llm = Anthropic(model_name="claude-3-sonnet-20240229");
 

jaclang/compiler/passes/tool/tests/fixtures/genai/odd_word_out.jac

@@ -1,4 +1,4 @@
-import:py from jaclang.core.llms, Anthropic;
+import:py from mtllm.llms, Anthropic;
 
 glob llm = Anthropic(model_name="claude-3-sonnet-20240229");
 

jaclang/compiler/passes/tool/tests/fixtures/genai/personality_finder.jac

@@ -1,4 +1,4 @@
-import:py from jaclang.core.llms, Anthropic;
+import:py from mtllm.llms, Anthropic;
 
 glob llm = Anthropic(model_name="claude-3-sonnet-20240229");
 

jaclang/compiler/passes/tool/tests/fixtures/genai/text_to_type.jac

@@ -1,4 +1,4 @@
-import:py from jaclang.core.llms, Anthropic;
+import:py from mtllm.llms, Anthropic;
 
 glob llm = Anthropic(model_name="claude-3-sonnet-20240229");
 

jaclang/compiler/passes/tool/tests/fixtures/genai/translator.jac

@@ -1,4 +1,4 @@
-import:py from jaclang.core.llms, Anthropic;
+import:py from mtllm.llms, Anthropic;
 
 glob llm = Anthropic(model_name="claude-3-sonnet-20240229");