jaclang 0.7.11__py3-none-any.whl → 0.7.14__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

jaclang/compiler/absyntree.py

@@ -621,6 +621,7 @@ class Module(AstDocNode):
         doc: Optional[String],
         body: Sequence[ElementStmt | String | EmptyToken],
         is_imported: bool,
+        terminals: list[Token],
         kid: Sequence[AstNode],
         stub_only: bool = False,
         registry: Optional[SemRegistry] = None,
@@ -635,6 +636,7 @@ class Module(AstDocNode):
         self.test_mod: list[Module] = []
         self.mod_deps: dict[str, Module] = {}
         self.registry = registry
+        self.terminals: list[Token] = terminals
         AstNode.__init__(self, kid=kid)
         AstDocNode.__init__(self, doc=doc)
 
@@ -642,15 +644,15 @@ class Module(AstDocNode):
     def annexable_by(self) -> Optional[str]:
         """Get annexable by."""
         if not self.stub_only and (
-            self.loc.mod_path.endswith("impl.jac")
-            or self.loc.mod_path.endswith("test.jac")
+            self.loc.mod_path.endswith(".impl.jac")
+            or self.loc.mod_path.endswith(".test.jac")
         ):
             head_mod_name = self.name.split(".")[0]
             potential_path = os.path.join(
                 os.path.dirname(self.loc.mod_path),
                 f"{head_mod_name}.jac",
             )
-            if os.path.exists(potential_path):
+            if os.path.exists(potential_path) and potential_path != self.loc.mod_path:
                 return potential_path
             annex_dir = os.path.split(os.path.dirname(self.loc.mod_path))[-1]
             if annex_dir.endswith(".impl") or annex_dir.endswith(".test"):
@@ -661,7 +663,10 @@ class Module(AstDocNode):
                     os.path.dirname(os.path.dirname(self.loc.mod_path)),
                     f"{head_mod_name}.jac",
                 )
-                if os.path.exists(potential_path):
+                if (
+                    os.path.exists(potential_path)
+                    and potential_path != self.loc.mod_path
+                ):
                     return potential_path
         return None
 
@@ -916,9 +921,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 +943,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

@@ -56,6 +56,7 @@ class JacParser(Pass):
             source=self.source,
             doc=None,
             body=[],
+            terminals=[],
             is_imported=False,
             kid=[ast.EmptyToken()],
         )
@@ -120,6 +121,7 @@ class JacParser(Pass):
             """Initialize transformer."""
             super().__init__(*args, **kwargs)
             self.parse_ref = parser
+            self.terminals: list[ast.Token] = []
 
         def ice(self) -> Exception:
             """Raise internal compiler error."""
@@ -131,7 +133,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:
@@ -159,6 +162,7 @@ class JacParser(Pass):
                 doc=doc,
                 body=body,
                 is_imported=False,
+                terminals=self.terminals,
                 kid=kid if len(kid) else [ast.EmptyToken()],
             )
             return self.nu(mod)
@@ -3982,4 +3986,5 @@ class JacParser(Pass):
                     err.line = ret.loc.first_line
                     err.column = ret.loc.col_start
                     raise err
+            self.terminals.append(ret)
             return self.nu(ret)

jaclang/compiler/passes/main/import_pass.py

@@ -182,6 +182,7 @@ class JacImportPass(Pass):
                 source=ast.JacSource("", mod_path=target),
                 doc=None,
                 body=[],
+                terminals=[],
                 is_imported=False,
                 stub_only=True,
                 kid=[ast.EmptyToken()],

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:
@@ -426,14 +434,7 @@ class PyastGenPass(Pass):
         body: SubNodeList[CodeBlockStmt],
         doc: Optional[String],
         """
-        if node.doc:
-            doc = self.sync(ast3.Expr(value=node.doc.gen.py_ast[0]), jac_node=node.doc)
-            if isinstance(node.body.gen.py_ast, list):
-                node.gen.py_ast = [doc] + node.body.gen.py_ast
-            else:
-                raise self.ice()
-        else:
-            node.gen.py_ast = node.body.gen.py_ast
+        node.gen.py_ast = self.resolve_stmt_block(node.body, doc=node.doc)
         if node.name:
             node.gen.py_ast = [
                 self.sync(
@@ -480,7 +481,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 +489,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 +497,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 +577,7 @@ class PyastGenPass(Pass):
                                         ast3.keyword(
                                             arg="target",
                                             value=self.sync(
-                                                ast3.Constant(value=p),
+                                                ast3.Constant(value=path),
                                             ),
                                         )
                                     ),
@@ -541,7 +586,8 @@ class PyastGenPass(Pass):
                                             arg="base_path",
                                             value=self.sync(
                                                 ast3.Name(
-                                                    id="__file__", ctx=ast3.Load()
+                                                    id="__file__",
+                                                    ctx=ast3.Load(),
                                                 )
                                             ),
                                         )
@@ -580,7 +626,7 @@ class PyastGenPass(Pass):
                                         ast3.keyword(
                                             arg="mdl_alias",
                                             value=self.sync(
-                                                ast3.Constant(value=a),
+                                                ast3.Constant(value=alias),
                                             ),
                                         )
                                     ),
@@ -588,21 +634,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 +807,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 +823,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

@@ -124,6 +124,7 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
             source=ast.JacSource("", mod_path=self.mod_path),
             doc=doc_str,
             body=valid[1:] if valid and isinstance(valid[0], ast.String) else valid,
+            terminals=[],
             is_imported=False,
             kid=valid,
         )
@@ -1507,11 +1508,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

@@ -47,8 +47,12 @@ class ImportPassPassTests(TestCase):
         state = jac_file_to_pass(
             self.fixture_abs_path("incautoimpl.jac"), JacImportPass
         )
+        count = 0
         for i in state.ir.get_all_sub_nodes(ast.Module):
-            self.assertEqual(i.annexable_by, self.fixture_abs_path("autoimpl.jac"))
+            if i.name != "autoimpl":
+                count += 1
+                self.assertEqual(i.annexable_by, self.fixture_abs_path("autoimpl.jac"))
+        self.assertEqual(count, 3)
 
     def test_py_resolve_list(self) -> None:
         """Basic test for pass."""

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/fuse_comments_pass.py

@@ -27,7 +27,12 @@ class FuseCommentsPass(Pass):
         """Insert comment tokens into all_tokens."""
         comment_stream = iter(self.comments)  # Iterator for comments
         code_stream = iter(self.all_tokens)  # Iterator for code tokens
-        new_stream: list[ast.AstNode] = []  # New stream to hold ordered tokens
+        new_stream: list[ast.Token] = []  # New stream to hold ordered tokens
+
+        if not isinstance(self.ir, ast.Module):
+            raise self.ice(
+                f"FuseCommentsPass can only be run on a Module, not a {type(self.ir)}"
+            )
 
         try:
             next_comment = next(comment_stream)  # Get the first comment
@@ -39,12 +44,20 @@ class FuseCommentsPass(Pass):
         except StopIteration:
             next_code = None
 
+        if next_comment and (not next_code or is_comment_next(next_comment, next_code)):
+            self.ir.terminals.insert(0, next_comment)
+
         while next_comment or next_code:
             if next_comment and (
                 not next_code or is_comment_next(next_comment, next_code)
             ):
                 # Add the comment to the new stream
+                last_tok = new_stream[-1] if len(new_stream) else None
                 new_stream.append(next_comment)
+                if last_tok:
+                    self.ir.terminals.insert(
+                        self.ir.terminals.index(last_tok) + 1, next_comment
+                    )
                 try:
                     next_comment = next(comment_stream)
                 except StopIteration:
@@ -70,7 +83,6 @@ class FuseCommentsPass(Pass):
                         parent_kids.insert(insert_index, token)
                         prev_token.parent.set_kids(parent_kids)
                     else:
-                        prev_token.pp()
                         raise self.ice(
                             "Token without parent in AST should be impossible"
                         )