jaclang 0.7.2__py3-none-any.whl → 0.7.8__py3-none-any.whl

jaclang/compiler/passes/main/def_impl_match_pass.py

@@ -28,26 +28,33 @@ class DeclImplMatchPass(Pass):
         """Rebuild sub node table."""
         self.ir = SubNodeTabPass(input_ir=self.ir, prior=self).ir
 
-    def defn_lookup(self, lookup: Symbol) -> ast.AstImplNeedingNode | None:
+    def defn_lookup(self, lookup: Symbol) -> ast.NameAtom | None:
         """Lookup a definition in a symbol table."""
         for defn in range(len(lookup.defn)):
             candidate = lookup.defn[len(lookup.defn) - (defn + 1)]
-            if isinstance(candidate, ast.AstImplNeedingNode) and candidate.needs_impl:
+            if (
+                isinstance(candidate.name_of, ast.AstImplNeedingNode)
+                and candidate.name_of.needs_impl
+            ):
                 return candidate
         return None
 
     def connect_def_impl(self, sym_tab: SymbolTable) -> None:
         """Connect Decls and Defs."""
         for sym in sym_tab.tab.values():
-            if isinstance(sym.decl, ast.AstImplOnlyNode):
+            if isinstance(sym.decl.name_of, ast.AstImplOnlyNode):
                 # currently strips the type info from impls
                 arch_refs = [x[3:] for x in sym.sym_name.split(".")]
-                name_of_links = []  # to link archref names to decls
+                name_of_links: list[ast.NameAtom] = []  # to link archref names to decls
                 lookup = sym_tab.lookup(arch_refs[0])
                 # If below may need to be a while instead of if to skip over local
                 # import name collisions (see test: test_impl_decl_resolution_fix)
-                if lookup and not isinstance(lookup.decl, ast.AstImplNeedingNode):
-                    lookup = sym_tab.parent.lookup(arch_refs[0])
+                if lookup and not isinstance(
+                    lookup.decl.name_of, ast.AstImplNeedingNode
+                ):
+                    lookup = (
+                        sym_tab.parent.lookup(arch_refs[0]) if sym_tab.parent else None
+                    )
                 decl_node = (
                     self.defn_lookup(lookup)
                     if len(arch_refs) == 1 and lookup
@@ -57,8 +64,8 @@ class DeclImplMatchPass(Pass):
                 for name in arch_refs[1:]:
                     if decl_node:
                         lookup = (
-                            decl_node.sym_tab.lookup(name)
-                            if decl_node.sym_tab
+                            decl_node.name_of.sym_tab.lookup(name, deep=False)
+                            if decl_node.name_of.sym_tab
                             else None
                         )
                         decl_node = (
@@ -77,11 +84,18 @@ class DeclImplMatchPass(Pass):
                         decl_node,
                     )
                     continue
-                decl_node.body = sym.decl  # type: ignore
-                sym.decl.decl_link = decl_node  # type: ignore
-                for idx, a in enumerate(sym.decl.target.archs):
-                    if isinstance(a.name_ref.sym_name_node, ast.NameSpec):
-                        a.name_ref.sym_name_node.name_of = name_of_links[idx]
-                decl_node.sym_tab.tab = sym.decl.sym_tab.tab  # type: ignore
+                if not isinstance(
+                    valid_decl := decl_node.name_of, ast.AstImplNeedingNode
+                ) or not (valid_decl.sym_tab and sym.decl.name_of.sym_tab):
+                    raise self.ice(
+                        f"Expected AstImplNeedingNode, got {valid_decl.__class__.__name__}. Not possible."
+                    )
+                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.archs):
+                    a.name_spec.name_of = name_of_links[idx].name_of
+                    a.name_spec.sym = name_of_links[idx].sym
+                sym.decl.name_of.sym_tab.tab.update(valid_decl.sym_tab.tab)
+                valid_decl.sym_tab.tab = sym.decl.name_of.sym_tab.tab
         for i in sym_tab.kid:
             self.connect_def_impl(i)

jaclang/compiler/passes/main/def_use_pass.py

@@ -10,10 +10,10 @@ 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:
@@ -23,25 +23,43 @@ class DefUsePass(SymTabPass):
         """Sub objects.
 
         name: Name,
-        doc: Optional[Token],
-        body: Optional[SubNodeList[ArchStmt]],
-        sym_tab: Optional[SymbolTable],
+        arch_type: Token,
+        access: Optional[SubTag[Token]],
+        base_classes: Optional[SubNodeList[Expr]],
+        body: Optional[SubNodeList[ArchBlockStmt] | ArchDef],
+        doc: Optional[String] = None,
+        semstr: Optional[String] = None,
+        decorators: Optional[SubNodeList[Expr]] = None,
         """
