jaclang 0.6.0__py3-none-any.whl → 0.6.1__py3-none-any.whl

jaclang/compiler/parser.py

@@ -140,7 +140,7 @@ class JacParser(Pass):
             body = kid[1:] if doc else kid
             body = [i for i in body if isinstance(i, ast.ElementStmt)]
             mod = ast.Module(
-                name=self.parse_ref.mod_path.split(os.path.sep)[-1].split(".")[0],
+                name=self.parse_ref.mod_path.split(os.path.sep)[-1].rstrip(".jac"),
                 source=self.parse_ref.source,
                 doc=doc,
                 body=body,

jaclang/compiler/passes/main/def_impl_match_pass.py

@@ -72,7 +72,10 @@ class DeclDefMatchPass(Pass):
                     continue
                 decl_node.body = sym.decl  # type: ignore
                 sym.decl.decl_link = decl_node  # type: ignore
-                decl_node.add_kids_right([sym.decl], pos_update=False)  # type: ignore
+                source_node = sym.decl.parent
+                decl_node.add_kids_right([sym.decl])  # type: ignore
+                if source_node and sym.decl in source_node.kid:
+                    source_node.kid.remove(sym.decl)
                 decl_node.sym_tab.tab = sym.decl.sym_tab.tab  # type: ignore
         for i in sym_tab.kid:
             self.connect_def_impl(i)

jaclang/compiler/passes/main/fuse_typeinfo_pass.py

@@ -48,8 +48,16 @@ class FuseTypeInfoPass(Pass):
     def __set_sym_table_link(self, node: ast.AstSymbolNode) -> None:
         typ = node.sym_info.typ.split(".")
         typ_sym_table = self.ir.sym_tab
-        if typ_sym_table and typ[0] == typ_sym_table.name:
-            for i in typ[1:]:
+
+        if typ[0] == "builtins":
+            return
+
+        assert isinstance(self.ir, ast.Module)
+
+        if typ_sym_table:
+            for i in typ:
+                if i == self.ir.name:
+                    continue
                 f = typ_sym_table.find_scope(i)
                 if f:
                     typ_sym_table = f
@@ -159,11 +167,6 @@ class FuseTypeInfoPass(Pass):
                     type(mypy_node),
                 )
 
-    def enter_import(self, node: ast.Import) -> None:
-        """Pass handler for import nodes."""
-        # Pruning the import nodes
-        self.prune()
-
     @__handle_node
     def enter_name(self, node: ast.NameSpec) -> None:
         """Pass handler for name nodes."""

jaclang/compiler/passes/main/import_pass.py

@@ -7,8 +7,8 @@ symbols are available for matching.
 
 import ast as py_ast
 import importlib.util
+import os
 import sys
-from os import path
 from typing import Optional
 
 
@@ -40,7 +40,6 @@ class JacImportPass(Pass):
                 self.process_import(node, i)
                 self.enter_module_path(i)
             SubNodeTabPass(prior=self, input_ir=node)
-        self.annex_impl(node)
         node.mod_deps = self.import_table
 
     def process_import(self, node: ast.Module, i: ast.ModulePath) -> None:
@@ -53,7 +52,6 @@ class JacImportPass(Pass):
             )
             if mod:
                 self.run_again = True
-                self.annex_impl(mod)
                 i.sub_module = mod
                 i.add_kids_right([mod], pos_update=False)
 
@@ -61,22 +59,41 @@ class JacImportPass(Pass):
         """Annex impl and test modules."""
         if not node.loc.mod_path:
             self.error("Module has no path")
