jaclang 0.7.16__py3-none-any.whl → 0.7.18__py3-none-any.whl

jaclang/compiler/passes/main/import_pass.py

@@ -6,19 +6,16 @@ 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 is_standard_lib_module
+from jaclang.compiler.passes.main import SubNodeTabPass, SymTabBuildPass
 from jaclang.utils.log import logging
 
+
 logger = logging.getLogger(__name__)
 
 
@@ -28,37 +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."""
         imp_node = i.parent_of_type(ast.Import)
         if imp_node.is_jac and not i.sub_module:
             self.import_jac_module(node=i)
-        elif imp_node.is_py:
-            self.__py_imports.add(i.path_str)
 
     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,11 +121,6 @@ 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) -> None:
         """Import a module."""
         self.cur_node = node  # impacts error reporting
@@ -214,58 +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."""
+        # 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
-            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
+        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:
+            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

jaclang/compiler/passes/main/py_collect_dep_pass.py

@@ -0,0 +1,70 @@
+"""Collect Python dependencies based on reference sourced from Jac.
+
+This pass will use mypy to calculate the python package/module dependencies
+that are only relevant to actual references source from Jac code.
+"""
+
+from __future__ import annotations
+
+
+import jaclang.compiler.absyntree as ast
+from jaclang.compiler.passes import Pass
+from jaclang.settings import settings
+
+import mypy.nodes as MypyNodes  # noqa N812
+
+
+class PyCollectDepsPass(Pass):
+    """Python and bytecode file self.__debug_printing pass."""
+
+    def __debug_print(self, msg: str) -> None:
+        if settings.collect_py_dep_debug:
+            self.log_info("CollectPythonDependencies::" + msg)
+
+    def enter_node(self, node: ast.AstNode) -> None:
+        """Collect python dependencies from all Jac Nodes."""
+        assert isinstance(self.ir, ast.Module)
+
+        if not isinstance(node, ast.AstSymbolNode):
+            return
+
+        path: str = ""
+        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)
+        elif isinstance(node, ast.ModuleItem):
+            imp = node.parent_of_type(ast.Import)
+            mod_path_node = imp.get_all_sub_nodes(ast.ModulePath)[0]
+            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)
+
+        if len(node.gen.mypy_ast) == 0:
+            return
+
+        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}"
+            )

jaclang/compiler/passes/main/pyast_gen_pass.py