+        node.sym_tab.inherit_baseclasses_sym(node)
+
+        def inform_from_walker(node: ast.AstNode) -> None:
+            for i in (
+                node.get_all_sub_nodes(ast.VisitStmt)
+                + node.get_all_sub_nodes(ast.IgnoreStmt)
+                + node.get_all_sub_nodes(ast.DisengageStmt)
+                + node.get_all_sub_nodes(ast.EdgeOpRef)
+            ):
+                i.from_walker = True
+
         if node.arch_type.name == Tok.KW_WALKER:
-            self.inform_from_walker(node)
+            inform_from_walker(node)
             for i in self.get_all_sub_nodes(node, ast.Ability):
                 if isinstance(i.body, ast.AbilityDef):
-                    self.inform_from_walker(i.body)
-
-    def inform_from_walker(self, node: ast.AstNode) -> None:
-        """Inform all sub nodes that they are from a walker."""
-        for i in (
-            self.get_all_sub_nodes(node, ast.VisitStmt)
-            + self.get_all_sub_nodes(node, ast.IgnoreStmt)
-            + self.get_all_sub_nodes(node, ast.DisengageStmt)
-            + self.get_all_sub_nodes(node, ast.EdgeOpRef)
-        ):
-            i.from_walker = True
+                    inform_from_walker(i.body)
+
+    def enter_enum(self, node: ast.Enum) -> None:
+        """Sub objects.
+
+        name: Name,
+        access: Optional[SubTag[Token]],
+        base_classes: Optional[SubNodeList[Expr]],
+        body: Optional[SubNodeList[EnumBlockStmt] | EnumDef],
+        doc: Optional[String] = None,
+        semstr: Optional[String] = None,
+        decorators: Optional[SubNodeList[Expr]] = None,
+        """
+        node.sym_tab.inherit_baseclasses_sym(node)
 
     def enter_arch_ref(self, node: ast.ArchRef) -> None:
         """Sub objects.
@@ -49,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.
@@ -66,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.
@@ -78,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,
@@ -97,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")
 
@@ -112,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")
 
@@ -125,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.
@@ -148,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.
@@ -201,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.
@@ -214,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.
@@ -227,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.
@@ -240,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.
@@ -254,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.
@@ -266,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.
@@ -278,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")
 
@@ -296,9 +315,9 @@ class DefUsePass(SymTabPass):
         )
         for i in items:
             if isinstance(i, ast.AtomTrailer):
-                self.unwind_atom_trailer(i)[-1].py_ctx_func = ast3.Del
+                i.as_attr_list[-1].name_spec.py_ctx_func = ast3.Del
             elif isinstance(i, ast.AstSymbolNode):
-                i.py_ctx_func = ast3.Del
+                i.name_spec.py_ctx_func = ast3.Del
             else:
                 self.error("Delete target not valid")
 
@@ -310,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
@@ -46,7 +47,7 @@ class FuseTypeInfoPass(Pass):
             )
 
     def __set_sym_table_link(self, node: ast.AstSymbolNode) -> None:
-        typ = node.sym_info.typ.split(".")
+        typ = node.sym_type.split(".")
         typ_sym_table = self.ir.sym_tab
 
         if typ[0] == "builtins":
@@ -63,7 +64,7 @@ class FuseTypeInfoPass(Pass):
                     typ_sym_table = f
 
         if typ_sym_table != self.ir.sym_tab:
-            node.sym_info.typ_sym_table = typ_sym_table
+            node.name_spec.type_sym_tab = typ_sym_table
 
     @staticmethod
     def __handle_node(
@@ -133,7 +134,7 @@ class FuseTypeInfoPass(Pass):
                     t = t.split("->")[1].strip()
                 elif "def" in t:
                     t = "None"
-                node.sym_info.typ = t
+                node.name_spec.sym_type = t
             else:
                 self.__debug_print(f"{node.loc} MemberExpr type is not found")
 
@@ -145,16 +146,16 @@ class FuseTypeInfoPass(Pass):
                 self.__call_type_handler(node, mypy_node.type)
 
             elif isinstance(mypy_node, MypyNodes.MypyFile):
-                node.sym_info = ast.SymbolInfo("types.ModuleType")
+                node.name_spec.sym_type = "types.ModuleType"
 
             elif isinstance(mypy_node, MypyNodes.TypeInfo):
-                node.sym_info = ast.SymbolInfo(mypy_node.fullname)
+                node.name_spec.sym_type = mypy_node.fullname
 
             elif isinstance(mypy_node, MypyNodes.OverloadedFuncDef):
                 self.__call_type_handler(node, mypy_node.items[0].func.type)
 
             elif mypy_node is None:
-                node.sym_info = ast.SymbolInfo("None")
+                node.name_spec.sym_type = "None"
 
             else:
                 self.__debug_print(
@@ -164,7 +165,7 @@ class FuseTypeInfoPass(Pass):
 
         else:
             if isinstance(mypy_node, MypyNodes.ClassDef):
-                node.sym_info.typ = mypy_node.fullname
+                node.name_spec.sym_type = mypy_node.fullname
                 self.__set_sym_table_link(node)
             elif isinstance(mypy_node, MypyNodes.FuncDef):
                 self.__call_type_handler(node, mypy_node.type)
@@ -179,22 +180,10 @@ class FuseTypeInfoPass(Pass):
                 )
 
     @__handle_node
-    def enter_name(self, node: ast.NameSpec) -> None:
+    def enter_name(self, node: ast.NameAtom) -> None:
         """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.sym_info.typ_sym_table
-                if isinstance(parent_symbol_table, ast.SymbolTable):
-                    owner = parent_symbol_table.owner
-                    if isinstance(owner, ast.AstSymbolNode):
-                        target_node.sym_link = owner.sym_link
-                        node.sym_link = parent_symbol_table.lookup(node.sym_name)
-
     @__handle_node
     def enter_module_path(self, node: ast.ModulePath) -> None:
         """Pass handler for ModulePath nodes."""
@@ -279,13 +268,13 @@ class FuseTypeInfoPass(Pass):
 
     def exit_has_var(self, node: ast.HasVar) -> None:
         """Pass handler for HasVar nodes."""
-        node.sym_info.typ = node.name.sym_info.typ
-        node.sym_info.typ_sym_table = node.name.sym_info.typ_sym_table
+        node.name_spec.sym_type = node.name.sym_type
+        node.name_spec.type_sym_tab = node.name.type_sym_tab
 
     @__handle_node
     def enter_multi_string(self, node: ast.MultiString) -> None:
         """Pass handler for MultiString nodes."""
-        node.sym_info = ast.SymbolInfo("builtins.str")
+        node.name_spec.sym_type = "builtins.str"
 
     @__handle_node
     def enter_f_string(self, node: ast.FString) -> None:
@@ -297,48 +286,48 @@ class FuseTypeInfoPass(Pass):
         """Pass handler for ListVal nodes."""
         mypy_node = node.gen.mypy_ast[0]
         if mypy_node in self.node_type_hash:
-            node.sym_info.typ = str(self.node_type_hash[mypy_node])
+            node.name_spec.sym_type = str(self.node_type_hash[mypy_node])
         else:
-            node.sym_info.typ = "builtins.list"
+            node.name_spec.sym_type = "builtins.list"
 
     @__handle_node
     def enter_set_val(self, node: ast.SetVal) -> None:
         """Pass handler for SetVal nodes."""
         mypy_node = node.gen.mypy_ast[0]
         if mypy_node in self.node_type_hash:
-            node.sym_info.typ = str(self.node_type_hash[mypy_node])
+            node.name_spec.sym_type = str(self.node_type_hash[mypy_node])
         else:
-            node.sym_info.typ = "builtins.set"
+            node.name_spec.sym_type = "builtins.set"
 
     @__handle_node
     def enter_tuple_val(self, node: ast.TupleVal) -> None:
         """Pass handler for TupleVal nodes."""
         mypy_node = node.gen.mypy_ast[0]
         if mypy_node in self.node_type_hash:
-            node.sym_info.typ = str(self.node_type_hash[mypy_node])
+            node.name_spec.sym_type = str(self.node_type_hash[mypy_node])
         else:
-            node.sym_info.typ = "builtins.tuple"
+            node.name_spec.sym_type = "builtins.tuple"
 
     @__handle_node
     def enter_dict_val(self, node: ast.DictVal) -> None:
         """Pass handler for DictVal nodes."""
         mypy_node = node.gen.mypy_ast[0]
         if mypy_node in self.node_type_hash:
-            node.sym_info.typ = str(self.node_type_hash[mypy_node])
+            node.name_spec.sym_type = str(self.node_type_hash[mypy_node])
         else:
-            node.sym_info.typ = "builtins.dict"
+            node.name_spec.sym_type = "builtins.dict"
 
     @__handle_node
     def enter_list_compr(self, node: ast.ListCompr) -> None:
         """Pass handler for ListCompr nodes."""
         mypy_node = node.gen.mypy_ast[0]
-        node.sym_info.typ = str(self.node_type_hash[mypy_node])
+        node.name_spec.sym_type = str(self.node_type_hash[mypy_node])
 
     @__handle_node
     def enter_dict_compr(self, node: ast.DictCompr) -> None:
         """Pass handler for DictCompr nodes."""
         mypy_node = node.gen.mypy_ast[0]