-        if node.loc.mod_path.endswith(".jac") and path.exists(
-            f"{node.loc.mod_path[:-4]}.impl.jac"
-        ):
-            mod = self.import_mod_from_file(f"{node.loc.mod_path[:-4]}.impl.jac")
-            if mod:
-                node.impl_mod = mod
-                node.add_kids_left([mod], pos_update=False)
-                mod.parent = node
-        if node.loc.mod_path.endswith(".jac") and path.exists(
-            f"{node.loc.mod_path[:-4]}.test.jac"
-        ):
-            mod = self.import_mod_from_file(f"{node.loc.mod_path[:-4]}.test.jac")
-            if mod:
-                node.test_mod = mod
-                node.add_kids_right([mod], pos_update=False)
-                mod.parent = node
+        if not node.loc.mod_path.endswith(".jac"):
+            return
+        base_path = node.loc.mod_path[:-4]
+        directory = os.path.dirname(node.loc.mod_path)
+        if not directory:
+            directory = os.getcwd()
+            base_path = os.path.join(directory, base_path)
+        impl_folder = base_path + ".impl"
+        search_files = [
+            os.path.join(directory, impl_file) for impl_file in os.listdir(directory)
+        ]
+        if os.path.exists(impl_folder):
+            search_files += [
+                os.path.join(impl_folder, impl_file)
+                for impl_file in os.listdir(impl_folder)
+            ]
+        for impl_file in search_files:
+            if node.loc.mod_path.endswith(impl_file):
+                continue
+            if (
+                impl_file.startswith(f"{base_path}.") or impl_folder in impl_file
+            ) and impl_file.endswith(".impl.jac"):
+                mod = self.import_mod_from_file(impl_file)
+                if mod:
+                    node.impl_mod.append(mod)
+                    node.add_kids_left([mod], pos_update=False)
+                    mod.parent = node
+            if (
+                impl_file.startswith(f"{base_path}.") or impl_folder in impl_file
+            ) and impl_file.endswith(".test.jac"):
+                mod = self.import_mod_from_file(impl_file)
+                if mod:
+                    node.test_mod = mod
+                    node.add_kids_right([mod], pos_update=False)
+                    mod.parent = node
 
     def enter_module_path(self, node: ast.ModulePath) -> None:
         """Sub objects.
@@ -96,7 +113,7 @@ class JacImportPass(Pass):
         """Import a module."""
         self.cur_node = node  # impacts error reporting
         target = import_target_to_relative_path(
-            node.level, node.path_str, path.dirname(node.loc.mod_path)
+            node.level, node.path_str, os.path.dirname(node.loc.mod_path)
         )
         return self.import_mod_from_file(target)
 
@@ -105,7 +122,7 @@ class JacImportPass(Pass):
         from jaclang.compiler.compile import jac_file_to_pass
         from jaclang.compiler.passes.main import SubNodeTabPass
 
-        if not path.exists(target):
+        if not os.path.exists(target):
             self.error(f"Could not find module {target}")
             return None
         if target in self.import_table:
@@ -133,7 +150,7 @@ class JacImportPass(Pass):
         """Import a module."""
         from jaclang.compiler.passes.main import PyastBuildPass
 
-        base_dir = path.dirname(mod_path)
+        base_dir = os.path.dirname(mod_path)
         sys.path.append(base_dir)
 
         try:

jaclang/compiler/passes/main/pyast_gen_pass.py

@@ -19,8 +19,6 @@ T = TypeVar("T", bound=ast3.AST)
 class PyastGenPass(Pass):
     """Jac blue transpilation to python pass."""
 
-    cout = 1
-
     @staticmethod
     def node_compilable_test(node: ast3.AST) -> None:
         """Convert any AST node to a compilable module node."""
@@ -214,25 +212,18 @@ class PyastGenPass(Pass):
                 i.end_lineno = (
                     jac_node.loc.last_line
                     if jac_node.loc.last_line
+                    and (jac_node.loc.last_line > jac_node.loc.first_line)
                     else jac_node.loc.first_line
                 )
                 i.end_col_offset = (
                     jac_node.loc.col_end
                     if jac_node.loc.col_end
+                    and (jac_node.loc.col_end > jac_node.loc.col_start)
                     else jac_node.loc.col_start
                 )
                 i.jac_link: list[ast3.AST] = [jac_node]  # type: ignore
         return py_node
 
-    def link_jac_py_nodes(
-        self, jac_node: ast.AstNode, py_nodes: list[ast3.AST]
-    ) -> None:
-        """Link jac name ast to py ast nodes."""
-        jac_node.gen.py_ast = py_nodes
-        for i in py_nodes:
-            if isinstance(i.jac_link, list):  # type: ignore
-                i.jac_link.append(jac_node)  # type: ignore
-
     def pyinline_sync(
         self,
         py_nodes: list[ast3.AST],
@@ -329,7 +320,10 @@ class PyastGenPass(Pass):
         is_imported: bool,
         """
         clean_body = [i for i in node.body if not isinstance(i, ast.AstImplOnlyNode)]
