jaclang 0.6.5__py3-none-any.whl → 0.7.1__py3-none-any.whl

jaclang/compiler/absyntree.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import ast as ast3
+from hashlib import md5
 from types import EllipsisType
 from typing import Any, Callable, Generic, Optional, Sequence, Type, TypeVar
 
@@ -700,10 +701,12 @@ class ModuleItem(AstSymbolNode):
         name: Name,
         alias: Optional[Name],
         kid: Sequence[AstNode],
+        sub_module: Optional[Module] = None,
     ) -> None:
         """Initialize module item node."""
         self.name = name
         self.alias = alias
+        self.sub_module = sub_module
         AstNode.__init__(self, kid=kid)
         AstSymbolNode.__init__(
             self,
@@ -1026,16 +1029,6 @@ class Ability(
         AstDocNode.__init__(self, doc=doc)
         AstAsyncNode.__init__(self, is_async=is_async)
 
-    @property
-    def is_method(self) -> bool:
-        """Check if is method."""
-        check = isinstance(self.parent, SubNodeList) and isinstance(
-            self.parent.parent, Architype
-        )
-        if check:
-            self.sym_type = SymbolType.METHOD
-        return check
-
     @property
     def is_func(self) -> bool:
         """Check if is func."""
@@ -1151,14 +1144,6 @@ class AbilityDef(AstSymbolNode, ElementStmt, AstImplOnlyNode, CodeBlockStmt):
         self.set_kids(nodes=new_kid)
         return res
 
-    @property
-    def is_method(self) -> bool:
-        """Check if is method."""
-        return (
-            len(self.target.archs) > 1
-            and self.target.archs[-2].arch.name != Tok.ABILITY_OP
-        )
-
 
 class FuncSignature(AstSemStrNode):
     """FuncSignature node type for Jac Ast."""
@@ -1196,13 +1181,6 @@ class FuncSignature(AstSemStrNode):
         self.set_kids(nodes=new_kid)
         return res
 
-    @property
-    def is_method(self) -> bool:
-        """Check if is method."""
-        return (isinstance(self.parent, Ability) and self.parent.is_method) or (
-            isinstance(self.parent, AbilityDef) and self.parent.is_method
-        )
-
     @property
     def is_static(self) -> bool:
         """Check if is static."""
@@ -1255,17 +1233,6 @@ class EventSignature(AstSemStrNode):
         self.set_kids(nodes=new_kid)
         return res
 
-    @property
-    def is_method(self) -> bool:
-        """Check if is method."""
-        if (isinstance(self.parent, Ability) and self.parent.is_method) or (
-            isinstance(self.parent, AbilityDef)
-            and isinstance(self.parent.decl_link, Ability)
-            and self.parent.decl_link.is_method
-        ):
-            return True
-        return False
-
 
 class ArchRefChain(AstNode):
     """Arch ref list node type for Jac Ast."""
@@ -4081,6 +4048,7 @@ class JacSource(EmptyToken):
         """Initialize source string."""
         super().__init__()
         self.value = source
+        self.hash = md5(source.encode()).hexdigest()
         self.file_path = mod_path
         self.comments: list[CommentToken] = []
 

jaclang/compiler/compile.py

@@ -57,6 +57,27 @@ def jac_str_to_pass(
     return ast_ret
 
 
+def jac_ir_to_pass(
+    ir: ast.AstNode,
+    target: Optional[Type[Pass]] = None,
+    schedule: list[Type[Pass]] = pass_schedule,
+) -> Pass:
+    """Convert a Jac file to an AST."""
+    if not target:
+        target = schedule[-1] if schedule else None
+    ast_ret = (
+        Pass(input_ir=ir, prior=None)
+        if not len(schedule)
+        else schedule[0](input_ir=ir, prior=None)
+    )
+    for i in schedule[1:]:
+        if i == target:
+            break
+        ast_ret = i(input_ir=ast_ret.ir, prior=ast_ret)
+    ast_ret = target(input_ir=ast_ret.ir, prior=ast_ret) if target else ast_ret
+    return ast_ret
+
+
 def jac_pass_to_pass(
     in_pass: Pass,
     target: Optional[Type[Pass]] = None,

jaclang/compiler/parser.py

@@ -28,7 +28,7 @@ class JacParser(Pass):
             JacParser.make_dev()
         Pass.__init__(self, input_ir=input_ir, prior=None)
 
-    def transform(self, ir: ast.AstNode) -> ast.AstNode:
+    def transform(self, ir: ast.AstNode) -> ast.Module:
         """Transform input IR."""
         try:
             tree, comments = JacParser.parse(
@@ -36,6 +36,10 @@ class JacParser(Pass):
             )
             mod = JacParser.TreeToAST(parser=self).transform(tree)
             self.source.comments = [self.proc_comment(i, mod) for i in comments]
+            if isinstance(mod, ast.Module):
+                return mod
+            else:
+                raise self.ice()
         except jl.UnexpectedInput as e:
             catch_error = ast.EmptyToken()
             catch_error.file_path = self.mod_path
@@ -43,11 +47,16 @@ class JacParser(Pass):
             catch_error.c_start = e.column
             catch_error.c_end = e.column
             self.error(f"Syntax Error: {e}", node_override=catch_error)
-            mod = self.source
         except Exception as e:
-            mod = self.source
             self.error(f"Internal Error: {e}")
-        return mod
+        return ast.Module(
+            name="",
+            source=self.source,
+            doc=None,
+            body=[],
+            is_imported=False,
+            kid=[ast.EmptyToken()],
+        )
 
     @staticmethod
     def proc_comment(token: jl.Token, mod: ast.AstNode) -> ast.CommentToken:

jaclang/compiler/passes/main/__init__.py

@@ -3,7 +3,7 @@
 from .sub_node_tab_pass import SubNodeTabPass
 from .import_pass import JacImportPass, PyImportPass  # noqa: I100
 from .sym_tab_build_pass import SymTabBuildPass  # noqa: I100
-from .def_impl_match_pass import DeclDefMatchPass  # noqa: I100
+from .def_impl_match_pass import DeclImplMatchPass  # noqa: I100
 from .def_use_pass import DefUsePass  # noqa: I100
 from .pyout_pass import PyOutPass  # noqa: I100
 from .pyast_load_pass import PyastBuildPass  # type: ignore # noqa: I100
@@ -20,7 +20,7 @@ __all__ = [
     "JacImportPass",
     "PyImportPass",
     "SymTabBuildPass",
-    "DeclDefMatchPass",
+    "DeclImplMatchPass",
     "DefUsePass",
     "PyOutPass",
     "PyastBuildPass",

jaclang/compiler/passes/main/def_impl_match_pass.py

@@ -12,7 +12,7 @@ from jaclang.compiler.passes.main import SubNodeTabPass
 from jaclang.compiler.symtable import Symbol, SymbolTable, SymbolType
 
 
-class DeclDefMatchPass(Pass):
+class DeclImplMatchPass(Pass):
     """Decls and Def matching pass."""
 
     def enter_module(self, node: ast.Module) -> None:
@@ -76,10 +76,6 @@ class DeclDefMatchPass(Pass):
                     continue
                 decl_node.body = sym.decl  # type: ignore
                 sym.decl.decl_link = decl_node  # type: ignore
-                source_node = sym.decl.parent
-                decl_node.add_kids_right([sym.decl])  # type: ignore
-                if source_node and sym.decl in source_node.kid:
-                    source_node.kid.remove(sym.decl)
                 decl_node.sym_tab.tab = sym.decl.sym_tab.tab  # type: ignore
         for i in sym_tab.kid:
             self.connect_def_impl(i)

jaclang/compiler/passes/main/def_use_pass.py

@@ -28,13 +28,20 @@ class DefUsePass(SymTabPass):
         sym_tab: Optional[SymbolTable],
         """
         if node.arch_type.name == Tok.KW_WALKER:
-            for i in (
-                self.get_all_sub_nodes(node, ast.VisitStmt)
-                + self.get_all_sub_nodes(node, ast.IgnoreStmt)
-                + self.get_all_sub_nodes(node, ast.DisengageStmt)
-                + self.get_all_sub_nodes(node, ast.EdgeOpRef)
-            ):
-                i.from_walker = True
+            self.inform_from_walker(node)
+            for i in self.get_all_sub_nodes(node, ast.Ability):
+                if isinstance(i.body, ast.AbilityDef):
+                    self.inform_from_walker(i.body)
+
+    def inform_from_walker(self, node: ast.AstNode) -> None:
+        """Inform all sub nodes that they are from a walker."""
+        for i in (
+            self.get_all_sub_nodes(node, ast.VisitStmt)
+            + self.get_all_sub_nodes(node, ast.IgnoreStmt)
+            + self.get_all_sub_nodes(node, ast.DisengageStmt)
+            + self.get_all_sub_nodes(node, ast.EdgeOpRef)
+        ):
+            i.from_walker = True
 
     def enter_arch_ref(self, node: ast.ArchRef) -> None:
         """Sub objects.

jaclang/compiler/passes/main/import_pass.py

@@ -46,14 +46,20 @@ class JacImportPass(Pass):
         """Process an import."""
         lang = i.parent_of_type(ast.Import).hint.tag.value
         if lang == "jac" and not i.sub_module:
-            mod = self.import_jac_module(
+            self.import_jac_module(
                 node=i,
                 mod_path=node.loc.mod_path,
             )
-            if mod:
-                self.run_again = True
-                i.sub_module = mod
-                i.add_kids_right([mod], pos_update=False)
+
+    def attach_mod_to_node(
+        self, node: ast.ModulePath | ast.ModuleItem, mod: ast.Module | None
+    ) -> None:
+        """Attach a module to a node."""
+        if mod:
+            self.run_again = True
+            node.sub_module = mod
+            self.__annex_impl(mod)
+            node.add_kids_right([mod], pos_update=False)
 
     def __annex_impl(self, node: ast.Module) -> None:
         """Annex impl and test modules."""
@@ -114,15 +120,55 @@ class JacImportPass(Pass):
             node.sub_module.name = node.alias.value
         # Items matched during def/decl pass
 
-    def import_jac_module(
-        self, node: ast.ModulePath, mod_path: str
-    ) -> ast.Module | None:
+    def import_jac_module(self, node: ast.ModulePath, mod_path: str) -> None:
         """Import a module."""
         self.cur_node = node  # impacts error reporting
         target = import_target_to_relative_path(
-            node.level, node.path_str, os.path.dirname(node.loc.mod_path)
+            level=node.level,
+            target=node.path_str,
+            base_path=os.path.dirname(node.loc.mod_path),
         )
-        return self.import_jac_mod_from_file(target)
+        # 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))
+            import_node = node.parent_of_type(ast.Import)
+            # And the import is a from import and I am the from module
+            if node == import_node.from_loc:
+                # 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),
+                        )
+                        # If package
+                        if os.path.isdir(from_mod_target):
+                            self.attach_mod_to_node(
+                                i, self.import_jac_mod_from_dir(from_mod_target)
+                            )
+                        # Else module
+                        else:
+                            self.attach_mod_to_node(
+                                i, self.import_jac_mod_from_file(from_mod_target)
+                            )
+        else:
+            self.attach_mod_to_node(node, self.import_jac_mod_from_file(target))
+
+    def import_jac_mod_from_dir(self, target: str) -> ast.Module | None:
+        """Import a module from a directory."""
+        with_init = os.path.join(target, "__init__.jac")
+        if os.path.exists(with_init):
+            return self.import_jac_mod_from_file(with_init)
+        else:
+            return ast.Module(
+                name=target.split(os.path.sep)[-1],
+                source=ast.JacSource("", mod_path=target),
+                doc=None,
+                body=[],
+                is_imported=False,
+                kid=[ast.EmptyToken()],
+            )
 
     def import_jac_mod_from_file(self, target: str) -> ast.Module | None:
         """Import a module from a file."""

jaclang/compiler/passes/main/pyast_gen_pass.py

@@ -42,6 +42,7 @@ class PyastGenPass(Pass):
         """Initialize pass."""
         self.debuginfo: dict[str, list[str]] = {"jac_mods": []}
         self.already_added: list[str] = []
+        self.method_sigs: list[ast.FuncSignature | ast.EventSignature] = []
         self.preamble: list[ast3.AST] = [
             self.sync(
                 ast3.ImportFrom(
@@ -658,6 +659,28 @@ class PyastGenPass(Pass):
             )
         ]
 
+    def enter_architype(self, node: ast.Architype) -> None:
+        """Sub objects.
+
+        name: Name,
+        arch_type: Token,
+        access: Optional[SubTag[Token]],
+        base_classes: Optional[SubNodeList[AtomType]],
+        body: Optional[SubNodeList[ArchBlockStmt] | ArchDef],
+        doc: Optional[String],
+        decorators: Optional[SubNodeList[ExprType]],
+        """
+        # Record all signatures that are part of methods
+        for i in (
+            node.body.body.items
+            if isinstance(node.body, ast.ArchDef)
+            else node.body.items if node.body else []
+        ):
+            if isinstance(i, ast.Ability) and i.signature:
+                self.method_sigs.append(i.signature)
+        if isinstance(node.body, ast.ArchDef):
+            self.traverse(node.body)
+
     def exit_architype(self, node: ast.Architype) -> None:
         """Sub objects.
 
@@ -821,6 +844,19 @@ class PyastGenPass(Pass):
         decorators: Optional[SubNodeList[ExprType]],
         """
 
+    def enter_enum(self, node: ast.Enum) -> None:
+        """Sub objects.
+
+        name: Name,
+        access: Optional[SubTag[Token]],
+        base_classes: Optional[SubNodeList[AtomType]],
+        body: Optional[SubNodeList[EnumBlockStmt] | EnumDef],
+        doc: Optional[String],
+        decorators: Optional[SubNodeList[ExprType]],
+        """
+        if isinstance(node.body, ast.EnumDef):
+            self.traverse(node.body)
+
     def exit_enum(self, node: ast.Enum) -> None:
         """Sub objects.
 
@@ -870,6 +906,23 @@ class PyastGenPass(Pass):
         decorators: Optional[SubNodeList[ExprType]],
         """
 
+    def enter_ability(self, node: ast.Ability) -> None:
+        """Sub objects.
+
+        name_ref: NameType,
+        is_func: bool,
+        is_async: bool,
+        is_static: bool,
+        is_abstract: bool,
+        access: Optional[SubTag[Token]],
+        signature: Optional[FuncSignature | ExprType | EventSignature],
+        body: Optional[SubNodeList[CodeBlockStmt] | AbilityDef | FuncCall],
+        doc: Optional[String],
+        decorators: Optional[SubNodeList[ExprType]],
+        """
+        if isinstance(node.body, ast.AbilityDef):
+            self.traverse(node.body)
+
     def exit_ability(self, node: ast.Ability) -> None:
         """Sub objects.
 
@@ -1272,7 +1325,7 @@ class PyastGenPass(Pass):
         """
         params = (
             [self.sync(ast3.arg(arg="self", annotation=None))]
-            if node.is_method and not node.is_static
+            if node in self.method_sigs and not node.is_static
             else []
         )
         vararg = None
@@ -1330,7 +1383,7 @@ class PyastGenPass(Pass):
                     posonlyargs=[],
                     args=(
                         [self.sync(ast3.arg(arg="self", annotation=None)), here]
-                        if node.is_method
+                        if node in self.method_sigs
                         else [here]
                     ),
                     kwonlyargs=[],

jaclang/compiler/passes/main/schedules.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 from .sub_node_tab_pass import SubNodeTabPass  # noqa: I100
 from .import_pass import JacImportPass, PyImportPass  # noqa: I100
 from .sym_tab_build_pass import SymTabBuildPass  # noqa: I100
-from .def_impl_match_pass import DeclDefMatchPass  # noqa: I100
+from .def_impl_match_pass import DeclImplMatchPass  # noqa: I100
 from .def_use_pass import DefUsePass  # noqa: I100
 from .pyout_pass import PyOutPass  # noqa: I100
 from .pybc_gen_pass import PyBytecodeGenPass  # noqa: I100
@@ -25,7 +25,7 @@ py_code_gen = [
     JacImportPass,
     PyImportPass,
     SymTabBuildPass,
-    DeclDefMatchPass,
+    DeclImplMatchPass,
     DefUsePass,
     RegistryPass,
     PyastGenPass,
@@ -33,5 +33,6 @@ py_code_gen = [
     PyBytecodeGenPass,
 ]
 
-py_code_gen_typed = [*py_code_gen, JacTypeCheckPass, FuseTypeInfoPass, AccessCheckPass]
+type_checker_sched = [JacTypeCheckPass, FuseTypeInfoPass, AccessCheckPass]
+py_code_gen_typed = [*py_code_gen, *type_checker_sched]
 py_compiler = [*py_code_gen, PyOutPass]

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

@@ -0,0 +1,7 @@
+include:jac autoimpl;
+
+with entry {
+    foo();
+    bar();
+    baz();
+}

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

@@ -1,11 +1,11 @@
 """Test pass module."""
 
 from jaclang.compiler.compile import jac_file_to_pass
-from jaclang.compiler.passes.main import DeclDefMatchPass
+from jaclang.compiler.passes.main import DeclImplMatchPass
 from jaclang.utils.test import TestCase
 
 
-class DeclDefMatchPassTests(TestCase):
+class DeclImplMatchPassTests(TestCase):
     """Test pass module."""
 
     def setUp(self) -> None:
@@ -14,7 +14,7 @@ class DeclDefMatchPassTests(TestCase):
 
     def test_ability_connected_to_decl(self) -> None:
         """Basic test for pass."""
-        state = jac_file_to_pass(self.fixture_abs_path("base.jac"), DeclDefMatchPass)
+        state = jac_file_to_pass(self.fixture_abs_path("base.jac"), DeclImplMatchPass)
         self.assertFalse(state.errors_had)
         self.assertIn("(o)Test.(c)say_hi", state.ir.sym_tab.tab)
         self.assertIsNotNone(state.ir.sym_tab.tab["(o)Test.(c)say_hi"].decl.body)
@@ -23,7 +23,7 @@ class DeclDefMatchPassTests(TestCase):
 
     def test_ability_connected_to_decl_post(self) -> None:
         """Basic test for pass."""
-        state = jac_file_to_pass(self.fixture_abs_path("base2.jac"), DeclDefMatchPass)
+        state = jac_file_to_pass(self.fixture_abs_path("base2.jac"), DeclImplMatchPass)
         self.assertFalse(state.errors_had)
         self.assertIn("(o)Test.(c)say_hi", state.ir.sym_tab.tab)
         self.assertIsNotNone(state.ir.sym_tab.tab["(o)Test.(c)say_hi"].decl.body)

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

@@ -28,3 +28,16 @@ class ImportPassPassTests(TestCase):
         self.assertIn("getme.impl", mod_names)
         self.assertIn("autoimpl.impl", mod_names)
         self.assertIn("autoimpl.something.else.impl", mod_names)
+
+    def test_import_include_auto_impl(self) -> None:
+        """Basic test for pass."""
+        state = jac_file_to_pass(
+            self.fixture_abs_path("incautoimpl.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, 4)
+        self.assertIn("getme.impl", mod_names)
+        self.assertIn("autoimpl", mod_names)
+        self.assertIn("autoimpl.impl", mod_names)
+        self.assertIn("autoimpl.something.else.impl", mod_names)

jaclang/compiler/passes/tool/jac_formatter_pass.py

@@ -1161,7 +1161,7 @@ class JacFormatPass(Pass):
         if (
             node.parent
             and node.parent.parent
-            and isinstance(node.parent.parent, (ast.Ability))
+            and not isinstance(node.parent.parent, (ast.Ability, ast.ModuleCode))
             and node.parent.kid[1].gen.jac != "self.jaseci_sdk = {};\n"
         ):
             self.emit_ln(node, "")
@@ -1229,7 +1229,7 @@ class JacFormatPass(Pass):
 
         body: CodeBlock,
         """
-        self.emit(node, "finally")
+        self.emit(node, " finally")
 
         self.emit(node, node.body.gen.jac)
 

jaclang/compiler/passes/transform.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from typing import Generic, Optional
+from typing import Generic, Optional, Type
 
 from jaclang.compiler.absyntree import AstNode, T
 from jaclang.compiler.codeloc import CodeLocInfo
@@ -13,10 +13,11 @@ from jaclang.utils.log import logging
 class Alert:
     """Alert interface."""
 
-    def __init__(self, msg: str, loc: CodeLocInfo) -> None:
+    def __init__(self, msg: str, loc: CodeLocInfo, from_pass: Type[Transform]) -> None:
         """Initialize alert."""
         self.msg = msg
         self.loc: CodeLocInfo = loc
+        self.from_pass: Type[Transform] = from_pass
 
     def __str__(self) -> str:
         """Return string representation of alert."""
@@ -52,14 +53,22 @@ class Transform(ABC, Generic[T]):
 
     def log_error(self, msg: str, node_override: Optional[AstNode] = None) -> None:
         """Pass Error."""
-        alrt = Alert(msg, self.cur_node.loc if not node_override else node_override.loc)
+        alrt = Alert(
+            msg,
+            self.cur_node.loc if not node_override else node_override.loc,
+            self.__class__,
+        )
         self.errors_had.append(alrt)
         # print("Error:", str(alrt))
         self.logger.error(str(alrt))
 
     def log_warning(self, msg: str, node_override: Optional[AstNode] = None) -> None:
         """Pass Error."""
-        alrt = Alert(msg, self.cur_node.loc if not node_override else node_override.loc)
+        alrt = Alert(
+            msg,
+            self.cur_node.loc if not node_override else node_override.loc,
+            self.__class__,
+        )
         self.warnings_had.append(alrt)
         # print("Warning:", str(alrt))
         self.logger.warning(str(alrt))

jaclang/compiler/tests/fixtures/mod_doc_test.jac

@@ -1 +1,3 @@
-with entry { print("hello"); }
+with entry {
+    print("hello");
+}