@@ -529,7 +529,7 @@ class PyastGenPass(Pass):
         sub_module: Optional[Module],
         """
         path_alias: dict[str, Optional[str]] = (
-            {node.from_loc.path_str: None} if node.from_loc else {}
+            {node.from_loc.dot_path_str: None} if node.from_loc else {}
         )
         imp_from = {}
         if node.items:
@@ -539,7 +539,7 @@ class PyastGenPass(Pass):
                         item.alias.sym_name if item.alias else None
                     )
                 elif isinstance(item, ast.ModulePath):
-                    path_alias[item.path_str] = (
+                    path_alias[item.dot_path_str] = (
                         item.alias.sym_name if item.alias else None
                     )
 
@@ -828,7 +828,7 @@ class PyastGenPass(Pass):
             typecheck_nodes.append(
                 self.sync(
                     py_node=ast3.ImportFrom(
-                        module=(source.path_str.lstrip(".") if source else None),
+                        module=(source.dot_path_str.lstrip(".") if source else None),
                         names=[self.sync(ast3.alias(name="*"), node)],
                         level=0,
                     ),
@@ -842,7 +842,7 @@ class PyastGenPass(Pass):
                 self.sync(
                     ast3.ImportFrom(
                         module=(
-                            node.from_loc.path_str.lstrip(".")
+                            node.from_loc.dot_path_str.lstrip(".")
                             if node.from_loc
                             else None
                         ),
@@ -879,7 +879,7 @@ class PyastGenPass(Pass):
         node.gen.py_ast = [
             self.sync(
                 ast3.alias(
-                    name=f"{node.path_str}",
+                    name=f"{node.dot_path_str}",
                     asname=node.alias.sym_name if node.alias else None,
                 )
             )
@@ -2367,7 +2367,22 @@ class PyastGenPass(Pass):
                             node.left.gen.py_ast[0],
                             node.right.gen.py_ast[0],
                             self.sync(
-                                ast3.Constant(value=node.op.edge_spec.edge_dir.name)
+                                ast3.Attribute(
+                                    value=self.sync(
+                                        ast3.Attribute(
+                                            value=self.sync(
+                                                ast3.Name(
+                                                    id=Con.JAC_FEATURE.value,
+                                                    ctx=ast3.Load(),
+                                                )
+                                            ),
+                                            attr="EdgeDir",
+                                            ctx=ast3.Load(),
+                                        )
+                                    ),
+                                    attr=node.op.edge_spec.edge_dir.name,
+                                    ctx=ast3.Load(),
+                                )
                             ),
                             (
                                 node.op.edge_spec.filter_cond.gen.py_ast[0]
@@ -2626,6 +2641,31 @@ class PyastGenPass(Pass):
             ]
         elif node.op.name in [Tok.STAR_POW]:
             node.gen.py_ast = node.operand.gen.py_ast
+        elif node.op.name in [Tok.BW_AND]:
+            node.gen.py_ast = [
+                self.sync(
+                    ast3.Call(
+                        func=self.sync(
+                            ast3.Attribute(
+                                value=self.sync(
+                                    ast3.Name(id=Con.JAC_FEATURE.value, ctx=ast3.Load())
+                                ),
+                                attr="get_object",
+                                ctx=ast3.Load(),
+                            )
+                        ),
+                        args=[],
+                        keywords=[
+                            self.sync(
+                                ast3.keyword(
+                                    arg="id",
+                                    value=node.operand.gen.py_ast[0],
+                                )
+                            ),
+                        ],
+                    )
+                )
+            ]
         else:
             self.ice(f"Unknown Unary operator {node.op.value}")
 

jaclang/compiler/passes/main/pyast_load_pass.py

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

jaclang/compiler/passes/main/pyjac_ast_link_pass.py

@@ -162,6 +162,13 @@ class PyJacAstLinkPass(Pass):
                     py_nodes=node.parent.signature.return_type.gen.py_ast,
                 )
 
+        if isinstance(node.decl_link, ast.Ability) and isinstance(
+            node.target, ast.ArchRefChain
+        ):
+            for arch in node.target.archs:
+                if arch.arch_name.sym:
+                    arch.arch_name.sym.add_use(arch.arch_name)
+
     def exit_param_var(self, node: ast.ParamVar) -> None:
         """Sub objects.
 

jaclang/compiler/passes/main/schedules.py

