jaclang 0.7.9__py3-none-any.whl → 0.7.13__py3-none-any.whl

jaclang/cli/cli.py

@@ -92,22 +92,30 @@ def run(
     base = base if base else "./"
     mod = mod[:-4]
     if filename.endswith(".jac"):
-        loaded_mod = jac_import(
+        ret_module = jac_import(
             target=mod,
             base_path=base,
             cachable=cache,
             override_name="__main__" if main else None,
         )
+        if ret_module is None:
+            loaded_mod = None
+        else:
+            (loaded_mod,) = ret_module
     elif filename.endswith(".jir"):
         with open(filename, "rb") as f:
             ir = pickle.load(f)
-            loaded_mod = jac_import(
+            ret_module = jac_import(
                 target=mod,
                 base_path=base,
                 cachable=cache,
                 override_name="__main__" if main else None,
                 mod_bundle=ir,
             )
+            if ret_module is None:
+                loaded_mod = None
+            else:
+                (loaded_mod,) = ret_module
     else:
         print("Not a .jac file.")
         return
@@ -243,7 +251,7 @@ def test(
 
     jac test => jac test -d .
     """
-    Jac.run_test(
+    failcount = Jac.run_test(
         filepath=filepath,
         filter=filter,
         xit=xit,
@@ -251,6 +259,8 @@ def test(
         directory=directory,
         verbose=verbose,
     )
+    if failcount:
+        raise SystemExit(f"Tests failed: {failcount}")
 
 
 @cmd_registry.register

jaclang/compiler/absyntree.py

@@ -916,9 +916,17 @@ class ModulePath(AstSymbolNode):
         self.sub_module: Optional[Module] = None
 
         name_spec = alias if alias else path[0] if path else None
+
+        AstNode.__init__(self, kid=kid)
+        if not name_spec:
+            pkg_name = self.loc.mod_path
+            for _ in range(self.level):
+                pkg_name = os.path.dirname(pkg_name)
+            pkg_name = pkg_name.split(os.sep)[-1]
+            name_spec = Name.gen_stub_from_node(self, pkg_name)
+            self.level += 1
         if not isinstance(name_spec, Name):
             raise ValueError("ModulePath should have a name spec. Impossible.")
-        AstNode.__init__(self, kid=kid)
         AstSymbolNode.__init__(
             self,
             sym_name=name_spec.sym_name,
@@ -930,7 +938,7 @@ class ModulePath(AstSymbolNode):
     def path_str(self) -> str:
         """Get path string."""
         return ("." * self.level) + ".".join(
-            [p.value for p in self.path] if self.path else ""
+            [p.value for p in self.path] if self.path else [self.name_spec.sym_name]
         )
 
     def normalize(self, deep: bool = False) -> bool:

jaclang/compiler/parser.py

@@ -131,7 +131,8 @@ class JacParser(Pass):
         def nu(self, node: ast.T) -> ast.T:
             """Update node."""
             self.parse_ref.cur_node = node
-            self.parse_ref.node_list.append(node)
+            if node not in self.parse_ref.node_list:
+                self.parse_ref.node_list.append(node)
             return node
 
         def start(self, kid: list[ast.Module]) -> ast.Module:

jaclang/compiler/passes/ir_pass.py

@@ -1,9 +1,11 @@
 """Abstract class for IR Passes for Jac."""
 
+import time
 from typing import Optional, Type, TypeVar
 
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.passes.transform import Transform
+from jaclang.settings import settings
 from jaclang.utils.helpers import pascal_to_snake
 
 T = TypeVar("T", bound=ast.AstNode)
@@ -17,6 +19,7 @@ class Pass(Transform[T]):
         self.term_signal = False
         self.prune_signal = False
         self.ir: ast.AstNode = input_ir
+        self.time_taken = 0.0
         Transform.__init__(self, input_ir, prior)
 
     def before_pass(self) -> None:
@@ -104,11 +107,17 @@ class Pass(Transform[T]):
         # Only performs passes on proper ASTs
         if not isinstance(ir, ast.AstNode):
             return ir
+        start_time = time.time()
         self.before_pass()
         if not isinstance(ir, ast.AstNode):
             raise ValueError("Current node is not an AstNode.")
         self.traverse(ir)
         self.after_pass()
+        self.time_taken = time.time() - start_time
+        if settings.pass_timer:
+            print(
+                f"Time taken in {self.__class__.__name__}: {self.time_taken:.4f} seconds"
+            )
         return self.ir
 
     def traverse(self, node: ast.AstNode) -> ast.AstNode:

jaclang/compiler/passes/main/import_pass.py

@@ -25,11 +25,14 @@ 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.terminate()  # Turns off auto traversal for deliberate traversal
         self.run_again = True
@@ -40,6 +43,10 @@ class JacImportPass(Pass):
                 self.process_import(node, 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
 
     def process_import(self, node: ast.Module, i: ast.ModulePath) -> None:
@@ -50,6 +57,8 @@ class JacImportPass(Pass):
                 node=i,
                 mod_path=node.loc.mod_path,
             )
+        elif lang == "py":
+            self.__py_imports.add(i.path_str)
 
     def attach_mod_to_node(
         self, node: ast.ModulePath | ast.ModuleItem, mod: ast.Module | None
@@ -122,6 +131,11 @@ 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:
         """Import a module."""
         self.cur_node = node  # impacts error reporting
@@ -206,10 +220,9 @@ 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()
-        else:
-            return super().before_pass()
 
     def process_import(self, node: ast.Module, i: ast.ModulePath) -> None:
         """Process an import."""

jaclang/compiler/passes/main/pyast_gen_pass.py

@@ -50,7 +50,15 @@ class PyastGenPass(Pass):
                     level=0,
                 ),
                 jac_node=self.ir,
-            )
+            ),
+            self.sync(
+                ast3.ImportFrom(
+                    module="typing",
+                    names=[self.sync(ast3.alias(name="TYPE_CHECKING", asname=None))],
+                    level=0,
+                ),
+                jac_node=self.ir,
+            ),
         ]
 
     def enter_node(self, node: ast.AstNode) -> None:
@@ -480,7 +488,7 @@ class PyastGenPass(Pass):
     def exit_import(self, node: ast.Import) -> None:
         """Sub objects.
 
-        lang: SubTag[Name],
+        hint: SubTag[Name],
         paths: list[ModulePath],
         alias: Optional[Name],
         items: Optional[SubNodeList[ModuleItem]],
@@ -488,12 +496,6 @@ class PyastGenPass(Pass):
         doc: Optional[String],
         sub_module: Optional[Module],
         """
-        py_nodes: list[ast3.AST] = []
-
-        if node.doc:
-            py_nodes.append(
-                self.sync(ast3.Expr(value=node.doc.gen.py_ast[0]), jac_node=node.doc)
-            )
         path_alias: dict[str, Optional[str]] = (
             {node.from_loc.path_str: None} if node.from_loc else {}
         )
@@ -502,25 +504,75 @@ class PyastGenPass(Pass):
             for item in node.items.items:
                 if isinstance(item, ast.ModuleItem):
                     imp_from[item.name.sym_name] = (
-                        item.alias.sym_name if item.alias else False
+                        item.alias.sym_name if item.alias else None
                     )
                 elif isinstance(item, ast.ModulePath):
                     path_alias[item.path_str] = (
                         item.alias.sym_name if item.alias else None
                     )
 
-        keys = []
-        values = []
-        for k in imp_from.keys():
-            keys.append(self.sync(ast3.Constant(value=k)))
-        for v in imp_from.values():
-            values.append(self.sync(ast3.Constant(value=v)))
-
+        item_keys = []
+        item_values = []
+        for k, v in imp_from.items():
+            item_keys.append(self.sync(ast3.Constant(value=k)))
+            item_values.append(self.sync(ast3.Constant(value=v)))
         self.needs_jac_import()
-        for p, a in path_alias.items():
+        path_named_value: str
+        py_nodes: list[ast3.AST] = []
+        typecheck_nodes: list[ast3.AST] = []
+        runtime_nodes: list[ast3.AST] = []
+
+        if node.doc:
             py_nodes.append(
+                self.sync(ast3.Expr(value=node.doc.gen.py_ast[0]), jac_node=node.doc)
+            )
+
+        for path, alias in path_alias.items():
+            path_named_value = ("_jac_inc_" if node.is_absorb else "") + (
+                alias if alias else path
+            ).lstrip(".").split(".")[0]
+            # target_named_value = ""
+            # for i in path.split("."):
+            #     target_named_value += i if i else "."
+            #     if i:
+            #         break
+            runtime_nodes.append(
                 self.sync(
-                    ast3.Expr(
+                    ast3.Assign(
+                        targets=(
+                            [
+                                self.sync(
+                                    ast3.Tuple(
+                                        elts=(
+                                            [
+                                                self.sync(
+                                                    ast3.Name(
+                                                        id=path_named_value,
+                                                        ctx=ast3.Store(),
+                                                    )
+                                                )
+                                            ]
+                                            if not len(item_keys)
+                                            else []
+                                            + [
+                                                self.sync(
+                                                    ast3.Name(
+                                                        id=(
+                                                            v.value
+                                                            if v.value
+                                                            else k.value
+                                                        ),
+                                                        ctx=ast3.Store(),
+                                                    )
+                                                )
+                                                for k, v in zip(item_keys, item_values)
+                                            ]
+                                        ),
+                                        ctx=ast3.Store(),
+                                    )
+                                )
+                            ]
+                        ),
                         value=self.sync(
                             ast3.Call(
                                 func=self.sync(
@@ -532,7 +584,7 @@ class PyastGenPass(Pass):
                                         ast3.keyword(
                                             arg="target",
                                             value=self.sync(
-                                                ast3.Constant(value=p),
+                                                ast3.Constant(value=path),
                                             ),
                                         )
                                     ),
@@ -541,7 +593,8 @@ class PyastGenPass(Pass):
                                             arg="base_path",
                                             value=self.sync(
                                                 ast3.Name(
-                                                    id="__file__", ctx=ast3.Load()
+                                                    id="__file__",
+                                                    ctx=ast3.Load(),
                                                 )
                                             ),
                                         )
@@ -580,7 +633,7 @@ class PyastGenPass(Pass):
                                         ast3.keyword(
                                             arg="mdl_alias",
                                             value=self.sync(
-                                                ast3.Constant(value=a),
+                                                ast3.Constant(value=alias),
                                             ),
                                         )
                                     ),
@@ -588,21 +641,170 @@ class PyastGenPass(Pass):
                                         ast3.keyword(
                                             arg="items",
                                             value=self.sync(
-                                                ast3.Dict(keys=keys, values=values),
+                                                ast3.Dict(
+                                                    keys=item_keys, values=item_values
+                                                ),
                                             ),
                                         )
                                     ),
                                 ],
                             )
-                        )
+                        ),
                     ),
+                ),
+            )
+        if node.is_absorb:
+            absorb_exec = f"={path_named_value}.__dict__['"
+            runtime_nodes.append(
+                self.sync(
+                    ast3.For(
+                        target=self.sync(ast3.Name(id="i", ctx=ast3.Store())),
+                        iter=self.sync(
+                            ast3.IfExp(
+                                test=self.sync(
+                                    ast3.Compare(
+                                        left=self.sync(ast3.Constant(value="__all__")),
+                                        ops=[self.sync(ast3.In())],
+                                        comparators=[
+                                            self.sync(
+                                                ast3.Attribute(
+                                                    value=self.sync(
+                                                        ast3.Name(
+                                                            id=path_named_value,
+                                                            ctx=ast3.Load(),
+                                                        )
+                                                    ),
+                                                    attr="__dict__",
+                                                    ctx=ast3.Load(),
+                                                )
+                                            )
+                                        ],
+                                    )
+                                ),
+                                body=self.sync(
+                                    ast3.Attribute(
+                                        value=self.sync(
+                                            ast3.Name(
+                                                id=path_named_value, ctx=ast3.Load()
+                                            )
+                                        ),
+                                        attr="__all__",
+                                        ctx=ast3.Load(),
+                                    )
+                                ),
+                                orelse=self.sync(
+                                    ast3.Attribute(
+                                        value=self.sync(
+                                            ast3.Name(
+                                                id=path_named_value, ctx=ast3.Load()
+                                            )
+                                        ),
+                                        attr="__dict__",
+                                        ctx=ast3.Load(),
+                                    )
+                                ),
+                            )
+                        ),
+                        body=[
+                            self.sync(
+                                ast3.If(
+                                    test=self.sync(
+                                        ast3.UnaryOp(
+                                            op=self.sync(ast3.Not()),
+                                            operand=self.sync(
+                                                ast3.Call(
+                                                    func=self.sync(
+                                                        ast3.Attribute(
+                                                            value=self.sync(
+                                                                ast3.Name(
+                                                                    id="i",
+                                                                    ctx=ast3.Load(),
+                                                                )
+                                                            ),
+                                                            attr="startswith",
+                                                            ctx=ast3.Load(),
+                                                        )
+                                                    ),
+                                                    args=[
+                                                        self.sync(
+                                                            ast3.Constant(value="_")
+                                                        )
+                                                    ],
+                                                    keywords=[],
+                                                )
+                                            ),
+                                        )
+                                    ),
+                                    body=[
+                                        self.sync(
+                                            ast3.Expr(
+                                                value=self.sync(
+                                                    ast3.Call(
+                                                        func=self.sync(
+                                                            ast3.Name(
+                                                                id="exec",
+                                                                ctx=ast3.Load(),
+                                                            )
+                                                        ),
+                                                        args=[
+                                                            self.sync(
+                                                                ast3.JoinedStr(
+                                                                    values=[
+                                                                        self.sync(
+                                                                            ast3.FormattedValue(
+                                                                                value=self.sync(
+                                                                                    ast3.Name(
+                                                                                        id="i",
+                                                                                        ctx=ast3.Load(),
+                                                                                    )
+                                                                                ),
+                                                                                conversion=-1,
+                                                                            )
+                                                                        ),
+                                                                        self.sync(
+                                                                            ast3.Constant(
+                                                                                value=absorb_exec
+                                                                            )
+                                                                        ),
+                                                                        self.sync(
+                                                                            ast3.FormattedValue(
+                                                                                value=self.sync(
+                                                                                    ast3.Name(
+                                                                                        id="i",
+                                                                                        ctx=ast3.Load(),
+                                                                                    )
+                                                                                ),
+                                                                                conversion=-1,
+                                                                            )
+                                                                        ),
+                                                                        self.sync(
+                                                                            ast3.Constant(
+                                                                                value="']"
+                                                                            )
+                                                                        ),
+                                                                    ]
+                                                                )
+                                                            )
+                                                        ],
+                                                        keywords=[],
+                                                    )
+                                                )
+                                            )
+                                        )
+                                    ],
+                                    orelse=[],
+                                )
+                            )
+                        ],
+                        orelse=[],
+                    )
                 )
             )
         if node.is_absorb:
             source = node.items.items[0]
             if not isinstance(source, ast.ModulePath):
                 raise self.ice()
-            py_nodes.append(
+            typecheck_nodes.append(
                 self.sync(
                     py_node=ast3.ImportFrom(
                         module=(source.path_str.lstrip(".") if source else None),
@@ -612,15 +814,10 @@ class PyastGenPass(Pass):
                     jac_node=node,
                 )
             )
-            if node.items:
-                pass
-                # self.warning(
-                #     "Includes import * in target module into current namespace."
-                # )
-        if not node.from_loc:
-            py_nodes.append(self.sync(ast3.Import(names=node.items.gen.py_ast)))
+        elif not node.from_loc:
+            typecheck_nodes.append(self.sync(ast3.Import(names=node.items.gen.py_ast)))
         else:
-            py_nodes.append(
+            typecheck_nodes.append(
                 self.sync(
                     ast3.ImportFrom(
                         module=(
@@ -633,6 +830,15 @@ class PyastGenPass(Pass):
                     )
                 )
             )
+        py_nodes.append(
+            self.sync(
+                ast3.If(
+                    test=self.sync(ast3.Name(id="TYPE_CHECKING", ctx=ast3.Load())),
+                    body=typecheck_nodes,
+                    orelse=runtime_nodes,
+                )
+            )
+        )
         node.gen.py_ast = py_nodes
 
     def exit_module_path(self, node: ast.ModulePath) -> None:

jaclang/compiler/passes/main/pyast_load_pass.py

@@ -1507,11 +1507,13 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
                         pos_end=0,
                     )
                 )
+        moddots = [self.operator(Tok.DOT, ".") for _ in range(node.level)]
+        modparts = moddots + modpaths
         path = ast.ModulePath(
             path=modpaths,
             level=node.level,
             alias=None,
-            kid=modpaths,
+            kid=modparts,
         )
         names = [self.convert(name) for name in node.names]
         valid_names = []

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

@@ -49,3 +49,16 @@ class ImportPassPassTests(TestCase):
         )
         for i in state.ir.get_all_sub_nodes(ast.Module):
             self.assertEqual(i.annexable_by, self.fixture_abs_path("autoimpl.jac"))
+
+    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)

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

@@ -36,7 +36,7 @@ class PyastGenPassTests(TestCaseMicroSuite, AstSyncTestMixin):
     def test_hodge_podge(self) -> None:
         """Basic test for pass."""
         code_gen = jac_file_to_pass(
-            self.fixture_abs_path("../../../../../../examples/micro/hodge_podge.jac"),
+            self.examples_abs_path("micro/hodge_podge.jac"),
             target=PyastGenPass,
         )
 
@@ -45,7 +45,7 @@ class PyastGenPassTests(TestCaseMicroSuite, AstSyncTestMixin):
     def test_circle_py_ast(self) -> None:
         """Basic test for pass."""
         code_gen = jac_file_to_pass(
-            self.fixture_abs_path("../../../../../../examples/manual_code/circle.jac"),
+            self.examples_abs_path("manual_code/circle.jac"),
             target=PyastGenPass,
         )
         import ast as ast3

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

@@ -15,9 +15,7 @@ class SubNodePassTests(TestCase):
     def test_sub_node_pass(self) -> None:
         """Basic test for pass."""
         code_gen = jac_file_to_pass(
-            file_path=self.fixture_abs_path(
-                "../../../../../../examples/manual_code/circle.jac"
-            ),
+            file_path=self.examples_abs_path("manual_code/circle.jac"),
             target=SubNodeTabPass,
         )
         for i in code_gen.ir.kid[1].kid:

jaclang/compiler/passes/main/type_check_pass.py

@@ -94,29 +94,12 @@ class JacTypeCheckPass(Pass):
             mypy_graph[module.name] = st
             new_modules.append(st)
 
-        # def get_stub(mod: str) -> myab.BuildSource:
-        #     """Get stub file path."""
-        #     return myab.BuildSource(
-        #         path=str(
-        #             pathlib.Path(os.path.dirname(jaclang.__file__)).parent
-        #             / "stubs"
-        #             / "jaclang"
-        #             / "plugin"
-        #             / f"{mod}.pyi"
-        #         ),
-        #         module=f"jaclang.plugin.{mod}",
-        #     )
-
         graph = myab.load_graph(
             [
                 myab.BuildSource(
                     path=str(self.__path / "typeshed" / "stdlib" / "builtins.pyi"),
                     module="builtins",
                 ),
-                # get_stub("default"),
-                # get_stub("feature"),
-                # get_stub("spec"),
-                # get_stub("builtin"),
             ],
             manager,
             old_graph=mypy_graph,

jaclang/compiler/passes/tool/tests/test_unparse_validate.py

@@ -18,10 +18,9 @@ class JacUnparseTests(TestCaseMicroSuite, AstSyncTestMixin):
 
     def test_double_unparse(self) -> None:
         """Parse micro jac file."""
-        filename = "../../../../../../examples/manual_code/circle.jac"
         try:
             code_gen_pure = jac_file_to_pass(
-                self.fixture_abs_path(filename),
+                self.examples_abs_path("manual_code/circle.jac"),
                 target=PyastGenPass,
                 schedule=without_format,
             )

jaclang/compiler/tests/test_importer.py

@@ -17,7 +17,7 @@ class TestLoader(TestCase):
 
     def test_import_basic_python(self) -> None:
         """Test basic self loading."""
-        h = jac_import("fixtures.hello_world", base_path=__file__)
+        (h,) = jac_import("fixtures.hello_world", base_path=__file__)
         self.assertEqual(h.hello(), "Hello World!")  # type: ignore
 
     def test_modules_correct(self) -> None: