jaclang 0.7.27__py3-none-any.whl → 0.7.30__py3-none-any.whl

jaclang/cli/cli.py

@@ -307,6 +307,7 @@ def enter(
 @cmd_registry.register
 def test(
     filepath: str,
+    test_name: str = "",
     filter: str = "",
     xit: bool = False,
     maxfail: int = None,  # type:ignore
@@ -316,6 +317,7 @@ def test(
     """Run the test suite in the specified .jac file.
 
     :param filepath: Path/to/file.jac
+    :param test_name: Run a specific test.
     :param filter: Filter the files using Unix shell style conventions.
     :param xit(exit): Stop(exit) running tests as soon as finds an error.
     :param maxfail: Stop running tests after n failures.
@@ -328,6 +330,7 @@ def test(
 
     failcount = Jac.run_test(
         filepath=filepath,
+        func_name=("test_" + test_name) if test_name else None,
         filter=filter,
         xit=xit,
         maxfail=maxfail,

jaclang/compiler/__init__.py

@@ -55,7 +55,7 @@ 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": "?",
+        "TYPE_OP": "`", "ABILITY_OP": ":can:", "NULL_OK": "?",
         "KW_OR": "|", "ARROW_BI": "<-->", "ARROW_L": "<--",
         "ARROW_R": "-->", "ARROW_L_P1": "<-:", "ARROW_R_P2": ":->",
         "ARROW_L_P2": ":-", "ARROW_R_P1": "-:", "CARROW_BI": "<++>",

jaclang/compiler/absyntree.py

@@ -30,6 +30,7 @@ from jaclang.compiler.constant import (
     SymbolType,
 )
 from jaclang.compiler.constant import DELIM_MAP, SymbolAccess, Tokens as Tok
+from jaclang.compiler.py_info import PyInfo
 from jaclang.compiler.semtable import SemRegistry
 from jaclang.utils.treeprinter import dotgen_ast_tree, print_ast_tree
 
@@ -636,11 +637,10 @@ class Module(AstDocNode):
         self.impl_mod: list[Module] = []
         self.test_mod: list[Module] = []
         self.mod_deps: dict[str, Module] = {}
-        self.py_mod_dep_map: dict[str, str] = {}
-        self.py_raise_map: dict[str, str] = {}
         self.registry = registry
         self.terminals: list[Token] = terminals
-        self.is_raised_from_py: bool = False
+        self.py_info: PyInfo = PyInfo()
+
         AstNode.__init__(self, kid=kid)
         AstDocNode.__init__(self, doc=doc)
 
@@ -693,6 +693,21 @@ class Module(AstDocNode):
         super().unparse()
         return self.format()
 
+    @staticmethod
+    def get_href_path(node: AstNode) -> str:
+        """Return the full path of the module that contains this node."""
+        parent = node.find_parent_of_type(Module)
+        mod_list: list[Module | Architype] = []
+        if isinstance(node, (Module, Architype)):
+            mod_list.append(node)
+        while parent is not None:
+            mod_list.append(parent)
+            parent = parent.find_parent_of_type(Module)
+        mod_list.reverse()
+        return ".".join(
+            p.name if isinstance(p, Module) else p.name.sym_name for p in mod_list
+        )
+
 
 class GlobalVars(ElementStmt, AstAccessNode):
     """GlobalVars node type for Jac Ast."""
@@ -998,8 +1013,9 @@ class ModulePath(AstSymbolNode):
         target = self.dot_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()
+        base_path = (
+            os.getenv("JACPATH") or os.path.dirname(self.loc.mod_path) or os.getcwd()
+        )
         parts = target.split(".")
         traversal_levels = self.level - 1 if self.level > 0 else 0
         actual_parts = parts[traversal_levels:]
@@ -1011,6 +1027,15 @@ class ModulePath(AstSymbolNode):
             if os.path.exists(relative_path + ".jac")
             else relative_path
         )
+        jacpath = os.getenv("JACPATH")
+        if not os.path.exists(relative_path) and jacpath:
+            name_to_find = actual_parts[-1] + ".jac"
+
+            # Walk through the single path in JACPATH
+            for root, _, files in os.walk(jacpath):
+                if name_to_find in files:
+                    relative_path = os.path.join(root, name_to_find)
+                    break
         return relative_path
 
     def normalize(self, deep: bool = False) -> bool:

jaclang/compiler/compile.py

@@ -31,7 +31,7 @@ def jac_file_to_pass(
     schedule: list[Type[Pass]] = pass_schedule,
 ) -> Pass:
     """Convert a Jac file to an AST."""
-    with open(file_path) as file:
+    with open(file_path, "r", encoding="utf-8") as file:
         return jac_str_to_pass(
             jac_str=file.read(),
             file_path=file_path,

jaclang/compiler/constant.py

@@ -315,7 +315,6 @@ class Tokens(str, Enum):
     ABILITY_OP = "ABILITY_OP"
     A_PIPE_FWD = "A_PIPE_FWD"
     A_PIPE_BKWD = "A_PIPE_BKWD"
-    ELVIS_OP = "ELVIS_OP"
     RETURN_HINT = "RETURN_HINT"
     NULL_OK = "NULL_OK"
     DECOR_OP = "DECOR_OP"

jaclang/compiler/jac.lark

@@ -298,10 +298,7 @@ lambda_expr: KW_WITH func_decl_params? (RETURN_HINT expression)? KW_CAN expressi
 pipe: (pipe PIPE_FWD)? pipe_back
 
 // Pipe back expressions
-pipe_back: (pipe_back PIPE_BKWD)? elvis_check
-
-// Elvis expressions
-elvis_check: (elvis_check ELVIS_OP)? bitwise_or
+pipe_back: (pipe_back PIPE_BKWD)? bitwise_or
 
 // Bitwise expressions
 bitwise_or: (bitwise_or BW_OR)? bitwise_xor
@@ -599,7 +596,6 @@ PIPE_BKWD: /<\|/
 DOT_FWD: /\.>/
 DOT_BKWD: /<\./
 RETURN_HINT: /->/
-ELVIS_OP: /\?:/
 NULL_OK: /\?/
 MATMUL_EQ: /@=/
 DECOR_OP: /@/

jaclang/compiler/parser.py

@@ -2037,16 +2037,8 @@ class JacParser(Pass):
         def pipe_back(self, kid: list[ast.AstNode]) -> ast.Expr:
             """Grammar rule.
 
-            pipe_back: elvis_check PIPE_BKWD pipe_back
-                     | elvis_check
-            """
-            return self.binary_expr_unwind(kid)
-
-        def elvis_check(self, kid: list[ast.AstNode]) -> ast.Expr:
-            """Grammar rule.
-
-            elvis_check: bitwise_or ELVIS_OP elvis_check
-                       | bitwise_or
+            pipe_back: bitwise_or PIPE_BKWD pipe_back
+                     | bitwise_or
             """
             return self.binary_expr_unwind(kid)
 

jaclang/compiler/passes/main/__init__.py

@@ -2,9 +2,9 @@
 
 from .sub_node_tab_pass import SubNodeTabPass
 from .sym_tab_build_pass import SymTabBuildPass  # noqa: I100
+from .def_use_pass import DefUsePass  # noqa: I100
 from .import_pass import JacImportPass, PyImportPass  # 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
 from .pyast_gen_pass import PyastGenPass  # noqa: I100

jaclang/compiler/passes/main/access_modifier_pass.py

@@ -45,7 +45,7 @@ class AccessCheckPass(Pass):
             settings.lsp_debug
             and isinstance(node, ast.NameAtom)
             and not node.sym
-            and not node.parent_of_type(ast.Module).is_raised_from_py
+            and not node.parent_of_type(ast.Module).py_info.is_raised_from_py
             and not (
                 node.sym_name == "py"
                 and node.parent

jaclang/compiler/passes/main/fuse_typeinfo_pass.py

@@ -10,6 +10,7 @@ import re
 from typing import Callable, Optional, TypeVar
 
 import jaclang.compiler.absyntree as ast
+from jaclang.compiler.constant import Constants, Tokens
 from jaclang.compiler.passes import Pass
 from jaclang.compiler.symtable import SymbolTable
 from jaclang.settings import settings
@@ -76,35 +77,6 @@ class FuseTypeInfoPass(Pass):
         if typ_sym_table != self.ir.sym_tab:
             node.name_spec.type_sym_tab = typ_sym_table
 
-    def __collect_python_dependencies(self, node: ast.AstNode) -> None:
-        assert isinstance(node, ast.AstSymbolNode)
-        assert isinstance(self.ir, ast.Module)
-
-        mypy_node = node.gen.mypy_ast[0]
-
-        if isinstance(mypy_node, MypyNodes.RefExpr) and mypy_node.node:
-            node_full_name = mypy_node.node.fullname
-            if "." in node_full_name:
-                mod_name = node_full_name[: node_full_name.rindex(".")]
-            else:
-                mod_name = node_full_name
-
-            if mod_name not in self.ir.py_mod_dep_map:
-                self.__debug_print(
-                    f"Can't find a python file associated with {type(node)}::{node.loc}"
-                )
-                return
-
-            mode_path = self.ir.py_mod_dep_map[mod_name]
-            if mode_path.endswith(".jac"):
-                return
-
-            self.ir.py_raise_map[mod_name] = mode_path
-        else:
-            self.__debug_print(
-                f"Collect python dependencies is not supported in {type(node)}::{node.loc}"
-            )
-
     @staticmethod
     def __handle_node(
         func: Callable[[FuseTypeInfoPass, T], None]
@@ -126,7 +98,6 @@ class FuseTypeInfoPass(Pass):
                 if len(node.gen.mypy_ast) == 1:
                     func(self, node)
                     self.__set_type_sym_table_link(node)
-                    self.__collect_python_dependencies(node)
 
                 # Jac node has multiple mypy nodes linked to it
                 elif len(node.gen.mypy_ast) > 1:
@@ -150,7 +121,6 @@ class FuseTypeInfoPass(Pass):
                         )
                         func(self, node)
                         self.__set_type_sym_table_link(node)
-                        self.__collect_python_dependencies(node)
 
                 # Special handing for BuiltinType
                 elif isinstance(node, ast.BuiltinType):
@@ -266,6 +236,43 @@ class FuseTypeInfoPass(Pass):
         if len(node.gen.mypy_ast) == 0:
             return
 
+        # No need to run this handling in case of a previous type
+        # was set during the pass, if not then we hope that the
+        # mypy node has a type associated to it
+        if node.expr_type != "NoType":
+            return
+
+        # Check if the expression is a data spatial expression
+        # Support disconnectOp
+        if isinstance(node, ast.BinaryExpr):
+            if isinstance(node.op, ast.DisconnectOp):
+                node.expr_type = "builtins.bool"
+                return
+
+            # Support spwan and connectOp
+            elif (
+                isinstance(node.op, ast.ConnectOp)
+                or node.op.name == Tokens.KW_SPAWN.value
+            ):
+                if node.gen.mypy_ast[-1] in self.node_type_hash:
+                    node.expr_type = (
+                        self.__call_type_handler(
+                            self.node_type_hash[node.gen.mypy_ast[-1]]
+                        )
+                        or node.expr_type
+                    )
+                return
+
+        if isinstance(node, ast.EdgeRefTrailer) and any(
+            isinstance(k, ast.FilterCompr) for k in node.kid
+        ):
+            if node.gen.mypy_ast[-1] in self.node_type_hash:
+                node.expr_type = (
+                    self.__call_type_handler(self.node_type_hash[node.gen.mypy_ast[-1]])
+                    or node.expr_type
+                )
+            return
+
         # If the corrosponding mypy ast node type has stored here, get the values.
         mypy_node = node.gen.mypy_ast[0]
         if mypy_node in self.node_type_hash:
@@ -427,7 +434,14 @@ class FuseTypeInfoPass(Pass):
     @__handle_node
     def enter_special_var_ref(self, node: ast.SpecialVarRef) -> None:
         """Pass handler for SpecialVarRef nodes."""
-        return self.enter_name(node)
+        if node.py_resolve_name() == Constants.ROOT:
+            if node.gen.mypy_ast[-1] in self.node_type_hash:
+                node.name_spec.expr_type = (
+                    self.__call_type_handler(self.node_type_hash[node.gen.mypy_ast[-1]])
+                    or node.name_spec.expr_type
+                )
+        else:
+            self.enter_name(node)
 
     @__handle_node
     def enter_edge_op_ref(self, node: ast.EdgeOpRef) -> None:
@@ -491,7 +505,7 @@ class FuseTypeInfoPass(Pass):
         self, mypy_type: MypyTypes.Overloaded
     ) -> Optional[str]:
         """Get type info from mypy type Overloaded."""
-        return self.__call_type_handler(mypy_type.items[0])
+        return self.__call_type_handler(mypy_type.items[-1])
 
     def get_type_from_none_type(self, mypy_type: MypyTypes.NoneType) -> Optional[str]:
         """Get type info from mypy type NoneType."""
@@ -509,6 +523,12 @@ class FuseTypeInfoPass(Pass):
         """Get type info from mypy type TypeType."""
         return str(mypy_type.item)
 
+    def get_type_from_type_var_type(
+        self, mypy_type: MypyTypes.TypeVarType
+    ) -> Optional[str]:
+        """Get type info from mypy type TypeType."""
+        return str(mypy_type.name)
+
     def exit_assignment(self, node: ast.Assignment) -> None:
         """Add new symbols in the symbol table in case of self."""
         # This will fix adding new items to the class through self
@@ -590,6 +610,7 @@ class FuseTypeInfoPass(Pass):
                     # right index slice is a range then it's type is the same as left
                     if right.is_range:
                         right.expr_type = left.expr_type
+                        right.parent_of_type(ast.AtomTrailer).expr_type = node_type
                         continue
 
                 # left type is a dictionary
@@ -603,6 +624,7 @@ class FuseTypeInfoPass(Pass):
                     continue
 
                 right.expr_type = node_type
+                right.parent_of_type(ast.AtomTrailer).expr_type = node_type
 
                 # Getting the correct symbol table and link it
                 type_symtab: Optional[SymbolTable] = self.ir.sym_tab
@@ -621,6 +643,13 @@ class FuseTypeInfoPass(Pass):
                 right.type_sym_tab = type_symtab
 
             else:
+                # Fix the symbolTable linking in case of type annotations
+                if left.type_sym_tab is None and isinstance(node.parent, ast.SubTag):
+                    assert isinstance(left, ast.AstSymbolNode)
+                    left.name_spec.type_sym_tab = self.ir.sym_tab.find_scope(
+                        left.sym_name
+                    )
+
                 if left.type_sym_tab:
                     right.name_spec.sym = left.type_sym_tab.lookup(right.sym_name)
                     if right.name_spec.sym: