jaclang 0.7.27__py3-none-any.whl → 0.7.30__py3-none-any.whl

jaclang/compiler/passes/main/import_pass.py

@@ -12,8 +12,11 @@ from typing import Optional
 
 
 import jaclang.compiler.absyntree as ast
+from jaclang.compiler.constant import SymbolType
 from jaclang.compiler.passes import Pass
-from jaclang.compiler.passes.main import SubNodeTabPass, SymTabBuildPass
+from jaclang.compiler.passes.main import DefUsePass, SubNodeTabPass, SymTabBuildPass
+from jaclang.compiler.passes.main.sym_tab_build_pass import PyInspectSymTabBuildPass
+from jaclang.compiler.symtable import Symbol, SymbolTable
 from jaclang.settings import settings
 from jaclang.utils.log import logging
 
@@ -183,7 +186,7 @@ class JacImportPass(Pass):
             self.warnings_had += mod_pass.warnings_had
             mod = mod_pass.ir
         except Exception as e:
-            logger.info(e)
+            logger.error(e)
             mod = None
         if isinstance(mod, ast.Module):
             self.import_table[target] = mod
@@ -198,19 +201,20 @@ class JacImportPass(Pass):
 class PyImportPass(JacImportPass):
     """Jac statically imports Python modules."""
 
+    def __debug_print(self, msg: str) -> None:
+        if settings.py_import_pass_debug:
+            self.log_info("[PyImportPass] " + msg)
+
     def before_pass(self) -> None:
         """Only run pass if settings are set to raise python."""
+        self.import_from_build_list: list[tuple[ast.Import, ast.Module]] = []
         super().before_pass()
         self.__load_builtins()
 
-    def __get_current_module(self, node: ast.AstNode) -> str:
-        parent = node.find_parent_of_type(ast.Module)
-        mod_list = []
-        while parent is not None:
-            mod_list.append(parent)
-            parent = parent.find_parent_of_type(ast.Module)
-        mod_list.reverse()
-        return ".".join(p.name for p in mod_list)
+    def after_pass(self) -> None:
+        """Build symbol tables for import from nodes."""
+        self.__import_from_symbol_table_build()
+        return super().after_pass()
 
     def process_import(self, i: ast.ModulePath) -> None:
         """Process an import."""
@@ -218,87 +222,273 @@ class PyImportPass(JacImportPass):
         # This won't work with py imports as this will fail to import stuff in form of
         #      from a import b
         #      from a import (c, d, e)
-        # Solution to that is to get the import node and check the from loc then
+        # Solution to that is to get the import node and check the from loc `then`
         # handle it based on if there a from loc or not
         imp_node = i.parent_of_type(ast.Import)
+
         if imp_node.is_py and not i.sub_module:
             if imp_node.from_loc:
-                for j in imp_node.items.items:
-                    assert isinstance(j, ast.ModuleItem)
-                    mod_path = f"{imp_node.from_loc.dot_path_str}.{j.name.sym_name}"
-                    self.import_py_module(
-                        parent_node=j,
-                        mod_path=mod_path,
-                        imported_mod_name=(
-                            j.name.sym_name if not j.alias else j.alias.sym_name
-                        ),
-                    )
+                msg = "Processing import from node at href="
+                msg += ast.Module.get_href_path(imp_node)
+                msg += f' path="{imp_node.loc.mod_path}, {imp_node.loc}"'
+                self.__debug_print(msg)
+                self.__process_import_from(imp_node)
+            else:
+                msg = "Processing import node at href="
+                msg += ast.Module.get_href_path(imp_node)
+                msg += f' path="{imp_node.loc.mod_path}, {imp_node.loc}"'
+                self.__debug_print(msg)
+                self.__process_import(imp_node)
+
+    def __process_import_from(self, imp_node: ast.Import) -> None:
+        """Process imports in the form of `from X import I`."""
+        assert isinstance(self.ir, ast.Module)
+        assert isinstance(imp_node.from_loc, ast.ModulePath)
+
+        self.__debug_print(f"\tTrying to import {imp_node.from_loc.dot_path_str}")
+
+        # Attempt to import the Python module X and process it
+        imported_mod = self.__import_py_module(
+            parent_node_path=ast.Module.get_href_path(imp_node),
+            mod_path=imp_node.from_loc.dot_path_str,
+        )
+
+        if imported_mod:
+            # Cyclic imports will happen in case of import sys
+            # sys stub file imports sys module which means that we need
+            # to import sys stub file again in the sys stub file and so on
+            # This can be detected by iterating over all the parents and make sure
+            # that the parent is in another file than the imported module
+            if self.__check_cyclic_imports(imp_node, imported_mod):
+                self.__debug_print(
+                    f"\tCycled imports is found at {imp_node.loc.mod_path} {imp_node.loc}"
+                )
+                return
+
+            if imported_mod.name == "builtins":
+                self.__debug_print(
+                    f"\tIgnoring attaching builtins {imp_node.loc.mod_path} {imp_node.loc}"
+                )
+                return
+
+            self.__debug_print(
+                f"\tAttaching {imported_mod.name} into {ast.Module.get_href_path(imp_node)}"
+            )
+            msg = f"\tRegistering module:{imported_mod.name} to "
+            msg += f"import_from handling with {imp_node.loc.mod_path}:{imp_node.loc}"
+            self.__debug_print(msg)
+
+            self.attach_mod_to_node(imp_node.from_loc, imported_mod)
+            self.import_from_build_list.append((imp_node, imported_mod))
+            if imported_mod._sym_tab is None:
+                self.__debug_print(
+                    f"\tBuilding symbol table for module:{ast.Module.get_href_path(imported_mod)}"
+                )
             else:
-                for j in imp_node.items.items:
-                    assert isinstance(j, ast.ModulePath)
-                    self.import_py_module(
-                        parent_node=j,
-                        mod_path=j.dot_path_str,
-                        imported_mod_name=(
-                            j.dot_path_str.replace(".", "")
-                            if not j.alias
-                            else j.alias.sym_name
-                        ),
+                self.__debug_print(
+                    f"\tRefreshing symbol table for module:{ast.Module.get_href_path(imported_mod)}"
+                )
+            PyInspectSymTabBuildPass(input_ir=imported_mod, prior=self)
+            DefUsePass(input_ir=imported_mod, prior=self)
+
+    def __import_from_symbol_table_build(self) -> None:
+        """Build symbol tables for the imported python modules."""
+        is_symbol_tabled_refreshed: list[str] = []
+        self.import_from_build_list.reverse()
+        for imp_node, imported_mod in self.import_from_build_list:
+            # Need to build the symbol tables again to make sure that the
+            # complete symbol table is built.
+            #
+            # Complete symbol tables won't be built in case of another
+            # import from statements in the imported modules.
+            #
+            # A solution was to only build the symbol table here after the
+            # full ast is raised but this will cause an issue with symboltable
+            # building with normal imports
+            #
+            # TODO: Change normal imports to call symbolTable here too
+
+            if imported_mod.loc.mod_path not in is_symbol_tabled_refreshed:
+                self.__debug_print(
+                    f"Refreshing symbol table for module:{ast.Module.get_href_path(imported_mod)}"
+                )
+                PyInspectSymTabBuildPass(input_ir=imported_mod, prior=self)
+                DefUsePass(input_ir=imported_mod, prior=self)
+                is_symbol_tabled_refreshed.append(imported_mod.loc.mod_path)
+
+            sym_tab = imported_mod.sym_tab
+            parent_sym_tab = imp_node.parent_of_type(ast.Module).sym_tab
+
+            if imp_node.is_absorb:
+                for symbol in sym_tab.tab.values():
+                    if symbol.sym_type == SymbolType.MODULE:
+                        continue
+                    self.__import_from_sym_table_add_symbols(symbol, parent_sym_tab)
+            else:
+                for i in imp_node.items.items:
+                    assert isinstance(i, ast.ModuleItem)
+                    needed_sym = sym_tab.lookup(i.name.sym_name)
+
+                    if needed_sym and needed_sym.defn[0].parent:
+                        self.__import_from_sym_table_add_symbols(
+                            needed_sym, parent_sym_tab
+                        )
+                    else:
+                        self.__debug_print(
+                            f"Can't find a symbol matching {i.name.sym_name} in {sym_tab.name}"
+                        )
+
+    def __import_from_sym_table_add_symbols(
+        self, sym: Symbol, sym_table: SymbolTable
+    ) -> None:
+        self.__debug_print(
+            f"\tAdding {sym.sym_type}:{sym.sym_name} into {sym_table.name}"
+        )
+        assert isinstance(sym.defn[0], ast.AstSymbolNode)
+        sym_table.def_insert(
+            node=sym.defn[0],
+            access_spec=sym.access,
+            force_overwrite=True,
+        )
+
+        if sym.fetch_sym_tab:
+            msg = f"\tAdding SymbolTable:{sym.fetch_sym_tab.name} into "
+            msg += f"SymbolTable:{sym_table.name} kids"
+            self.__debug_print(msg)
+            sym_table.kid.append(sym.fetch_sym_tab)
+        elif sym.sym_type not in (SymbolType.VAR, SymbolType.MOD_VAR):
+            raise AssertionError(
+                f"Unexpected symbol type '{sym.sym_type}' that doesn't have a symbl table"
+            )
+
+    def __process_import(self, imp_node: ast.Import) -> None:
+        """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 isinstance(imported_item, ast.ModulePath)
+
+        self.__debug_print(f"\tTrying to import {imported_item.dot_path_str}")
+        imported_mod = self.__import_py_module(
+            parent_node_path=ast.Module.get_href_path(imported_item),
+            mod_path=imported_item.dot_path_str,
+            imported_mod_name=(
+                # TODO: Check this replace
+                imported_item.dot_path_str.replace(".", "")
+                if not imported_item.alias
+                else imported_item.alias.sym_name
+            ),
+        )
+        if imported_mod:
+            if self.__check_cyclic_imports(imp_node, imported_mod):
+                self.__debug_print(
+                    f"\tCycled imports is found at {imp_node.loc.mod_path} {imp_node.loc}"
+                )
+                return
+            elif imported_mod.name == "builtins":
+                self.__debug_print(
+                    f"\tIgnoring attaching builtins {imp_node.loc.mod_path} {imp_node.loc}"
+                )
+                return
+
+            self.__debug_print(
+                f"\tAttaching {imported_mod.name} into {ast.Module.get_href_path(imp_node)}"
+            )
+            self.attach_mod_to_node(imported_item, imported_mod)
+
+            if imp_node.is_absorb:
+                msg = f"\tRegistering module:{imported_mod.name} to "
+                msg += f"import_from (import all) handling with {imp_node.loc.mod_path}:{imp_node.loc}"
+                self.__debug_print(msg)
+
+                self.import_from_build_list.append((imp_node, imported_mod))
+                if imported_mod._sym_tab is None:
+                    self.__debug_print(
+                        f"\tBuilding symbol table for module:{ast.Module.get_href_path(imported_mod)}"
+                    )
+                else:
+                    self.__debug_print(
+                        f"\tRefreshing symbol table for module:{ast.Module.get_href_path(imported_mod)}"
                     )
+                PyInspectSymTabBuildPass(input_ir=imported_mod, prior=self)
+                DefUsePass(input_ir=imported_mod, prior=self)
+
+            else:
+                self.__debug_print(
+                    f"\tBuilding symbol table for module:{ast.Module.get_href_path(imported_mod)}"
+                )
+                SymTabBuildPass(input_ir=imported_mod, prior=self)
 
-    def import_py_module(
+    def __import_py_module(
         self,
-        parent_node: ast.ModulePath | ast.ModuleItem,
-        imported_mod_name: str,
+        parent_node_path: str,
         mod_path: str,
+        imported_mod_name: Optional[str] = None,
     ) -> Optional[ast.Module]:
-        """Import a module."""
+        """Import a python module."""
         from jaclang.compiler.passes.main import PyastBuildPass
 
         assert isinstance(self.ir, ast.Module)
 
-        python_raise_map = self.ir.py_raise_map
-        file_to_raise = None
+        python_raise_map = self.ir.py_info.py_raise_map
+        file_to_raise: Optional[str] = None
 
         if mod_path in python_raise_map:
             file_to_raise = python_raise_map[mod_path]
         else:
-            resolved_mod_path = (
-                f"{self.__get_current_module(parent_node)}.{imported_mod_name}"
-            )
-            assert isinstance(self.ir, ast.Module)
+            # TODO: Is it fine to use imported_mod_name or get it from mod_path?
+            resolved_mod_path = f"{parent_node_path}.{mod_path}"
+            resolved_mod_path = resolved_mod_path.replace("..", ".")
             resolved_mod_path = resolved_mod_path.replace(f"{self.ir.name}.", "")
             file_to_raise = python_raise_map.get(resolved_mod_path)
 
         if file_to_raise is None:
+            self.__debug_print("\tNo file is found to do the import")
             return None
 
+        self.__debug_print(f"\tFile used to do the import is {file_to_raise}")
+
         try:
-            if file_to_raise not in {None, "built-in", "frozen"}:
-                if file_to_raise in self.import_table:
-                    return self.import_table[file_to_raise]
-
-                with open(file_to_raise, "r", encoding="utf-8") as f:
-                    file_source = f.read()
-                    mod = PyastBuildPass(
-                        input_ir=ast.PythonModuleAst(
-                            py_ast.parse(file_source),
-                            orig_src=ast.JacSource(file_source, file_to_raise),
-                        ),
-                    ).ir
-                    SubNodeTabPass(input_ir=mod, prior=self)
-                if mod:
-                    mod.name = imported_mod_name
-                    self.import_table[file_to_raise] = mod
-                    self.attach_mod_to_node(parent_node, mod)
-                    SymTabBuildPass(input_ir=mod, prior=self)
-                    return mod
-                else:
-                    raise self.ice(f"Failed to import python module {mod_path}")
+            if file_to_raise in {None, "built-in", "frozen"}:
+                return None
+
+            if file_to_raise in self.import_table:
+                self.__debug_print(
+                    f"\t{file_to_raise} was raised before, getting it from cache"
+                )
+                return self.import_table[file_to_raise]
+
+            with open(file_to_raise, "r", encoding="utf-8") as f:
+                file_source = f.read()
+                mod = PyastBuildPass(
+                    input_ir=ast.PythonModuleAst(
+                        py_ast.parse(file_source),
+                        orig_src=ast.JacSource(file_source, file_to_raise),
+                    ),
+                ).ir
+                SubNodeTabPass(input_ir=mod, prior=self)
+
+            if mod:
+                mod.name = imported_mod_name if imported_mod_name else mod.name
+                if mod.name == "__init__":
+                    mod_name = mod.loc.mod_path.split(os.sep)[-2]
+                    self.__debug_print(
+                        f"\tRaised the __init__ file and rename the mod to be {mod_name}"
+                    )
+                    mod.name = mod_name
+                self.import_table[file_to_raise] = mod
+                mod.py_info.is_raised_from_py = True
+                self.__debug_print(
+                    f"\t{file_to_raise} is raised, adding it to the cache"
+                )
+                return mod
+            else:
+                raise self.ice(f"\tFailed to import python module {mod_path}")
+
         except Exception as e:
-            self.error(f"Failed to import python module {mod_path}")
+            self.error(f"\tFailed to import python module {mod_path}")
             raise e
-        return None
 
     def __load_builtins(self) -> None:
         """Pyraise builtins to help with builtins auto complete."""
@@ -330,3 +520,34 @@ class PyImportPass(JacImportPass):
     def annex_impl(self, node: ast.Module) -> None:
         """Annex impl and test modules."""
         return None
+
+    def __handle_different_site_packages(self, mod_path: str) -> str:
+        if "site-packages" in mod_path:
+            mod_path = mod_path[mod_path.index("site-packages") :]
+        return mod_path
+
+    def __check_cyclic_imports(
+        self, imp_node: ast.AstNode, imported_module: ast.Module
+    ) -> bool:
+        """Check cyclic imports that might happen."""
+        # Example of cyclic imports is import os
+        # In the os stub file it imports the real os module which will cause os
+        # stub to be raised again and so on
+        # Another example is numpy. numpy init file imports multidim array file
+        # which imports again more items from numpy and so on.
+        imp_node_file = self.__handle_different_site_packages(imp_node.loc.mod_path)
+        imported_module_file = self.__handle_different_site_packages(
+            imported_module.loc.mod_path
+        )
+        if imp_node_file == imported_module_file:
+            return True
+
+        parent: Optional[ast.AstNode] = imp_node.parent
+        while parent is not None:
+            parent_file = self.__handle_different_site_packages(parent.loc.mod_path)
+            if parent_file == imported_module_file:
+                return True
+            else:
+                parent = parent.find_parent_of_type(ast.Module)
+
+        return False

jaclang/compiler/passes/main/inheritance_pass.py

@@ -0,0 +1,103 @@
+"""Pass used to add the inherited symbols for architypes."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import jaclang.compiler.absyntree as ast
+from jaclang.compiler.passes import Pass
+from jaclang.compiler.symtable import Symbol, SymbolTable
+from jaclang.settings import settings
+
+
+class InheritancePass(Pass):
+    """Add inherited abilities in the target symbol tables."""
+
+    def __debug_print(self, msg: str) -> None:
+        if settings.inherit_pass_debug:
+            self.log_info("[PyImportPass] " + msg)
+
+    def __lookup(self, name: str, sym_table: SymbolTable) -> Optional[Symbol]:
+        symbol = sym_table.lookup(name)
+        if symbol is None:
+            # Check if the needed symbol in builtins
+            builtins_symtable = self.ir.sym_tab.find_scope("builtins")
+            assert builtins_symtable is not None
+            symbol = builtins_symtable.lookup(name)
+        return symbol
+
+    def enter_architype(self, node: ast.Architype) -> None:
+        """Fill architype symbol tables with abilities from parent architypes."""
+        if node.base_classes is None:
+            return
+
+        for item in node.base_classes.items:
+            # The assumption is that the base class can only be a name node
+            # or an atom trailer only.
+            assert isinstance(item, (ast.Name, ast.AtomTrailer))
+
+            # In case of name node, then get the symbol table that contains
+            # the current class and lookup for that name after that use the
+            # symbol to get the symbol table of the base class
+            if isinstance(item, ast.Name):
+                assert node.sym_tab.parent is not None
+                base_class_symbol = self.__lookup(item.sym_name, node.sym_tab.parent)
+                if base_class_symbol is None:
+                    msg = "Missing symbol for base class "
+                    msg += f"{ast.Module.get_href_path(item)}.{item.sym_name}"
+                    msg += f" needed for {ast.Module.get_href_path(node)}"
+                    self.__debug_print(msg)
+                    continue
+                base_class_symbol_table = base_class_symbol.fetch_sym_tab
+                if (
+                    base_class_symbol_table is None
+                    and base_class_symbol.defn[0]
+                    .parent_of_type(ast.Module)
+                    .py_info.is_raised_from_py
+                ):
+                    msg = "Missing symbol table for python base class "
+                    msg += f"{ast.Module.get_href_path(item)}.{item.sym_name}"
+                    msg += f" needed for {ast.Module.get_href_path(node)}"
+                    self.__debug_print(msg)
+                    continue
+                assert base_class_symbol_table is not None
+                node.sym_tab.inherit_sym_tab(base_class_symbol_table)
+
+            # In case of atom trailer, unwind it and use each name node to
+            # as the code above to lookup for the base class
+            elif isinstance(item, ast.AtomTrailer):
+                current_sym_table = node.sym_tab.parent
+                not_found: bool = False
+                assert current_sym_table is not None
+                for name in item.as_attr_list:
+                    sym = self.__lookup(name.sym_name, current_sym_table)
+                    if sym is None:
+                        msg = "Missing symbol for base class "
+                        msg += f"{ast.Module.get_href_path(name)}.{name.sym_name}"
+                        msg += f" needed for {ast.Module.get_href_path(node)}"
+                        self.__debug_print(msg)
+                        not_found = True
+                        break
+                    current_sym_table = sym.fetch_sym_tab
+
+                    # In case of python nodes, the base class may not be
+                    # raised so ignore these classes for now
+                    # TODO Do we need to import these classes?
+                    if (
+                        sym.defn[0].parent_of_type(ast.Module).py_info.is_raised_from_py
+                        and current_sym_table is None
+                    ):
+                        msg = "Missing symbol table for python base class "
+                        msg += f"{ast.Module.get_href_path(name)}.{name.sym_name}"
+                        msg += f" needed for {ast.Module.get_href_path(node)}"
+                        self.__debug_print(msg)
+                        not_found = True
+                        break
+
+                    assert current_sym_table is not None
+
+                if not_found:
+                    continue
+
+                assert current_sym_table is not None
+                node.sym_tab.inherit_sym_tab(current_sym_table)

jaclang/compiler/passes/main/py_collect_dep_pass.py

@@ -35,7 +35,7 @@ class PyCollectDepsPass(Pass):
         if isinstance(node, ast.ModulePath):
             if node.path:
                 path = ".".join([i.value for i in node.path])
-            node.abs_path = self.ir.py_mod_dep_map.get(path)
+            node.abs_path = self.ir.py_info.py_mod_dep_map.get(path)
             if node.abs_path and os.path.isfile(node.abs_path.replace(".pyi", ".py")):
                 node.abs_path = node.abs_path.replace(".pyi", ".py")
 
@@ -45,7 +45,7 @@ class PyCollectDepsPass(Pass):
             if mod_path_node.path:
                 path = ".".join([i.value for i in mod_path_node.path])
             path += f".{node.name.value}"
-            node.abs_path = self.ir.py_mod_dep_map.get(path)
+            node.abs_path = self.ir.py_info.py_mod_dep_map.get(path)
             if node.abs_path and os.path.isfile(node.abs_path.replace(".pyi", ".py")):
                 node.abs_path = node.abs_path.replace(".pyi", ".py")
 
@@ -61,17 +61,17 @@ class PyCollectDepsPass(Pass):
             else:
                 mod_name = node_full_name
 
-            if mod_name not in self.ir.py_mod_dep_map:
+            if mod_name not in self.ir.py_info.py_mod_dep_map:
                 self.__debug_print(
                     f"Can't find a python file associated with {type(node)}::{node.loc}"
                 )
                 return
 
-            mode_path = self.ir.py_mod_dep_map[mod_name]
+            mode_path = self.ir.py_info.py_mod_dep_map[mod_name]
             if mode_path.endswith(".jac"):
                 return
 
-            self.ir.py_raise_map[mod_name] = mode_path
+            self.ir.py_info.py_raise_map[mod_name] = mode_path
         else:
             self.__debug_print(
                 f"Collect python dependencies is not supported in {type(node)}::{node.loc}"

jaclang/compiler/passes/main/pyast_gen_pass.py

@@ -2482,25 +2482,6 @@ class PyastGenPass(Pass):
             return func_node.gen.py_ast
         elif node.op.name == Tok.PIPE_FWD and isinstance(node.right, ast.TupleVal):
             self.error("Invalid pipe target.")
-        elif node.op.name == Tok.ELVIS_OP:
-            self.needs_jac_feature()
-            return [
-                self.sync(
-                    ast3.Call(
-                        func=self.sync(
-                            ast3.Attribute(
-                                value=self.sync(
-                                    ast3.Name(id=Con.JAC_FEATURE.value, ctx=ast3.Load())
-                                ),
-                                attr="elvis",
-                                ctx=ast3.Load(),
-                            )
-                        ),
-                        args=[node.left.gen.py_ast[0], node.right.gen.py_ast[0]],
-                        keywords=[],
-                    )
-                )
-            ]
         else:
             self.error(
                 f"Binary operator {node.op.value} not supported in bootstrap Jac"

jaclang/compiler/passes/main/pyast_load_pass.py

@@ -129,7 +129,7 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
             is_imported=False,
             kid=valid,
         )
-        ret.is_raised_from_py = True
+        ret.py_info.is_raised_from_py = True
         return self.nu(ret)
 
     def proc_function_def(

jaclang/compiler/passes/main/schedules.py

@@ -20,6 +20,7 @@ from .fuse_typeinfo_pass import FuseTypeInfoPass  # noqa: I100
 from .registry_pass import RegistryPass  # noqa: I100
 from .access_modifier_pass import AccessCheckPass  # noqa: I100
 from .py_collect_dep_pass import PyCollectDepsPass  # noqa: I100
+from .inheritance_pass import InheritancePass  # noqa: I100
 
 py_code_gen = [
     SubNodeTabPass,
@@ -38,6 +39,7 @@ type_checker_sched = [
     PyCollectDepsPass,
     PyImportPass,
     DefUsePass,
+    InheritancePass,
     FuseTypeInfoPass,
     AccessCheckPass,
 ]

jaclang/compiler/passes/main/sym_tab_build_pass.py

@@ -4,6 +4,8 @@ This pass builds the symbol table tree for the Jaseci Ast. It also adds symbols
 for globals, imports, architypes, and abilities declarations and definitions.
 """
 
+from typing import TypeVar
+
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.passes import Pass
 from jaclang.compiler.symtable import SymbolTable
@@ -19,6 +21,7 @@ class SymTabBuildPass(Pass):
     def push_scope(self, name: str, key_node: ast.AstNode) -> None:
         """Push scope."""
         inherit = key_node.parent
+
         if not len(self.cur_sym_tab) and not inherit:
             self.cur_sym_tab.append(SymbolTable(name, key_node))
         elif not len(self.cur_sym_tab) and inherit:
@@ -1284,3 +1287,17 @@ class SymTabBuildPass(Pass):
     def enter_comment_token(self, node: ast.CommentToken) -> None:
         """Sub objects."""
         self.sync_node_to_scope(node)
+
+
+T = TypeVar("T", bound=ast.AstNode)
+
+
+class PyInspectSymTabBuildPass(SymTabBuildPass):
+    """Jac Symbol table build pass."""
+
+    def push_scope(self, name: str, key_node: ast.AstNode) -> None:
+        """Push scope."""
+        if not len(self.cur_sym_tab):
+            self.cur_sym_tab.append(SymbolTable(name, key_node))
+        else:
+            self.cur_sym_tab.append(self.cur_scope.push_kid_scope(name, key_node))