-        pre_body = [*node.impl_mod.body, *clean_body] if node.impl_mod else clean_body
+        pre_body: list[ast.AstNode] = []
+        for pbody in node.impl_mod:
+            pre_body = [*pre_body, *pbody.body]
+        pre_body = [*pre_body, *clean_body]
         pre_body = [*pre_body, *node.test_mod.body] if node.test_mod else pre_body
         body = (
             [
@@ -648,8 +642,6 @@ class PyastGenPass(Pass):
                 )
             )
         ]
-        if node.alias:
-            self.link_jac_py_nodes(jac_node=node.alias, py_nodes=node.gen.py_ast)
 
     def exit_module_item(self, node: ast.ModuleItem) -> None:
         """Sub objects.
@@ -776,9 +768,6 @@ class PyastGenPass(Pass):
                 )
             )
         ]
-        self.link_jac_py_nodes(jac_node=node.name, py_nodes=node.gen.py_ast)
-        if isinstance(node.body, ast.ArchDef):
-            self.link_jac_py_nodes(jac_node=node.body, py_nodes=node.gen.py_ast)
 
     def collect_events(
         self, node: ast.Architype
@@ -831,12 +820,6 @@ class PyastGenPass(Pass):
         doc: Optional[String],
         decorators: Optional[SubNodeList[ExprType]],
         """
-        for i in node.target.archs:
-            if i.sym_link:
-                self.link_jac_py_nodes(jac_node=i, py_nodes=i.sym_link.decl.gen.py_ast)
-                self.link_jac_py_nodes(
-                    jac_node=i.name_ref, py_nodes=i.sym_link.decl.gen.py_ast
-                )
 
     def exit_enum(self, node: ast.Enum) -> None:
         """Sub objects.
@@ -877,8 +860,6 @@ class PyastGenPass(Pass):
                 )
             )
         ]
-        if isinstance(node.body, ast.EnumDef):
-            self.link_jac_py_nodes(jac_node=node.body, py_nodes=node.gen.py_ast)
 
     def exit_enum_def(self, node: ast.EnumDef) -> None:
         """Sub objects.
@@ -888,12 +869,6 @@ class PyastGenPass(Pass):
         doc: Optional[String],
         decorators: Optional[SubNodeList[ExprType]],
         """
-        for i in node.target.archs:
-            if i.sym_link:
-                self.link_jac_py_nodes(jac_node=i, py_nodes=i.sym_link.decl.gen.py_ast)
-                self.link_jac_py_nodes(
-                    jac_node=i.name_ref, py_nodes=i.sym_link.decl.gen.py_ast
-                )
 
     def exit_ability(self, node: ast.Ability) -> None:
         """Sub objects.
@@ -995,9 +970,6 @@ class PyastGenPass(Pass):
                 )
             )
         ]
-        self.link_jac_py_nodes(jac_node=node.name_ref, py_nodes=node.gen.py_ast)
-        if isinstance(node.body, ast.AbilityDef):
-            self.link_jac_py_nodes(jac_node=node.body, py_nodes=node.gen.py_ast)
 
     def gen_llm_body(self, node: ast.Ability) -> list[ast3.AST]:
         """Generate llm body."""
@@ -1291,15 +1263,6 @@ class PyastGenPass(Pass):
         doc: Optional[String],
         decorators: Optional[SubNodeList[ExprType]],
         """
-        for i in node.target.archs:
-            if i.sym_link:
-                self.link_jac_py_nodes(jac_node=i, py_nodes=i.sym_link.decl.gen.py_ast)
-                self.link_jac_py_nodes(
-                    jac_node=i.name_ref, py_nodes=i.sym_link.decl.gen.py_ast
-                )
-        if isinstance(node.parent, ast.Ability) and node.parent.signature:
-            # TODO: Here we need to do a link for each subnode to the original parent signature
-            pass
 
     def exit_func_signature(self, node: ast.FuncSignature) -> None:
         """Sub objects.
