jaclang 0.7.14__py3-none-any.whl → 0.7.17__py3-none-any.whl

jaclang/compiler/passes/main/fuse_typeinfo_pass.py

@@ -6,8 +6,7 @@ mypy apis into Jac and use jac py ast in it.
 
 from __future__ import annotations
 
-import traceback
-from typing import Callable, TypeVar
+from typing import Callable, Optional, TypeVar
 
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.passes import Pass
@@ -30,12 +29,12 @@ class FuseTypeInfoPass(Pass):
 
     node_type_hash: dict[MypyNodes.Node | VNode, MyType] = {}
 
-    def __debug_print(self, *argv: object) -> None:
+    def __debug_print(self, msg: str) -> None:
         if settings.fuse_type_info_debug:
-            print("FuseTypeInfo::", *argv)
+            self.log_info("FuseTypeInfo::" + msg)
 
     def __call_type_handler(
-        self, node: ast.AstSymbolNode, mypy_type: MypyTypes.ProperType
+        self, node: ast.AstSymbolNode, mypy_type: MypyTypes.Type
     ) -> None:
         mypy_type_name = pascal_to_snake(mypy_type.__class__.__name__)
         type_handler_name = f"get_type_from_{mypy_type_name}"
@@ -53,6 +52,9 @@ class FuseTypeInfoPass(Pass):
         if typ[0] == "builtins":
             return
 
+        if node.sym_type == "types.ModuleType" and node.sym:
+            node.name_spec.type_sym_tab = node.sym.parent_tab.find_scope(node.sym_name)
+
         assert isinstance(self.ir, ast.Module)
 
         if typ_sym_table:
@@ -66,13 +68,44 @@ class FuseTypeInfoPass(Pass):
         if typ_sym_table != self.ir.sym_tab:
             node.name_spec.type_sym_tab = typ_sym_table
 
+    def __collect_python_dependencies(self, node: ast.AstNode) -> None:
+        assert isinstance(node, ast.AstSymbolNode)
+        assert isinstance(self.ir, ast.Module)
+
+        mypy_node = node.gen.mypy_ast[0]
+
+        if isinstance(mypy_node, MypyNodes.RefExpr) and mypy_node.node:
+            node_full_name = mypy_node.node.fullname
+            if "." in node_full_name:
+                mod_name = node_full_name[: node_full_name.rindex(".")]
+            else:
+                mod_name = node_full_name
+
+            if mod_name not in self.ir.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]
+            if mode_path.endswith(".jac"):
+                return
+
+            self.ir.py_raise_map[mod_name] = mode_path
+        else:
+            self.__debug_print(
+                f"Collect python dependencies is not supported in {type(node)}::{node.loc}"
+            )
+
     @staticmethod
     def __handle_node(
         func: Callable[[FuseTypeInfoPass, T], None]
     ) -> Callable[[FuseTypeInfoPass, T], None]:
         def node_handler(self: FuseTypeInfoPass, node: T) -> None:
             if not isinstance(node, ast.AstSymbolNode):
-                print(f"Warning {node.__class__.__name__} is not an AstSymbolNode")
+                self.__debug_print(
+                    f"Warning {node.__class__.__name__} is not an AstSymbolNode"
+                )
 
             try:
                 jac_node_str = f'jac node "{node.loc}::{node.__class__.__name__}'
@@ -85,6 +118,7 @@ class FuseTypeInfoPass(Pass):
                 if len(node.gen.mypy_ast) == 1:
                     func(self, node)
                     self.__set_sym_table_link(node)
+                    self.__collect_python_dependencies(node)
 
                 # Jac node has multiple mypy nodes linked to it
                 elif len(node.gen.mypy_ast) > 1:
@@ -100,27 +134,28 @@ class FuseTypeInfoPass(Pass):
                     # Check the number of unique mypy nodes linked
                     if len(temp) > 1:
                         self.__debug_print(
-                            jac_node_str, "has multiple mypy nodes associated to it"
+                            f"{jac_node_str} has multiple mypy nodes associated to it"
                         )
                     else:
                         self.__debug_print(
-                            jac_node_str, "has duplicate mypy nodes associated to it"
+                            f"{jac_node_str} has duplicate mypy nodes associated to it"
                         )
                         func(self, node)
                         self.__set_sym_table_link(node)
+                        self.__collect_python_dependencies(node)
 
                 # Jac node doesn't have mypy nodes linked to it
                 else:
                     self.__debug_print(
-                        jac_node_str, "doesn't have mypy node associated to it"
+                        f"{jac_node_str} doesn't have mypy node associated to it"
                     )
 
             except AttributeError as e:
+                if settings.fuse_type_info_debug:
+                    raise e
                 self.__debug_print(
-                    f'Internal error happened while parsing "{e.obj.__class__.__name__}"'
+                    f'{node.loc}: Internal error happened while parsing "{e.obj.__class__.__name__}"'
                 )
-                traceback.print_exc()
-                print(e)
 
         return node_handler
 
@@ -129,12 +164,7 @@ class FuseTypeInfoPass(Pass):
 
         if isinstance(mypy_node, MypyNodes.MemberExpr):
             if mypy_node in self.node_type_hash:
-                t = str(self.node_type_hash[mypy_node])
-                if "def" in t and "->" in t:
-                    t = t.split("->")[1].strip()
-                elif "def" in t:
-                    t = "None"
-                node.name_spec.sym_type = t
+                self.__call_type_handler(node, self.node_type_hash[mypy_node])
             else:
                 self.__debug_print(f"{node.loc} MemberExpr type is not found")
 
@@ -159,8 +189,8 @@ class FuseTypeInfoPass(Pass):
 
             else:
                 self.__debug_print(
-                    f'"{node.loc}::{node.__class__.__name__}" mypy (with node attr) node isn\'t supported',
-                    type(mypy_node),
+                    f'"{node.loc}::{node.__class__.__name__}" mypy (with node attr) node isn\'t supported'
+                    f"{type(mypy_node)}"
                 )
 
         else:
@@ -175,8 +205,8 @@ class FuseTypeInfoPass(Pass):
                 self.__call_type_handler(node, mypy_node.func.type.ret_type)
             else:
                 self.__debug_print(
-                    f'"{node.loc}::{node.__class__.__name__}" mypy node isn\'t supported',
-                    type(mypy_node),
+                    f'"{node.loc}::{node.__class__.__name__}" mypy node isn\'t supported'
+                    f"{type(mypy_node)}"
                 )
 
     @__handle_node
@@ -187,12 +217,12 @@ class FuseTypeInfoPass(Pass):
     @__handle_node
     def enter_module_path(self, node: ast.ModulePath) -> None:
         """Pass handler for ModulePath nodes."""
-        self.__debug_print("Getting type not supported in", type(node))
+        self.__debug_print(f"Getting type not supported in {type(node)}")
 
     @__handle_node
     def enter_module_item(self, node: ast.ModuleItem) -> None:
         """Pass handler for ModuleItem nodes."""
-        self.__debug_print("Getting type not supported in", type(node))
+        self.__debug_print(f"Getting type not supported in {type(node)}")
 
     @__handle_node
     def enter_architype(self, node: ast.Architype) -> None:
@@ -202,7 +232,7 @@ class FuseTypeInfoPass(Pass):
     @__handle_node
     def enter_arch_def(self, node: ast.ArchDef) -> None:
         """Pass handler for ArchDef nodes."""
-        self.__debug_print("Getting type not supported in", type(node))
+        self.__debug_print(f"Getting type not supported in {type(node)}")
 
     @__handle_node
     def enter_enum(self, node: ast.Enum) -> None:
@@ -212,7 +242,7 @@ class FuseTypeInfoPass(Pass):
     @__handle_node
     def enter_enum_def(self, node: ast.EnumDef) -> None:
         """Pass handler for EnumDef nodes."""
-        self.__debug_print("Getting type not supported in", type(node))
+        self.__debug_print(f"Getting type not supported in {type(node)}")
 
     @__handle_node
     def enter_ability(self, node: ast.Ability) -> None:
@@ -221,8 +251,8 @@ class FuseTypeInfoPass(Pass):
             self.__call_type_handler(node, node.gen.mypy_ast[0].type.ret_type)
         else:
             self.__debug_print(
-                f"{node.loc}: Can't get type of an ability from mypy node other than Ability.",
-                type(node.gen.mypy_ast[0]),
+                f"{node.loc}: Can't get type of an ability from mypy node other than Ability. "
+                f"{type(node.gen.mypy_ast[0])}"
             )
 
     @__handle_node
@@ -232,8 +262,8 @@ class FuseTypeInfoPass(Pass):
             self.__call_type_handler(node, node.gen.mypy_ast[0].type.ret_type)
         else:
             self.__debug_print(
-                f"{node.loc}: Can't get type of an AbilityDef from mypy node other than FuncDef.",
-                type(node.gen.mypy_ast[0]),
+                f"{node.loc}: Can't get type of an AbilityDef from mypy node other than FuncDef. "
+                f"{type(node.gen.mypy_ast[0])}"
             )
 
     @__handle_node
@@ -279,7 +309,7 @@ class FuseTypeInfoPass(Pass):
     @__handle_node
     def enter_f_string(self, node: ast.FString) -> None:
         """Pass handler for FString nodes."""
-        self.__debug_print("Getting type not supported in", type(node))
+        self.__debug_print(f"Getting type not supported in {type(node)}")
 
     @__handle_node
     def enter_list_val(self, node: ast.ListVal) -> None:
@@ -332,7 +362,7 @@ class FuseTypeInfoPass(Pass):
     @__handle_node
     def enter_index_slice(self, node: ast.IndexSlice) -> None:
         """Pass handler for IndexSlice nodes."""
-        self.__debug_print("Getting type not supported in", type(node))
+        self.__debug_print(f"Getting type not supported in {type(node)}")
 
     @__handle_node
     def enter_arch_ref(self, node: ast.ArchRef) -> None:
@@ -346,8 +376,8 @@ class FuseTypeInfoPass(Pass):
             self.__call_type_handler(node, mypy_node2.type)
         else:
             self.__debug_print(
-                f"{node.loc}: Can't get ArchRef value from mypyNode other than ClassDef",
-                type(node.gen.mypy_ast[0]),
+                f"{node.loc}: Can't get ArchRef value from mypyNode other than ClassDef "
+                f"type(node.gen.mypy_ast[0])"
             )
 
     @__handle_node
@@ -363,12 +393,12 @@ class FuseTypeInfoPass(Pass):
     @__handle_node
     def enter_filter_compr(self, node: ast.FilterCompr) -> None:
         """Pass handler for FilterCompr nodes."""
-        self.__debug_print("Getting type not supported in", type(node))
+        self.__debug_print(f"Getting type not supported in {type(node)}")
 
     @__handle_node
     def enter_assign_compr(self, node: ast.AssignCompr) -> None:
         """Pass handler for AssignCompr nodes."""
-        self.__debug_print("Getting type not supported in", type(node))
+        self.__debug_print(f"Getting type not supported in {type(node)}")
 
     @__handle_node
     def enter_int(self, node: ast.Int) -> None:
@@ -405,7 +435,7 @@ class FuseTypeInfoPass(Pass):
         self, node: ast.AstSymbolNode, mypy_type: MypyTypes.CallableType
     ) -> None:
         """Get type info from mypy type CallableType."""