@@ -19,11 +19,11 @@ from .type_check_pass import JacTypeCheckPass  # noqa: I100
 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
 
 py_code_gen = [
     SubNodeTabPass,
     JacImportPass,
-    PyImportPass,
     SymTabBuildPass,
     DeclImplMatchPass,
     DefUsePass,
@@ -33,6 +33,13 @@ py_code_gen = [
     PyBytecodeGenPass,
 ]
 
-type_checker_sched = [JacTypeCheckPass, FuseTypeInfoPass, AccessCheckPass]
+type_checker_sched = [
+    JacTypeCheckPass,
+    PyCollectDepsPass,
+    PyImportPass,
+    DefUsePass,
+    FuseTypeInfoPass,
+    AccessCheckPass,
+]
 py_code_gen_typed = [*py_code_gen, *type_checker_sched]
 py_compiler = [*py_code_gen, PyOutPass]

jaclang/compiler/passes/main/sym_tab_build_pass.py

@@ -19,12 +19,16 @@ class SymTabBuildPass(Pass):
         """Before pass."""
         self.cur_sym_tab: list[SymbolTable] = []
 
-    def push_scope(self, name: str, key_node: ast.AstNode, fresh: bool = False) -> None:
+    def push_scope(self, name: str, key_node: ast.AstNode) -> None:
         """Push scope."""
-        if fresh:
+        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:
+            self.cur_sym_tab.append(inherit.sym_tab)
+            self.cur_sym_tab.append(self.cur_scope.push_kid_scope(name, key_node))
         else:
-            self.cur_sym_tab.append(self.cur_scope.push_scope(name, key_node))
+            self.cur_sym_tab.append(self.cur_scope.push_kid_scope(name, key_node))
 
     def pop_scope(self) -> SymbolTable:
         """Pop scope."""
@@ -48,7 +52,7 @@ class SymTabBuildPass(Pass):
         mod_path: str,
         is_imported: bool,
         """
-        self.push_scope(node.name, node, fresh=(node == self.ir))
+        self.push_scope(node.name, node)
         self.sync_node_to_scope(node)
         for obj in dir(builtins):
             builtin = ast.Name(
@@ -197,7 +201,7 @@ class SymTabBuildPass(Pass):
             source = node.items.items[0]
             if not isinstance(source, ast.ModulePath) or not source.sub_module:
                 self.error(
-                    f"Module {node.from_loc.path_str if node.from_loc else 'from location'}"
+                    f"Module {node.from_loc.dot_path_str if node.from_loc else 'from location'}"
                     f" not found to include *, or ICE occurred!"
                 )
             else:

jaclang/compiler/passes/main/tests/fixtures/autoimpl.jac

@@ -6,4 +6,4 @@ with entry {
     foo();
     bar();
     baz();
-}
+}

jaclang/compiler/passes/main/tests/fixtures/py_imp_test.jac

@@ -0,0 +1,29 @@
+import:py math;
+import:py argparse;
+import:py from pygame_mock { color, display }
+import:py pygame_mock;
+import:py os;
+
+can fool_me -> `Type[pygame_mock.constants.CL] {
+    return pygame_mock.constants.CL;
+}
+
+obj kk {
+    can fool_me -> `Type[pygame_mock.constants.CL] {
+        return pygame_mock.constants.CL;
+    }
+}
+
+with entry {
+    b = math.floor(1.7);
+    c: color.Color = color.Color(pygame_mock.constants.CONST_VALUE);
+    c2: pygame_mock.color.Color = color.Color(pygame_mock.constants.CL.CONST_VALUE2);
+    c3: pygame_mock.color.Color = color.Color(fool_me().CONST_VALUE2);
+    c4: pygame_mock.color.Color = color.Color(kk().fool_me().CONST_VALUE2);
+    g = fool_me();
+    c4: pygame_mock.color.Color = color.Color(g.CONST_VALUE2);
+    a: argparse.ArgumentParser = argparse.ArgumentParser();
+    print("Hello", 1, b);
+    pygame_mock.display.set_mode(WIN_WIDTH, WIN_HEIGHT);
+    print(os.path.isfile("/jj"));
+}

jaclang/compiler/passes/main/tests/fixtures/pygame_mock/__init__.py

@@ -0,0 +1,3 @@
+from .display import *
+from .color import *
+from .constants import *

jaclang/compiler/passes/main/tests/fixtures/pygame_mock/color.py

@@ -0,0 +1,3 @@
+class Color:
+    def __init__(self, value: int | str) -> None:
+        pass

jaclang/compiler/passes/main/tests/fixtures/pygame_mock/constants.py

@@ -0,0 +1,5 @@
+CONST_VALUE: int = 0
+
+
+class CL:
+    CONST_VALUE2: str = "h"

jaclang/compiler/passes/main/tests/fixtures/pygame_mock/display.py

@@ -0,0 +1,2 @@
+def set_mode(a, b):
+    pass

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

@@ -1,8 +1,15 @@
 """Test pass module."""
 
+import io
+import re
+import sys
+
 import jaclang.compiler.absyntree as ast
+from jaclang.cli import cli
 from jaclang.compiler.compile import jac_file_to_pass
 from jaclang.compiler.passes.main import JacImportPass
+from jaclang.compiler.passes.main.fuse_typeinfo_pass import FuseTypeInfoPass
+from jaclang.compiler.passes.main.schedules import py_code_gen_typed
 from jaclang.utils.test import TestCase
 
 
@@ -24,7 +31,7 @@ class ImportPassPassTests(TestCase):
         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.assertEqual(num_modules, 4)
         self.assertIn("getme.impl", mod_names)
         self.assertIn("autoimpl.impl", mod_names)
         self.assertIn("autoimpl.something.else.impl", mod_names)
@@ -36,7 +43,7 @@ class ImportPassPassTests(TestCase):
         )
         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, 4)
+        self.assertEqual(num_modules, 5)
         self.assertIn("getme.impl", mod_names)
         self.assertIn("autoimpl", mod_names)
         self.assertIn("autoimpl.impl", mod_names)
@@ -52,17 +59,69 @@ class ImportPassPassTests(TestCase):
             if i.name != "autoimpl":
                 count += 1
                 self.assertEqual(i.annexable_by, self.fixture_abs_path("autoimpl.jac"))
-        self.assertEqual(count, 3)
+        self.assertEqual(count, 4)
+
+    def test_py_raise_map(self) -> None:
+        """Basic test for pass."""
+        build = jac_file_to_pass(
+            self.fixture_abs_path("py_imp_test.jac"),
+            FuseTypeInfoPass,
+            schedule=py_code_gen_typed,
+        )
+        assert isinstance(build.ir, ast.Module)
+        p = {
+            "math": "jaclang/jaclang/vendor/mypy/typeshed/stdlib/math.pyi",
+            "pygame_mock": "pygame_mock/__init__.py",
+            "pygame_mock.color": "pygame_mock/color.py",
+            "pygame_mock.constants": "pygame_mock/constants.py",
+            "argparse": "jaclang/vendor/mypy/typeshed/stdlib/argparse.pyi",
+            "builtins": "jaclang/vendor/mypy/typeshed/stdlib/builtins.pyi",
+            "pygame_mock.display": "pygame_mock/display.py",
+            "os": "jaclang/vendor/mypy/typeshed/stdlib/os/__init__.pyi",
+            "genericpath": "jaclang/vendor/mypy/typeshed/stdlib/genericpath.pyi",
+        }
+        for i in p:
+            self.assertIn(i, build.ir.py_raise_map)
+            self.assertIn(p[i], re.sub(r".*fixtures/", "", build.ir.py_raise_map[i]))
 
-    def test_py_resolve_list(self) -> None:
+    def test_py_raised_mods(self) -> None:
         """Basic test for pass."""
-        state: JacImportPass = jac_file_to_pass(
-            self.examples_abs_path("rpg_game/jac_impl/jac_impl_5/main.jac"),
-            JacImportPass,
+        state = jac_file_to_pass(
+            self.fixture_abs_path("py_imp_test.jac"), schedule=py_code_gen_typed
+        )
+        self.assertEqual(
+            len(
+                list(
+                    filter(
+                        lambda x: x.is_raised_from_py,
+                        state.ir.get_all_sub_nodes(ast.Module),
+                    )
+                )
+            ),
+            7,
         )
-        self.assertGreater(len(state.py_resolve_list), 20)
-        self.assertIn("pygame.sprite.Sprite.__init__", state.py_resolve_list)
-        self.assertIn("pygame.mouse.get_pressed", state.py_resolve_list)
-        self.assertIn("pygame.K_SPACE", state.py_resolve_list)
-        self.assertIn("random.randint", state.py_resolve_list)
-        self.assertIn("pygame.font.Font", state.py_resolve_list)
+
+    # def test_py_resolve_list(self) -> None:
+    #     """Basic test for pass."""
+    #     state: JacImportPass = jac_file_to_pass(
+    #         self.examples_abs_path("rpg_game/jac_impl/jac_impl_5/main.jac"),
+    #         JacImportPass,
+    #     )
+    #     self.assertGreater(len(state.py_resolve_list), 20)
+    #     self.assertIn("pygame.sprite.Sprite.__init__", state.py_resolve_list)
+    #     self.assertIn("pygame.mouse.get_pressed", state.py_resolve_list)
+    #     self.assertIn("pygame.K_SPACE", state.py_resolve_list)
+    #     self.assertIn("random.randint", state.py_resolve_list)
+    #     self.assertIn("pygame.font.Font", state.py_resolve_list)
+
+    def test_double_empty_anx(self) -> None:
+        """Test importing python."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        cli.run(self.fixture_abs_path("autoimpl.jac"))
+        cli.run(self.fixture_abs_path("autoimpl.jac"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        self.assertIn("foo", stdout_value)
+        self.assertIn("bar", stdout_value)
+        self.assertIn("baz", stdout_value)