@@ -1464,7 +1427,6 @@ class PyastGenPass(Pass):
                 )
             )
         ]
-        self.link_jac_py_nodes(jac_node=node.name, py_nodes=node.gen.py_ast)
 
     def exit_arch_has(self, node: ast.ArchHas) -> None:
         """Sub objects.
@@ -1720,8 +1682,6 @@ class PyastGenPass(Pass):
                 )
             )
         ]
-        if node.name:
-            self.link_jac_py_nodes(jac_node=node.name, py_nodes=node.gen.py_ast)
 
     def exit_finally_stmt(self, node: ast.FinallyStmt) -> None:
         """Sub objects.
@@ -1829,9 +1789,6 @@ class PyastGenPass(Pass):
                 )
             )
         ]
-        self.link_jac_py_nodes(jac_node=node.expr, py_nodes=node.gen.py_ast)
-        if node.alias:
-            self.link_jac_py_nodes(jac_node=node.alias, py_nodes=node.gen.py_ast)
 
     def exit_raise_stmt(self, node: ast.RaiseStmt) -> None:
         """Sub objects.
@@ -2089,7 +2046,6 @@ class PyastGenPass(Pass):
                     jac_node=x,
                 )
             )
-            self.link_jac_py_nodes(jac_node=x, py_nodes=[py_nodes[-1]])
         node.gen.py_ast = [*py_nodes]
 
     def exit_non_local_stmt(self, node: ast.NonLocalStmt) -> None:
@@ -2105,7 +2061,6 @@ class PyastGenPass(Pass):
                     jac_node=x,
                 )
             )
-            self.link_jac_py_nodes(jac_node=x, py_nodes=[py_nodes[-1]])
         node.gen.py_ast = [*py_nodes]
 
     def exit_assignment(self, node: ast.Assignment) -> None:
@@ -2647,8 +2602,6 @@ class PyastGenPass(Pass):
                 )
             )
         ]
-        if node.key:
-            self.link_jac_py_nodes(jac_node=node.key, py_nodes=node.gen.py_ast)
 
     def exit_inner_compr(self, node: ast.InnerCompr) -> None:
         """Sub objects.
@@ -2758,9 +2711,6 @@ class PyastGenPass(Pass):
                         )
                     )
                 ]
-                self.link_jac_py_nodes(
-                    jac_node=node.right.sym_name_node, py_nodes=node.gen.py_ast
-                )
             else:
                 self.error("Invalid attribute access")
         elif isinstance(node.right, ast.FilterCompr):
@@ -3025,7 +2975,6 @@ class PyastGenPass(Pass):
                     for kw_pair in node.params.items
                     if isinstance(kw_pair, ast.KWPair)
                 ]
-                self.cout += 1
             else:
                 inputs = []
 

jaclang/compiler/passes/main/pyjac_ast_link_pass.py

@@ -0,0 +1,218 @@
+"""Jac to python ast link pass."""
+
+import ast as ast3
+
+import jaclang.compiler.absyntree as ast
+from jaclang.compiler.passes import Pass
+
+
+class PyJacAstLinkPass(Pass):
+    """Link jac ast to python ast nodes."""
+
+    def link_jac_py_nodes(
+        self, jac_node: ast.AstNode, py_nodes: list[ast3.AST]
+    ) -> None:
+        """Link jac name ast to py ast nodes."""
+        jac_node.gen.py_ast = py_nodes
+        for i in py_nodes:
+            if isinstance(i.jac_link, list):  # type: ignore
+                i.jac_link.append(jac_node)  # type: ignore
+
+    def exit_module_path(self, node: ast.ModulePath) -> None:
+        """Sub objects.
+
+        path: Sequence[Token],
+        alias: Optional[Name],
+        path_str: str,
+        """
+        if node.alias:
+            self.link_jac_py_nodes(jac_node=node.alias, py_nodes=node.gen.py_ast)
+
+    def exit_architype(self, node: ast.Architype) -> None:
+        """Sub objects.
+
+        name: Name,
+        arch_type: Token,
+        access: Optional[SubTag[Token]],
+        base_classes: Optional[SubNodeList[AtomType]],
+        body: Optional[SubNodeList[ArchBlockStmt] | ArchDef],
+        doc: Optional[String],
+        decorators: Optional[SubNodeList[ExprType]],
+        """
+        self.link_jac_py_nodes(jac_node=node.name, py_nodes=node.gen.py_ast)
+        if isinstance(node.body, ast.ArchDef):
+            self.link_jac_py_nodes(jac_node=node.body, py_nodes=node.gen.py_ast)
+
+    def exit_arch_def(self, node: ast.ArchDef) -> None:
+        """Sub objects.
+
+        target: ArchRefChain,
+        body: SubNodeList[ArchBlockStmt],
+        doc: Optional[String],
+        decorators: Optional[SubNodeList[ExprType]],
+        """
+        for i in node.target.archs:
+            if i.sym_link:
+                self.link_jac_py_nodes(jac_node=i, py_nodes=i.sym_link.decl.gen.py_ast)
+                self.link_jac_py_nodes(
+                    jac_node=i.name_ref, py_nodes=i.sym_link.decl.gen.py_ast
+                )
+
+    def exit_enum(self, node: ast.Enum) -> None:
+        """Sub objects.
+
+        name: Name,
+        access: Optional[SubTag[Token]],
+        base_classes: Optional[Optional[SubNodeList[AtomType]]],
+        body: Optional[SubNodeList[EnumBlockStmt] | EnumDef],
+        doc: Optional[String],
+        decorators: Optional[SubNodeList[ExprType]],
+        """
+        if isinstance(node.body, ast.EnumDef):
+            self.link_jac_py_nodes(jac_node=node.body, py_nodes=node.gen.py_ast)
+
+    def exit_enum_def(self, node: ast.EnumDef) -> None:
+        """Sub objects.
+
+        target: ArchRefChain,
+        body: SubNodeList[EnumBlockStmt],
+        doc: Optional[String],
+        decorators: Optional[SubNodeList[ExprType]],
+        """
+        for i in node.target.archs:
+            if i.sym_link:
+                self.link_jac_py_nodes(jac_node=i, py_nodes=i.sym_link.decl.gen.py_ast)
+                self.link_jac_py_nodes(
+                    jac_node=i.name_ref, py_nodes=i.sym_link.decl.gen.py_ast
+                )
+
+    def exit_ability(self, node: ast.Ability) -> None:
+        """Sub objects.
+
+        name_ref: NameType,
+        is_func: bool,
+        is_async: bool,
+        is_static: bool,
+        is_abstract: bool,
+        access: Optional[SubTag[Token]],
+        signature: Optional[FuncSignature | ExprType | EventSignature],
+        body: Optional[SubNodeList[CodeBlockStmt] | AbilityDef | FuncCall],
+        doc: Optional[String],
+        decorators: Optional[SubNodeList[ExprType]],
+        """
+        self.link_jac_py_nodes(jac_node=node.name_ref, py_nodes=node.gen.py_ast)
+        if isinstance(node.body, ast.AbilityDef):
+            self.link_jac_py_nodes(jac_node=node.body, py_nodes=node.gen.py_ast)
+
+    def exit_ability_def(self, node: ast.AbilityDef) -> None:
+        """Sub objects.
+
+        target: ArchRefChain,
+        signature: FuncSignature | EventSignature,
+        body: SubNodeList[CodeBlockStmt],
+        doc: Optional[String],
+        decorators: Optional[SubNodeList[ExprType]],
+        """
+        for i in node.target.archs:
+            if i.sym_link:
+                self.link_jac_py_nodes(jac_node=i, py_nodes=i.sym_link.decl.gen.py_ast)
+                self.link_jac_py_nodes(
+                    jac_node=i.name_ref, py_nodes=i.sym_link.decl.gen.py_ast
+                )
+
+        if isinstance(node.parent, ast.Ability) and node.parent.signature:
+            if isinstance(node.signature, ast.FuncSignature) and node.signature.params:
+                for src_prm in node.signature.params.items:
+                    if (
+                        isinstance(node.parent.signature, ast.FuncSignature)
+                        and node.parent.signature.params
+                    ):
+                        for trg_prm in node.parent.signature.params.items:
+                            if src_prm.name.sym_name == trg_prm.name.sym_name:
+                                self.link_jac_py_nodes(
+                                    jac_node=src_prm, py_nodes=trg_prm.gen.py_ast
+                                )
+                                self.link_jac_py_nodes(
+                                    jac_node=src_prm.name,
+                                    py_nodes=trg_prm.name.gen.py_ast,
+                                )
+            if (
+                isinstance(node.signature, ast.FuncSignature)
+                and node.signature.return_type
+            ) and (
+                isinstance(node.parent.signature, ast.FuncSignature)
+                and node.parent.signature.return_type
+            ):
+                self.link_jac_py_nodes(
+                    jac_node=node.signature.return_type,
+                    py_nodes=node.parent.signature.return_type.gen.py_ast,
+                )
+
+    def exit_param_var(self, node: ast.ParamVar) -> None:
+        """Sub objects.
+
+        name: Name,
+        unpack: Optional[Token],
+        type_tag: SubTag[ExprType],
+        value: Optional[ExprType],
+        """
+        self.link_jac_py_nodes(jac_node=node.name, py_nodes=node.gen.py_ast)
+
+    def exit_except(self, node: ast.Except) -> None:
+        """Sub objects.
+
+        ex_type: ExprType,
+        name: Optional[Name],
+        body: SubNodeList[CodeBlockStmt],
+        """
+        if node.name:
+            self.link_jac_py_nodes(jac_node=node.name, py_nodes=node.gen.py_ast)
+
+    def exit_expr_as_item(self, node: ast.ExprAsItem) -> None:
+        """Sub objects.
+
+        expr: ExprType,
+        alias: Optional[ExprType],
+        """
+        self.link_jac_py_nodes(jac_node=node.expr, py_nodes=node.gen.py_ast)
+        if node.alias:
+            self.link_jac_py_nodes(jac_node=node.alias, py_nodes=node.gen.py_ast)
+
+    def exit_global_stmt(self, node: ast.GlobalStmt) -> None:
+        """Sub objects.
+
+        target: SubNodeList[NameType],
+        """
+        for x, y in enumerate(node.target.items):
+            self.link_jac_py_nodes(jac_node=y, py_nodes=[node.gen.py_ast[x]])
+
+    def exit_non_local_stmt(self, node: ast.NonLocalStmt) -> None:
+        """Sub objects.
+
+        target: SubNodeList[NameType],
+        """
+        for x, y in enumerate(node.target.items):
+            self.link_jac_py_nodes(jac_node=y, py_nodes=[node.gen.py_ast[x]])
+
+    def exit_k_w_pair(self, node: ast.KWPair) -> None:
+        """Sub objects.
+
+        key: NameType,
+        value: ExprType,
+        """
+        if node.key:
+            self.link_jac_py_nodes(jac_node=node.key, py_nodes=node.gen.py_ast)
+
+    def exit_atom_trailer(self, node: ast.AtomTrailer) -> None:
+        """Sub objects.
+
+        target: Expr,
+        right: AtomExpr | Expr,
+        is_attr: bool,
+        is_null_ok: bool,
+        is_genai: bool = False,
+        """
+        if node.is_attr and isinstance(node.right, ast.AstSymbolNode):
+            self.link_jac_py_nodes(
+                jac_node=node.right.sym_name_node, py_nodes=node.gen.py_ast
+            )

jaclang/compiler/passes/main/schedules.py

@@ -14,6 +14,7 @@ from .def_use_pass import DefUsePass  # noqa: I100
 from .pyout_pass import PyOutPass  # noqa: I100
 from .pybc_gen_pass import PyBytecodeGenPass  # noqa: I100
 from .pyast_gen_pass import PyastGenPass  # noqa: I100
+from .pyjac_ast_link_pass import PyJacAstLinkPass  # noqa: I100
 from .type_check_pass import JacTypeCheckPass  # noqa: I100
 from .fuse_typeinfo_pass import FuseTypeInfoPass  # noqa: I100
 from .registry_pass import RegistryPass  # noqa: I100
@@ -28,6 +29,7 @@ py_code_gen = [
     DefUsePass,
     RegistryPass,
     PyastGenPass,
+    PyJacAstLinkPass,
     PyBytecodeGenPass,
 ]
 

jaclang/compiler/passes/main/sym_tab_build_pass.py

@@ -217,9 +217,9 @@ class SymTabBuildPass(SymTabPass):
         else:
             self.cur_sym_tab.append(self.cur_scope().push_scope(name, key_node))
 
-    def pop_scope(self) -> None:
+    def pop_scope(self) -> SymbolTable:
         """Pop scope."""
-        self.cur_sym_tab.pop()
+        return self.cur_sym_tab.pop()
 
     def cur_scope(self) -> SymbolTable:
         """Return current scope."""
