jaclang 0.7.15__tar.gz → 0.7.16__tar.gz

{jaclang-0.7.15 → jaclang-0.7.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jaclang
-Version: 0.7.15
+Version: 0.7.16
 Summary: Jac is a unique and powerful programming language that runs on top of Python, offering an unprecedented level of intelligence and intuitive understanding.
 Home-page: https://jaseci.org
 License: MIT
@@ -28,7 +28,7 @@ Description-Content-Type: text/markdown
 
 [Jac Website] | [Getting started] | [Learn] | [Documentation] | [Contributing]
 
-  [![PyPI version](https://img.shields.io/pypi/v/jaclang.svg)](https://pypi.org/project/jaclang/) [![Tests](https://github.com/chandralegend/jaclang/actions/workflows/run_pytest.yml/badge.svg?branch=main)](https://github.com/chandralegend/jaclang/actions/workflows/run_pytest.yml) [![codecov](https://codecov.io/github/chandralegend/jaclang/graph/badge.svg?token=OAX26B0FE4)](https://codecov.io/github/chandralegend/jaclang)
+  [![PyPI version](https://img.shields.io/pypi/v/jaclang.svg)](https://pypi.org/project/jaclang/) [![Tests](https://github.com/Jaseci-Labs/jaclang/actions/workflows/run_pytest.yml/badge.svg)](https://github.com/Jaseci-Labs/jaclang/actions/workflows/run_pytest.yml) [![codecov](https://codecov.io/github/chandralegend/jaclang/graph/badge.svg?token=OAX26B0FE4)](https://codecov.io/github/chandralegend/jaclang)
 </div>
 
 This is the main source code repository for the [Jac] programming language. It contains the compiler, language server, and documentation.
@@ -97,3 +97,4 @@ Third-party logos may be subject to third-party copyrights and trademarks. See [
 [jaseci]: https://jaseci.org/
 [media-guide]: https://jaseci.org/policies/logo-policy-and-media-guide/
 [policies-licenses]: https://www.jaseci.org/policies/licenses
+

{jaclang-0.7.15 → jaclang-0.7.16}/README.md

@@ -9,7 +9,7 @@
 
 [Jac Website] | [Getting started] | [Learn] | [Documentation] | [Contributing]
 
-  [![PyPI version](https://img.shields.io/pypi/v/jaclang.svg)](https://pypi.org/project/jaclang/) [![Tests](https://github.com/chandralegend/jaclang/actions/workflows/run_pytest.yml/badge.svg?branch=main)](https://github.com/chandralegend/jaclang/actions/workflows/run_pytest.yml) [![codecov](https://codecov.io/github/chandralegend/jaclang/graph/badge.svg?token=OAX26B0FE4)](https://codecov.io/github/chandralegend/jaclang)
+  [![PyPI version](https://img.shields.io/pypi/v/jaclang.svg)](https://pypi.org/project/jaclang/) [![Tests](https://github.com/Jaseci-Labs/jaclang/actions/workflows/run_pytest.yml/badge.svg)](https://github.com/Jaseci-Labs/jaclang/actions/workflows/run_pytest.yml) [![codecov](https://codecov.io/github/chandralegend/jaclang/graph/badge.svg?token=OAX26B0FE4)](https://codecov.io/github/chandralegend/jaclang)
 </div>
 
 This is the main source code repository for the [Jac] programming language. It contains the compiler, language server, and documentation.
@@ -77,4 +77,4 @@ Third-party logos may be subject to third-party copyrights and trademarks. See [
 
 [jaseci]: https://jaseci.org/
 [media-guide]: https://jaseci.org/policies/logo-policy-and-media-guide/
-[policies-licenses]: https://www.jaseci.org/policies/licenses
+[policies-licenses]: https://www.jaseci.org/policies/licenses

{jaclang-0.7.15 → jaclang-0.7.16}/jaclang/cli/cli.py

@@ -23,6 +23,7 @@ from jaclang.plugin.builtin import dotgen
 from jaclang.plugin.feature import JacCmd as Cmd
 from jaclang.plugin.feature import JacFeature as Jac
 from jaclang.runtimelib.constructs import Architype
+from jaclang.runtimelib.machine import JacProgram
 from jaclang.utils.helpers import debugger as db
 from jaclang.utils.lang_tools import AstTool
 
@@ -104,12 +105,13 @@ def run(
     elif filename.endswith(".jir"):
         with open(filename, "rb") as f:
             ir = pickle.load(f)
+            jac_program = JacProgram(mod_bundle=ir, bytecode=None)
+            Jac.context().jac_machine.attach_program(jac_program)
             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
@@ -220,7 +222,7 @@ def enter(filename: str, entrypoint: str, args: list) -> None:
         base, mod_name = os.path.split(filename)
         base = base if base else "./"
         mod_name = mod_name[:-4]
-        mod = jac_import(target=mod_name, base_path=base)
+        (mod,) = jac_import(target=mod_name, base_path=base)
         if not mod:
             print("Errors occurred while importing the module.")
             return

{jaclang-0.7.15 → jaclang-0.7.16}/jaclang/compiler/__init__.py

@@ -34,6 +34,7 @@ def generate_static_parser(force: bool = False) -> None:
         except Exception as e:
             logging.error(f"Error generating reference files: {e}")
 
+
 try:
     from jaclang.compiler.generated import jac_parser as jac_lark
 except ModuleNotFoundError:
@@ -48,62 +49,29 @@ TOKEN_MAP = {
     for x in jac_lark.Lark_StandAlone().parser.lexer_conf.terminals
 }
 
+# fmt: off
 TOKEN_MAP.update(
     {
-        "CARROW_L": "<++",
-        "CARROW_R": "++>",
-        "GLOBAL_OP": ":global:",
-        "NONLOCAL_OP": ":nonlocal:",
-        "WALKER_OP": ":walker:",
-        "NODE_OP": ":node:",
-        "EDGE_OP": ":edge:",
-        "CLASS_OP": ":class:",
-        "OBJECT_OP": ":obj:",
-        "TYPE_OP": "`",
-        "ABILITY_OP": ":can:",
-        "ELVIS_OP": "?:",
-        "NULL_OK": "?",
-        "KW_OR": "|",
-        "ARROW_BI": "<-->",
-        "ARROW_L": "<--",
-        "ARROW_R": "-->",
-        "ARROW_L_P1": "<-:",
-        "ARROW_R_P2": ":->",
-        "ARROW_L_P2": ":-",
-        "ARROW_R_P1": "-:",
-        "CARROW_BI": "<++>",
-        "CARROW_L": "<++",
-        "CARROW_R": "++>",
-        "CARROW_L_P1": "<+:",
-        "CARROW_R_P2": ":+>",
-        "CARROW_L_P2": ":+",
-        "CARROW_R_P1": "+:",
-        "PIPE_FWD": "|>",
-        "PIPE_BKWD": "<|",
-        "A_PIPE_FWD": ":>",
-        "A_PIPE_BKWD": "<:",
-        "DOT_FWD": ".>",
-        "STAR_POW": "**",
-        "STAR_MUL": "*",
-        "FLOOR_DIV": "//",
-        "DIV": "/",
-        "PYNLINE": "::py::",
-        "ADD_EQ": "+=",
-        "SUB_EQ": "-=",
-        "STAR_POW_EQ": "**=",
-        "MUL_EQ": "*=",
-        "FLOOR_DIV_EQ": "//=",
-        "DIV_EQ": "/=",
-        "MOD_EQ": "%=",
-        "BW_AND_EQ": "&=",
-        "BW_OR_EQ": "|=",
-        "BW_XOR_EQ": "^=",
-        "BW_NOT_EQ": "~=",
-        "LSHIFT_EQ": "<<=",
-        "RSHIFT_EQ": ">>=",
-        "ELLIPSIS": "...",
+        "CARROW_L": "<++", "CARROW_R": "++>", "GLOBAL_OP": ":global:",
+        "NONLOCAL_OP": ":nonlocal:", "WALKER_OP": ":walker:", "NODE_OP": ":node:",
+        "EDGE_OP": ":edge:", "CLASS_OP": ":class:", "OBJECT_OP": ":obj:",
+        "TYPE_OP": "`", "ABILITY_OP": ":can:", "ELVIS_OP": "?:", "NULL_OK": "?",
+        "KW_OR": "|", "ARROW_BI": "<-->", "ARROW_L": "<--",
+        "ARROW_R": "-->", "ARROW_L_P1": "<-:", "ARROW_R_P2": ":->",
+        "ARROW_L_P2": ":-", "ARROW_R_P1": "-:", "CARROW_BI": "<++>",
+        "CARROW_L": "<++", "CARROW_R": "++>", "CARROW_L_P1": "<+:",
+        "CARROW_R_P2": ":+>", "CARROW_L_P2": ":+", "CARROW_R_P1": "+:",
+        "PIPE_FWD": "|>", "PIPE_BKWD": "<|", "A_PIPE_FWD": ":>",
+        "A_PIPE_BKWD": "<:", "DOT_FWD": ".>", "STAR_POW": "**",
+        "STAR_MUL": "*", "FLOOR_DIV": "//", "DIV": "/",
+        "PYNLINE": "::py::", "ADD_EQ": "+=", "SUB_EQ": "-=",
+        "STAR_POW_EQ": "**=", "MUL_EQ": "*=", "FLOOR_DIV_EQ": "//=",
+        "DIV_EQ": "/=", "MOD_EQ": "%=", "BW_AND_EQ": "&=",
+        "BW_OR_EQ": "|=", "BW_XOR_EQ": "^=", "BW_NOT_EQ": "~=",
+        "LSHIFT_EQ": "<<=", "RSHIFT_EQ": ">>=", "ELLIPSIS": "...",
     }
 )
+# fmt: on
 
 
 __all__ = ["jac_lark", "TOKEN_MAP"]

{jaclang-0.7.15 → jaclang-0.7.16}/jaclang/compiler/absyntree.py

@@ -158,7 +158,7 @@ class AstNode:
         """Get parent of type."""
         from jaclang.compiler.passes import Pass
 
-        return Pass.has_parent_of_type(node=self, typ=typ)
+        return Pass.find_parent_of_type(node=self, typ=typ)
 
     def parent_of_type(self, typ: Type[T]) -> T:
         """Get parent of type."""
@@ -858,7 +858,7 @@ class Import(ElementStmt, CodeBlockStmt):
 
     def __init__(
         self,
-        hint: SubTag[Name],
+        hint: Optional[SubTag[Name]],
         from_loc: Optional[ModulePath],
         items: SubNodeList[ModuleItem] | SubNodeList[ModulePath],
         is_absorb: bool,  # For includes
@@ -873,11 +873,52 @@ class Import(ElementStmt, CodeBlockStmt):
         AstNode.__init__(self, kid=kid)
         AstDocNode.__init__(self, doc=doc)
 
+    @property
+    def is_py(self) -> bool:
+        """Check if import is python."""
+        if self.hint and self.hint.tag.value == "py":
+            return True
+        if not self.hint:
+            return not self.__jac_detected
+        return False
+
+    @property
+    def is_jac(self) -> bool:
+        """Check if import is jac."""
+        if self.hint and self.hint.tag.value == "jac":
+            return True
+        if not self.hint:
+            return self.__jac_detected
+        return False
+
+    @property
+    def __jac_detected(self) -> bool:
+        """Check if import is jac."""
+        if self.from_loc:
+            if self.from_loc.resolve_relative_path().endswith(".jac"):
+                return True
+            if os.path.isdir(self.from_loc.resolve_relative_path()):
+                if os.path.exists(
+                    os.path.join(self.from_loc.resolve_relative_path(), "__init__.jac")
+                ):
+                    return True
+                for i in self.items.items:
+                    if isinstance(
+                        i, ModuleItem
+                    ) and self.from_loc.resolve_relative_path(i.name.value).endswith(
+                        ".jac"
+                    ):
+                        return True
+        return any(
+            isinstance(i, ModulePath) and i.resolve_relative_path().endswith(".jac")
+            for i in self.items.items
+        )
+
     def normalize(self, deep: bool = False) -> bool:
         """Normalize import node."""
         res = True
         if deep:
-            res = self.hint.normalize(deep)
+            res = self.hint.normalize(deep) if self.hint else res
             res = res and self.from_loc.normalize(deep) if self.from_loc else res
             res = res and self.items.normalize(deep)
             res = res and self.doc.normalize(deep) if self.doc else res
@@ -888,7 +929,8 @@ class Import(ElementStmt, CodeBlockStmt):
             new_kid.append(self.gen_token(Tok.KW_INCLUDE))
         else:
             new_kid.append(self.gen_token(Tok.KW_IMPORT))
-        new_kid.append(self.hint)
+        if self.hint:
+            new_kid.append(self.hint)
         if self.from_loc:
             new_kid.append(self.gen_token(Tok.KW_FROM))
             new_kid.append(self.from_loc)
@@ -941,6 +983,26 @@ class ModulePath(AstSymbolNode):
             [p.value for p in self.path] if self.path else [self.name_spec.sym_name]
         )
 
+    def resolve_relative_path(self, target_item: Optional[str] = None) -> str:
+        """Convert an import target string into a relative file path."""
+        target = self.path_str
+        if target_item:
+            target += f".{target_item}"
+        base_path = os.path.dirname(self.loc.mod_path)
+        base_path = base_path if base_path else os.getcwd()
+        parts = target.split(".")
+        traversal_levels = self.level - 1 if self.level > 0 else 0
+        actual_parts = parts[traversal_levels:]
+        for _ in range(traversal_levels):
+            base_path = os.path.dirname(base_path)
+        relative_path = os.path.join(base_path, *actual_parts)
+        relative_path = (
+            relative_path + ".jac"
+            if os.path.exists(relative_path + ".jac")
+            else relative_path
+        )
+        return relative_path
+
     def normalize(self, deep: bool = False) -> bool:
         """Normalize module path node."""
         res = True
@@ -1127,7 +1189,6 @@ class ArchDef(AstImplOnlyNode):
         body: SubNodeList[ArchBlockStmt],
         kid: Sequence[AstNode],
         doc: Optional[String] = None,
-        decorators: Optional[SubNodeList[Expr]] = None,
         decl_link: Optional[Architype] = None,
     ) -> None:
         """Initialize arch def node."""
@@ -1468,6 +1529,23 @@ class FuncSignature(AstSemStrNode):
             and self.parent.decl_link.is_static
         )
 
+    @property
+    def is_in_py_class(self) -> bool:
+        """Check if the ability belongs to a class."""
+        is_archi = self.find_parent_of_type(Architype)
+        is_class = is_archi is not None and is_archi.arch_type.name == Tok.KW_CLASS
+
+        return (
+            isinstance(self.parent, Ability)
+            and self.parent.is_method is not None
+            and is_class
+        ) or (
+            isinstance(self.parent, AbilityDef)
+            and isinstance(self.parent.decl_link, Ability)
+            and self.parent.decl_link.is_method
+            and is_class
+        )
+
 
 class EventSignature(AstSemStrNode):
     """EventSignature node type for Jac Ast."""

{jaclang-0.7.15 → jaclang-0.7.16}/jaclang/compiler/jac.lark

@@ -16,8 +16,9 @@ element: import_stmt
        | test
 
 // Import/Include Statements
-import_stmt: KW_IMPORT sub_name KW_FROM from_path COMMA import_items SEMI
-           | KW_IMPORT sub_name import_path (COMMA import_path)* SEMI
+import_stmt: KW_IMPORT sub_name? KW_FROM from_path LBRACE import_items RBRACE
+           | KW_IMPORT sub_name? KW_FROM from_path COMMA import_items SEMI  //Deprecated
+           | KW_IMPORT sub_name? import_path (COMMA import_path)* SEMI
            | include_stmt
 
 from_path: (DOT | ELLIPSIS)* import_path
@@ -27,7 +28,7 @@ import_path: named_ref (DOT named_ref)* (KW_AS NAME)?
 import_items: (import_item COMMA)* import_item
 import_item: named_ref (KW_AS NAME)?
 sub_name: COLON NAME
-include_stmt: KW_INCLUDE sub_name import_path SEMI
+include_stmt: KW_INCLUDE sub_name? import_path SEMI
 
 // Architypes
 architype: decorators? architype_decl

{jaclang-0.7.15 → jaclang-0.7.16}/jaclang/compiler/parser.py

@@ -298,26 +298,29 @@ class JacParser(Pass):
         def import_stmt(self, kid: list[ast.AstNode]) -> ast.Import:
             """Grammar rule.
 
-            import_stmt: KW_IMPORT sub_name KW_FROM from_path COMMA import_items SEMI
-                    | KW_IMPORT sub_name import_path (COMMA import_path)* SEMI
+            import_stmt: KW_IMPORT sub_name? KW_FROM from_path LBRACE import_items RBRACE
+                    | KW_IMPORT sub_name? KW_FROM from_path COMMA import_items SEMI  //Deprecated
+                    | KW_IMPORT sub_name? import_path (COMMA import_path)* SEMI
                     | include_stmt
             """
             if len(kid) == 1 and isinstance(kid[0], ast.Import):
                 return self.nu(kid[0])
-            lang = kid[1]
-            from_path = kid[3] if isinstance(kid[3], ast.ModulePath) else None
+            chomp = [*kid]
+            lang = kid[1] if isinstance(kid[1], ast.SubTag) else None
+            chomp = chomp[2:] if lang else chomp[1:]
+            from_path = chomp[1] if isinstance(chomp[1], ast.ModulePath) else None
             if from_path:
                 items = kid[-2] if isinstance(kid[-2], ast.SubNodeList) else None
             else:
                 paths = [i for i in kid if isinstance(i, ast.ModulePath)]
                 items = ast.SubNodeList[ast.ModulePath](
-                    items=paths, delim=Tok.COMMA, kid=kid[2:-1]
+                    items=paths, delim=Tok.COMMA, kid=kid[2 if lang else 1 : -1]
                 )
-                kid = kid[:2] + [items] + kid[-1:]
+                kid = (kid[:2] if lang else kid[:1]) + [items] + kid[-1:]
 
             is_absorb = False
-            if isinstance(lang, ast.SubTag) and (isinstance(items, ast.SubNodeList)):
-                return self.nu(
+            if isinstance(items, ast.SubNodeList):
+                ret = self.nu(
                     ast.Import(
                         hint=lang,
                         from_loc=from_path,
@@ -326,7 +329,15 @@ class JacParser(Pass):
                         kid=kid,
                     )
                 )
-
+                if (
+                    from_path
+                    and isinstance(kid[-1], ast.Token)
+                    and kid[-1].name == Tok.SEMI
+                ):
+                    self.parse_ref.warning(
+                        "Deprecated syntax, use braces for multiple imports (e.g, import from mymod {a, b, c})",
+                    )
+                return ret
             else:
                 raise self.ice()
 
@@ -364,27 +375,24 @@ class JacParser(Pass):
 
             include_stmt: KW_INCLUDE sub_name import_path SEMI
             """
-            lang = kid[1]
-            from_path = kid[2]
+            lang = kid[1] if isinstance(kid[1], ast.SubTag) else None
+            from_path = kid[2] if lang else kid[1]
             if not isinstance(from_path, ast.ModulePath):
                 raise self.ice()
             items = ast.SubNodeList[ast.ModulePath](
                 items=[from_path], delim=Tok.COMMA, kid=[from_path]
             )
-            kid = kid[:2] + [items] + kid[3:]
+            kid = (kid[:2] if lang else kid[:1]) + [items] + kid[-1:]
             is_absorb = True
-            if isinstance(lang, ast.SubTag):
-                return self.nu(
-                    ast.Import(
-                        hint=lang,
-                        from_loc=None,
-                        items=items,
-                        is_absorb=is_absorb,
-                        kid=kid,
-                    )
+            return self.nu(
+                ast.Import(
+                    hint=lang,
+                    from_loc=None,
+                    items=items,
+                    is_absorb=is_absorb,
+                    kid=kid,
                 )
-            else:
-                raise self.ice()
+            )
 
         def import_path(self, kid: list[ast.AstNode]) -> ast.ModulePath:
             """Grammar rule.

{jaclang-0.7.15 → jaclang-0.7.16}/jaclang/compiler/passes/ir_pass.py

@@ -74,7 +74,7 @@ class Pass(Transform[T]):
         return result
 
     @staticmethod
-    def has_parent_of_type(node: ast.AstNode, typ: Type[T]) -> Optional[T]:
+    def find_parent_of_type(node: ast.AstNode, typ: Type[T]) -> Optional[T]:
         """Check if node has parent of type."""
         while node.parent:
             if isinstance(node.parent, typ):

{jaclang-0.7.15 → jaclang-0.7.16}/jaclang/compiler/passes/main/access_modifier_pass.py

@@ -175,7 +175,7 @@ class AccessCheckPass(Pass):
         if isinstance(node.parent, ast.FuncCall):
             self.access_check(node)
 
-        if node.sym and Pass.has_parent_of_type(
+        if node.sym and Pass.find_parent_of_type(
             node=node.sym.defn[-1], typ=ast.GlobalVars
         ):
             self.access_check(node)

{jaclang-0.7.15 → jaclang-0.7.16}/jaclang/compiler/passes/main/import_pass.py

@@ -16,7 +16,7 @@ import jaclang.compiler.absyntree as ast
 from jaclang.compiler.passes import Pass
 from jaclang.compiler.passes.main import SubNodeTabPass
 from jaclang.settings import settings
-from jaclang.utils.helpers import import_target_to_relative_path, is_standard_lib_module
+from jaclang.utils.helpers import is_standard_lib_module
 from jaclang.utils.log import logging
 
 logger = logging.getLogger(__name__)
@@ -54,13 +54,10 @@ class JacImportPass(Pass):
 
     def process_import(self, node: ast.Module, i: ast.ModulePath) -> None:
         """Process an import."""
-        lang = i.parent_of_type(ast.Import).hint.tag.value
-        if lang == "jac" and not i.sub_module:
-            self.import_jac_module(
-                node=i,
-                mod_path=node.loc.mod_path,
-            )
-        elif lang == "py":
+        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(
@@ -139,14 +136,10 @@ class JacImportPass(Pass):
         if node.as_attr_list[0].sym_name in self.__py_imports:
             self.py_resolve_list.add(".".join([i.sym_name for i in node.as_attr_list]))
 
-    def import_jac_module(self, node: ast.ModulePath, mod_path: str) -> None:
+    def import_jac_module(self, node: ast.ModulePath) -> None:
         """Import a module."""
         self.cur_node = node  # impacts error reporting
-        target = import_target_to_relative_path(
-            level=node.level,
-            target=node.path_str,
-            base_path=os.path.dirname(node.loc.mod_path),
-        )
+        target = node.resolve_relative_path()
         # If the module is a package (dir)
         if os.path.isdir(target):
             self.attach_mod_to_node(node, self.import_jac_mod_from_dir(target))
@@ -156,11 +149,7 @@ class JacImportPass(Pass):
                 # Import all from items as modules or packages
                 for i in import_node.items.items:
                     if isinstance(i, ast.ModuleItem):
-                        from_mod_target = import_target_to_relative_path(
-                            level=node.level,
-                            target=node.path_str + "." + i.name.value,
-                            base_path=os.path.dirname(node.loc.mod_path),
-                        )
+                        from_mod_target = node.resolve_relative_path(i.name.value)
                         # If package
                         if os.path.isdir(from_mod_target):
                             self.attach_mod_to_node(
@@ -230,8 +219,12 @@ class PyImportPass(JacImportPass):
 
     def process_import(self, node: ast.Module, i: ast.ModulePath) -> None:
         """Process an import."""
-        lang = i.parent_of_type(ast.Import).hint.tag.value
-        if lang == "py" and not i.sub_module and not is_standard_lib_module(i.path_str):
+        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