-        node.sym_info.typ = str(self.node_type_hash[mypy_node])
+        node.name_spec.sym_type = str(self.node_type_hash[mypy_node])
 
     @__handle_node
     def enter_index_slice(self, node: ast.IndexSlice) -> None:
@@ -350,7 +339,7 @@ class FuseTypeInfoPass(Pass):
         """Pass handler for ArchRef nodes."""
         if isinstance(node.gen.mypy_ast[0], MypyNodes.ClassDef):
             mypy_node: MypyNodes.ClassDef = node.gen.mypy_ast[0]
-            node.sym_info.typ = mypy_node.fullname
+            node.name_spec.sym_type = mypy_node.fullname
             self.__set_sym_table_link(node)
         elif isinstance(node.gen.mypy_ast[0], MypyNodes.FuncDef):
             mypy_node2: MypyNodes.FuncDef = node.gen.mypy_ast[0]
@@ -384,22 +373,22 @@ class FuseTypeInfoPass(Pass):
     @__handle_node
     def enter_int(self, node: ast.Int) -> None:
         """Pass handler for Int nodes."""
-        node.sym_info.typ = "builtins.int"
+        node.name_spec.sym_type = "builtins.int"
 
     @__handle_node
     def enter_float(self, node: ast.Float) -> None:
         """Pass handler for Float nodes."""
-        node.sym_info.typ = "builtins.float"
+        node.name_spec.sym_type = "builtins.float"
 
     @__handle_node
     def enter_string(self, node: ast.String) -> None:
         """Pass handler for String nodes."""
-        node.sym_info.typ = "builtins.str"
+        node.name_spec.sym_type = "builtins.str"
 
     @__handle_node
     def enter_bool(self, node: ast.Bool) -> None:
         """Pass handler for Bool nodes."""
-        node.sym_info.typ = "builtins.bool"
+        node.name_spec.sym_type = "builtins.bool"
 
     @__handle_node
     def enter_builtin_type(self, node: ast.BuiltinType) -> None:
@@ -410,13 +399,13 @@ class FuseTypeInfoPass(Pass):
         self, node: ast.AstSymbolNode, mypy_type: MypyTypes.Instance
     ) -> None:
         """Get type info from mypy type Instance."""
-        node.sym_info = ast.SymbolInfo(str(mypy_type))
+        node.name_spec.sym_type = str(mypy_type)
 
     def get_type_from_callable_type(
         self, node: ast.AstSymbolNode, mypy_type: MypyTypes.CallableType
     ) -> None:
         """Get type info from mypy type CallableType."""
-        node.sym_info = ast.SymbolInfo(str(mypy_type.ret_type))
+        node.name_spec.sym_type = str(mypy_type.ret_type)
 
     # TODO: Which overloaded function to get the return value from?
     def get_type_from_overloaded(
@@ -429,16 +418,49 @@ class FuseTypeInfoPass(Pass):
         self, node: ast.AstSymbolNode, mypy_type: MypyTypes.NoneType
     ) -> None:
         """Get type info from mypy type NoneType."""
-        node.sym_info = ast.SymbolInfo("None")
+        node.name_spec.sym_type = "None"
 
     def get_type_from_any_type(
         self, node: ast.AstSymbolNode, mypy_type: MypyTypes.AnyType
     ) -> None:
         """Get type info from mypy type NoneType."""
-        node.sym_info = ast.SymbolInfo("Any")
+        node.name_spec.sym_type = "Any"
 
     def get_type_from_tuple_type(
         self, node: ast.AstSymbolNode, mypy_type: MypyTypes.TupleType
     ) -> None:
         """Get type info from mypy type TupleType."""
-        node.sym_info = ast.SymbolInfo("builtins.tuple")
+        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/import_pass.py

@@ -204,15 +204,17 @@ class JacImportPass(Pass):
 class PyImportPass(JacImportPass):
     """Jac statically imports Python modules."""
 
+    def before_pass(self) -> None:
+        """Only run pass if settings are set to raise python."""
+        if not settings.py_raise:
+            self.terminate()
+        else:
+            return super().before_pass()
+
     def process_import(self, node: ast.Module, i: ast.ModulePath) -> None:
         """Process an import."""
         lang = i.parent_of_type(ast.Import).hint.tag.value
-        if (
-            lang == "py"
-            and not i.sub_module
-            and settings.py_raise
-            and not is_standard_lib_module(i.path_str)
-        ):
+        if lang == "py" and not i.sub_module and not is_standard_lib_module(i.path_str):
             mod = self.import_py_module(node=i, mod_path=node.loc.mod_path)
             if mod:
                 i.sub_module = mod