@@ -263,7 +263,13 @@ class SymTabBuildPass(SymTabPass):
         mod_path: str,
         is_imported: bool,
         """
-        self.pop_scope()
+        s = self.pop_scope()
+        # If not the main module add all the other modules symbol table
+        # as a child to the current symbol table
+        if node != self.ir:
+            self.cur_scope().kid.append(s)
+            s.parent = self.cur_scope()
+
         if (
             isinstance(node.parent, ast.Module)
             and node

jaclang/compiler/passes/main/tests/test_import_pass.py

@@ -1,5 +1,6 @@
 """Test pass module."""
 
+import jaclang.compiler.absyntree as ast
 from jaclang.compiler.compile import jac_file_to_pass
 from jaclang.compiler.passes.main import JacImportPass
 from jaclang.utils.test import TestCase
@@ -17,3 +18,13 @@ class ImportPassPassTests(TestCase):
         state = jac_file_to_pass(self.fixture_abs_path("base.jac"), JacImportPass)
         self.assertFalse(state.errors_had)
         self.assertIn("56", str(state.ir.to_dict()))
+
+    def test_import_auto_impl(self) -> None:
+        """Basic test for pass."""
+        state = jac_file_to_pass(self.fixture_abs_path("autoimpl.jac"), JacImportPass)
+        num_modules = len(state.ir.get_all_sub_nodes(ast.Module))
+        mod_names = [i.name for i in state.ir.get_all_sub_nodes(ast.Module)]
+        self.assertEqual(num_modules, 3)
+        self.assertIn("getme.impl", mod_names)
+        self.assertIn("autoimpl.impl", mod_names)
+        self.assertIn("autoimpl.something.else.impl", mod_names)

jaclang/core/aott.py

@@ -138,22 +138,31 @@ def get_type_explanation(
         _, type_info = mod_registry.lookup(scope=sem_info_scope)
         type_info_str = []
         type_info_types = []
+        type_example = [f"{sem_info.name}("]
         if sem_info.type == "Enum" and isinstance(type_info, list):
             for enum_item in type_info:
                 type_info_str.append(
                     f"{enum_item.semstr} ({enum_item.name}) (EnumItem)"
                 )
+            type_example[0] = type_example[0].replace("(", f".{enum_item.name}")
         elif sem_info.type in ["obj", "class", "node", "edge"] and isinstance(
             type_info, list
         ):
             for arch_item in type_info:
+                if arch_item.type in ["obj", "class", "node", "edge"]:
+                    continue
                 type_info_str.append(
                     f"{arch_item.semstr} ({arch_item.name}) ({arch_item.type})"
                 )
+                type_example.append(f"{arch_item.name}={arch_item.type}, ")
                 if arch_item.type and extract_non_primary_type(arch_item.type):
                     type_info_types.extend(extract_non_primary_type(arch_item.type))
+            if len(type_example) > 1:
+                type_example[-1] = type_example[-1].replace(", ", ")")
+            else:
+                type_example.append(")")
         return (
-            f"{sem_info.semstr} ({sem_info.name}) ({sem_info.type}) = {', '.join(type_info_str)}",
+            f"{sem_info.semstr} ({sem_info.name}) ({sem_info.type}) eg:- {''.join(type_example)} -> {', '.join(type_info_str)}",  # noqa: E501
             set(type_info_types),
         )
     return None, None