-        node.name_spec.sym_type = str(mypy_type.ret_type)
+        self.__call_type_handler(node, mypy_type.ret_type)
 
     # TODO: Which overloaded function to get the return value from?
     def get_type_from_overloaded(
@@ -432,6 +462,12 @@ class FuseTypeInfoPass(Pass):
         """Get type info from mypy type TupleType."""
         node.name_spec.sym_type = "builtins.tuple"
 
+    def get_type_from_type_type(
+        self, node: ast.AstSymbolNode, mypy_type: MypyTypes.TypeType
+    ) -> None:
+        """Get type info from mypy type TypeType."""
+        node.name_spec.sym_type = str(mypy_type.item)
+
     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
@@ -447,20 +483,85 @@ class FuseTypeInfoPass(Pass):
                 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()
+    def expand_atom_trailer(self, node_list: list[ast.AstNode]) -> list[ast.AstNode]:
+        """Expand the atom trailer object in a list of AstNode."""
+        out: list[ast.AstNode] = []
+        for i in node_list:
+            if isinstance(i, ast.AtomTrailer):
+                out.append(i.target)
+                out.append(i.right)
+            elif isinstance(i, ast.FuncCall):
+                out.append(i.target)
+            else:
+                out.append(i)
+        return out
+
+    def exit_atom_trailer(self, node: ast.AtomTrailer) -> None:
+        """Adding symbol links to AtomTrailer right nodes."""
+        # This will fix adding the symbol links to nodes in atom trailer
+        # self.x.z = 5  # will add symbol links to both x and z
+
+        # This function originally used `as_attr_list` in AtomTrailer
+        # but an issue happened when doing stuff like fool_me().CONST_VALUE2
+        # The issue was due to the way `as_attr_list` implemented so the fix
+        # was to implement it again to get all items in AtomTrailer even if
+        # their type is not an AstSymbolNode
+        atom_trailer_unwind = self.expand_atom_trailer([node])
+        iteration_count = 0
+        while any(
+            isinstance(i, (ast.AtomTrailer, ast.FuncCall)) for i in atom_trailer_unwind
+        ):
+            atom_trailer_unwind = self.expand_atom_trailer(atom_trailer_unwind)
+            iteration_count += 1
+            if iteration_count > 50:
+                break
+
+        for i in range(1, len(atom_trailer_unwind)):
+            left = atom_trailer_unwind[i - 1]
+            right = atom_trailer_unwind[i]
+
+            assert isinstance(left, ast.AstSymbolNode)
+            assert isinstance(right, ast.AstSymbolNode)
+
+            if isinstance(right, ast.IndexSlice):
+                # In case of index slice, left won't have a symbol table as it's a list/dict/set
+                node_type: str = ""
+
+                # left type is a list
+                if left.sym_type.startswith("builtins.list["):
+                    node_type = left.sym_type[len("builtins.list[") : -1]
+
+                    # right index slice is a range then it's type is the same as left
+                    if right.is_range:
+                        right.name_spec.sym_type = left.sym_type
+                        continue
+
+                # left type is a dictionary
+                elif left.sym_type.startswith("builtins.dict["):
+                    node_type = (
+                        left.sym_type[len("builtins.dict[") : -1].split(",")[1].strip()
+                    )
+
+                # unsupported type
+                else:
+                    continue
+
+                right.name_spec.sym_type = node_type
+
+                # Getting the correct symbol table and link it
+                type_symtab: Optional[SymbolTable] = self.ir.sym_tab
+                assert isinstance(self.ir, ast.Module)
+                assert isinstance(type_symtab, SymbolTable)
+                for j in node_type.split("."):
+                    if j == self.ir.name:
+                        continue
+                    type_symtab = type_symtab.find_scope(j)
+                    if type_symtab is None:
+                        break
+                right.name_spec.type_sym_tab = type_symtab
+
+            else:
+                if left.type_sym_tab:
+                    right.name_spec.sym = left.type_sym_tab.lookup(right.sym_name)
+                    if right.name_spec.sym:
+                        right.name_spec.sym.add_use(right.name_spec)

jaclang/compiler/passes/main/import_pass.py

@@ -6,17 +6,17 @@ symbols are available for matching.
 """
 
 import ast as py_ast
-import importlib.util
 import os
-import sys
 from typing import Optional
 
 
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.passes import Pass
-from jaclang.compiler.passes.main import SubNodeTabPass
-from jaclang.settings import settings
-from jaclang.utils.helpers import import_target_to_relative_path, is_standard_lib_module
+from jaclang.compiler.passes.main import SubNodeTabPass, SymTabBuildPass
+from jaclang.utils.log import logging
+
+
+logger = logging.getLogger(__name__)
 
 
 class JacImportPass(Pass):
@@ -25,40 +25,29 @@ class JacImportPass(Pass):
     def before_pass(self) -> None:
         """Run once before pass."""
         self.import_table: dict[str, ast.Module] = {}
-        self.__py_imports: set[str] = set()
-        self.py_resolve_list: set[str] = set()
 
     def enter_module(self, node: ast.Module) -> None:
         """Run Importer."""
         self.cur_node = node
         self.import_table[node.loc.mod_path] = node
-        self.__py_imports.clear()
-        self.__annex_impl(node)
+        self.annex_impl(node)
         self.terminate()  # Turns off auto traversal for deliberate traversal
         self.run_again = True
         while self.run_again:
             self.run_again = False
             all_imports = self.get_all_sub_nodes(node, ast.ModulePath)
             for i in all_imports:
-                self.process_import(node, i)
+                self.process_import(i)
                 self.enter_module_path(i)
             SubNodeTabPass(prior=self, input_ir=node)
 
-        for i in self.get_all_sub_nodes(node, ast.AtomTrailer):
-            self.enter_atom_trailer(i)
-
-        node.mod_deps = self.import_table
+        node.mod_deps.update(self.import_table)
 
-    def process_import(self, node: ast.Module, i: ast.ModulePath) -> None:
+    def process_import(self, i: ast.ModulePath) -> None:
         """Process an import."""
-        lang = i.parent_of_type(ast.Import).hint.tag.value
-        if lang == "jac" and not i.sub_module:
-            self.import_jac_module(
-                node=i,
-                mod_path=node.loc.mod_path,
-            )
-        elif lang == "py":
-            self.__py_imports.add(i.path_str)
+        imp_node = i.parent_of_type(ast.Import)
+        if imp_node.is_jac and not i.sub_module:
+            self.import_jac_module(node=i)
 
     def attach_mod_to_node(
         self, node: ast.ModulePath | ast.ModuleItem, mod: ast.Module | None
@@ -67,10 +56,11 @@ class JacImportPass(Pass):
         if mod:
             self.run_again = True
             node.sub_module = mod
-            self.__annex_impl(mod)
+            self.annex_impl(mod)
             node.add_kids_right([mod], pos_update=False)
+            mod.parent = node
 
-    def __annex_impl(self, node: ast.Module) -> None:
+    def annex_impl(self, node: ast.Module) -> None:
         """Annex impl and test modules."""
         if node.stub_only:
             return
@@ -131,19 +121,10 @@ class JacImportPass(Pass):
             node.sub_module.name = node.alias.value
         # Items matched during def/decl pass
 
-    def enter_atom_trailer(self, node: ast.AtomTrailer) -> None:
-        """Iterate on AtomTrailer nodes to get python paths to resolve."""
-        if node.as_attr_list[0].sym_name in self.__py_imports:
-            self.py_resolve_list.add(".".join([i.sym_name for i in node.as_attr_list]))
-
-    def import_jac_module(self, node: ast.ModulePath, mod_path: str) -> None:
+    def import_jac_module(self, node: ast.ModulePath) -> None:
         """Import a module."""
         self.cur_node = node  # impacts error reporting
-        target = import_target_to_relative_path(
-            level=node.level,
-            target=node.path_str,
-            base_path=os.path.dirname(node.loc.mod_path),
-        )
+        target = node.resolve_relative_path()
         # If the module is a package (dir)
         if os.path.isdir(target):
             self.attach_mod_to_node(node, self.import_jac_mod_from_dir(target))
@@ -153,11 +134,7 @@ class JacImportPass(Pass):
                 # Import all from items as modules or packages
                 for i in import_node.items.items:
                     if isinstance(i, ast.ModuleItem):
-                        from_mod_target = import_target_to_relative_path(
-                            level=node.level,
-                            target=node.path_str + "." + i.name.value,
-                            base_path=os.path.dirname(node.loc.mod_path),
-                        )
+                        from_mod_target = node.resolve_relative_path(i.name.value)
                         # If package
                         if os.path.isdir(from_mod_target):
                             self.attach_mod_to_node(
@@ -204,7 +181,7 @@ class JacImportPass(Pass):
             self.warnings_had += mod_pass.warnings_had
             mod = mod_pass.ir
         except Exception as e:
-            print(e)
+            logger.info(e)
             mod = None
         if isinstance(mod, ast.Module):
             self.import_table[target] = mod
@@ -222,55 +199,102 @@ class PyImportPass(JacImportPass):
     def before_pass(self) -> None:
         """Only run pass if settings are set to raise python."""
         super().before_pass()
-        if not settings.py_raise:
-            self.terminate()
 
-    def process_import(self, node: ast.Module, i: ast.ModulePath) -> None:
+    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 process_import(self, 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 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
-                i.add_kids_right([mod], pos_update=False)
-                if settings.py_raise_deep:
-                    self.run_again = True
+        # Process import is orginally implemented to handle ModulePath in Jaclang
+        # 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
+        # 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
+                        ),
+                    )
+            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
+                        ),
+                    )
 
     def import_py_module(
-        self, node: ast.ModulePath, mod_path: str
+        self,
+        parent_node: ast.ModulePath | ast.ModuleItem,
+        imported_mod_name: str,
+        mod_path: str,
     ) -> Optional[ast.Module]:
         """Import a module."""
         from jaclang.compiler.passes.main import PyastBuildPass
 
-        base_dir = os.path.dirname(mod_path)
-        sys.path.append(base_dir)
+        assert isinstance(self.ir, ast.Module)
+
+        python_raise_map = self.ir.py_raise_map
+        file_to_raise = 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)
+            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:
+            return None
+
         try:
-            # Dynamically import the module
-            spec = importlib.util.find_spec(node.path_str)
-            sys.path.remove(base_dir)
-            if spec and spec.origin and spec.origin not in {None, "built-in", "frozen"}:
-                if spec.origin in self.import_table:
-                    return self.import_table[spec.origin]
-                with open(spec.origin, "r", encoding="utf-8") as f:
-                    # print(f"\nImporting python module {node.path_str}")
+            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:
                     mod = PyastBuildPass(
                         input_ir=ast.PythonModuleAst(
-                            py_ast.parse(f.read()), mod_path=spec.origin
+                            py_ast.parse(f.read()), mod_path=file_to_raise
                         ),
                     ).ir
+                    SubNodeTabPass(input_ir=mod, prior=self)
                 if mod:
-                    self.import_table[spec.origin] = 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 {node.path_str}: {spec.origin}"
-                    )
+                    raise self.ice(f"Failed to import python module {mod_path}")
         except Exception as e:
-            if "Empty kid for Token ModulePath" in str(e) or "utf-8" in str(e):  # FIXME
-                return None
-            self.error(
-                f"Failed to import python module {node.path_str}: {e}",
-                node_override=node,
-            )
+            self.error(f"Failed to import python module {mod_path}")
             raise e
         return None
+
+    def annex_impl(self, node: ast.Module) -> None:
+        """Annex impl and test modules."""
+        return None