jaclang 0.5.17__py3-none-any.whl → 0.6.0__py3-none-any.whl

jaclang/compiler/jac.lark

@@ -195,8 +195,8 @@ list_inner_pattern: (pattern_seq | STAR_MUL NAME)
 dict_inner_pattern: (literal_pattern COLON pattern_seq | STAR_POW NAME)
 
 // Match class patterns
-class_pattern: NAME LPAREN kw_pattern_list? RPAREN
-             | NAME LPAREN pattern_list (COMMA kw_pattern_list)? RPAREN
+class_pattern: NAME (DOT NAME)* LPAREN kw_pattern_list? RPAREN
+             | NAME (DOT NAME)* LPAREN pattern_list (COMMA kw_pattern_list)? RPAREN
 
 pattern_list: (pattern_list COMMA)? pattern_seq
 kw_pattern_list: (kw_pattern_list COMMA)? named_ref EQ pattern_seq
@@ -317,9 +317,9 @@ cmp_op: KW_ISN
 
 // Arithmetic expressions
 arithmetic: (arithmetic (MINUS | PLUS))? term
-term: (term (MOD | DIV | FLOOR_DIV | STAR_MUL | DECOR_OP))? factor
-factor: (BW_NOT | MINUS | PLUS) factor | power
-power: (power STAR_POW)? connect
+term: (term (MOD | DIV | FLOOR_DIV | STAR_MUL | DECOR_OP))? power
+power: (power STAR_POW)? factor
+factor: (BW_NOT | MINUS | PLUS) factor | connect
 
 // Connect expressions
 connect: (connect (connect_op | disconnect_op))? atomic_pipe
@@ -539,16 +539,16 @@ KW_POST_INIT: "postinit"
 KW_SUPER: "super"
 KW_ROOT: "root"
 
-FLOAT: /(\d+(\.\d*)|\.\d+)([eE][+-]?\d+)?/
+FLOAT: /(\d+(\.\d*)|\.\d+)([eE][+-]?\d+)?|\d+([eE][-+]?\d+)/
 DOC_STRING.1: /"""(.|\n|\r)*?"""|'''(.|\n|\r)*?'''/
 PYNLINE: /::py::(.|\n|\r)*?::py::/
 STRING: /(r?b?|b?r?)"[^"\r\n]*"|(r?b?|b?r?)'[^'\r\n]*'/
 BOOL.1: /True|False/
 KW_NIN.1: /\bnot\s+in\b/
 KW_ISN.1: /\bis\s+not\b/
-HEX: /0[xX][0-9a-fA-F_]+/
-BIN: /0[bB][01_]+/
-OCT: /0[oO][0-7_]+/
+HEX.1: /0[xX][0-9a-fA-F_]+/
+BIN.1: /0[bB][01_]+/
+OCT.1: /0[oO][0-7_]+/
 INT: /[0-9][0-9_]*/
 NULL.1: /None/
 KWESC_NAME: /<>[a-zA-Z_][a-zA-Z0-9_]*/

jaclang/compiler/parser.py

@@ -287,17 +287,22 @@ class JacParser(Pass):
             if len(kid) == 1 and isinstance(kid[0], ast.Import):
                 return self.nu(kid[0])
             lang = kid[1]
-            paths = [i for i in kid if isinstance(i, ast.ModulePath)]
+            from_path = kid[3] if isinstance(kid[3], 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]
+                )
+                kid = kid[:2] + [items] + kid[-1:]
 
-            items = kid[-2] if isinstance(kid[-2], ast.SubNodeList) else None
             is_absorb = False
-            if isinstance(lang, ast.SubTag) and (
-                isinstance(items, ast.SubNodeList) or items is None
-            ):
+            if isinstance(lang, ast.SubTag) and (isinstance(items, ast.SubNodeList)):
                 return self.nu(
                     ast.Import(
                         hint=lang,
-                        paths=paths,
+                        from_loc=from_path,
                         items=items,
                         is_absorb=is_absorb,
                         kid=kid,
@@ -342,14 +347,20 @@ class JacParser(Pass):
             include_stmt: KW_INCLUDE sub_name import_path SEMI
             """
             lang = kid[1]
-            paths = [i for i in kid if isinstance(i, ast.ModulePath)]
+            from_path = kid[2]
+            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:]
             is_absorb = True
             if isinstance(lang, ast.SubTag):
                 return self.nu(
                     ast.Import(
                         hint=lang,
-                        paths=paths,
-                        items=None,
+                        from_loc=None,
+                        items=items,
                         is_absorb=is_absorb,
                         kid=kid,
                     )
@@ -1919,13 +1930,17 @@ class JacParser(Pass):
                 sig_kid.append(params)
             if return_type:
                 sig_kid.append(return_type)
-            signature = ast.FuncSignature(
-                params=params,
-                return_type=return_type,
-                kid=sig_kid,
+            signature = (
+                ast.FuncSignature(
+                    params=params,
+                    return_type=return_type,
+                    kid=sig_kid,
+                )
+                if params or return_type
+                else None
             )
             new_kid = [i for i in kid if i != params and i != return_type]
-            new_kid.insert(1, signature)
+            new_kid.insert(1, signature) if signature else None
             if isinstance(chomp[0], ast.Expr):
                 return self.nu(
                     ast.LambdaExpr(
@@ -3724,12 +3739,43 @@ class JacParser(Pass):
         def class_pattern(self, kid: list[ast.AstNode]) -> ast.MatchArch:
             """Grammar rule.
 
-            class_pattern: NAME LPAREN kw_pattern_list? RPAREN
-                        | NAME LPAREN pattern_list (COMMA kw_pattern_list)? RPAREN
+            class_pattern: NAME (DOT NAME)* LPAREN kw_pattern_list? RPAREN
+                        | NAME (DOT NAME)* LPAREN pattern_list (COMMA kw_pattern_list)? RPAREN
             """
-            name = kid[0]
-            first = kid[2]
-            second = kid[4] if len(kid) > 4 else None
+            chomp = [*kid]
+            cur_element = chomp[0]
+            chomp = chomp[1:]
+            while not (isinstance(chomp[0], ast.Token) and chomp[0].name == Tok.LPAREN):
+                if isinstance(chomp[0], ast.Token) and chomp[0].name == Tok.DOT:
+                    target_ = cur_element
+                    right_ = chomp[1]
+                    if isinstance(right_, (ast.Expr, ast.AtomExpr)) and isinstance(
+                        target_, ast.Expr
+                    ):
+                        cur_element = ast.AtomTrailer(
+                            target=target_,
+                            right=right_,
+                            is_attr=True,
+                            is_null_ok=False,
+                            kid=[target_, chomp[0], right_],
+                        )
+                        chomp = chomp[2:]
+                    else:
+                        raise self.ice()
+                elif isinstance(cur_element, ast.NameSpec):
+                    chomp = chomp[1:]
+                else:
+                    break
+            name = cur_element
+            lparen = chomp[0]
+            rapren = chomp[-1]
+            first = chomp[1]
+            if len(chomp) > 4:
+                second = chomp[3]
+                comma = chomp[2]
+            else:
+                second = None
+                comma = None
             arg = (
                 first
                 if isinstance(first, ast.SubNodeList)
@@ -3747,13 +3793,22 @@ class JacParser(Pass):
                     else None
                 )
             )
-            if isinstance(name, ast.NameSpec):
+            if isinstance(name, (ast.NameSpec, ast.AtomTrailer)):
+                kid_nodes = [name, lparen]
+                if arg:
+                    kid_nodes.append(arg)
+                    if kw:
+                        kid_nodes.extend([comma, kw]) if comma else kid_nodes.append(kw)
+                elif kw:
+                    kid_nodes.append(kw)
+                kid_nodes.append(rapren)
+
                 return self.nu(
                     ast.MatchArch(
                         name=name,
                         arg_patterns=arg,
                         kw_patterns=kw,
-                        kid=kid,
+                        kid=kid_nodes,
                     )
                 )
             else:

jaclang/compiler/passes/ir_pass.py

@@ -1,16 +1,18 @@
 """Abstract class for IR Passes for Jac."""
 
-from typing import Optional, Type
+from typing import Optional, Type, TypeVar
 
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.passes.transform import Transform
 from jaclang.utils.helpers import pascal_to_snake
 
+T = TypeVar("T", bound=ast.AstNode)
 
-class Pass(Transform[ast.T]):
+
+class Pass(Transform[T]):
     """Abstract class for IR passes."""
 
-    def __init__(self, input_ir: ast.T, prior: Optional[Transform]) -> None:
+    def __init__(self, input_ir: T, prior: Optional[Transform]) -> None:
         """Initialize parser."""
         self.term_signal = False
         self.prune_signal = False
@@ -45,10 +47,10 @@ class Pass(Transform[ast.T]):
 
     @staticmethod
     def get_all_sub_nodes(
-        node: ast.AstNode, typ: Type[ast.T], brute_force: bool = False
-    ) -> list[ast.T]:
+        node: ast.AstNode, typ: Type[T], brute_force: bool = False
+    ) -> list[T]:
         """Get all sub nodes of type."""
-        result: list[ast.T] = []
+        result: list[T] = []
         # Assumes pass built the sub node table
         if not node:
             return result
@@ -69,7 +71,7 @@ class Pass(Transform[ast.T]):
         return result
 
     @staticmethod
-    def has_parent_of_type(node: ast.AstNode, typ: Type[ast.T]) -> Optional[ast.T]:
+    def has_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):
@@ -97,7 +99,7 @@ class Pass(Transform[ast.T]):
 
     # Transform Implementations
     # -------------------------
-    def transform(self, ir: ast.T) -> ast.AstNode:
+    def transform(self, ir: T) -> ast.AstNode:
         """Run pass."""
         # Only performs passes on proper ASTs
         if not isinstance(ir, ast.AstNode):

jaclang/compiler/passes/main/__init__.py

@@ -1,7 +1,7 @@
 """Collection of passes for Jac IR."""
 
 from .sub_node_tab_pass import SubNodeTabPass
-from .import_pass import ImportPass  # 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_use_pass import DefUsePass  # noqa: I100
@@ -17,7 +17,8 @@ pass_schedule = py_code_gen
 
 __all__ = [
     "SubNodeTabPass",
-    "ImportPass",
+    "JacImportPass",
+    "PyImportPass",
     "SymTabBuildPass",
     "DeclDefMatchPass",
     "DefUsePass",

jaclang/compiler/passes/main/access_modifier_pass.py

@@ -0,0 +1,173 @@
+"""Access check pass for the Jac compiler.
+
+This pass checks for access to attributes in the Jac language.
+"""
+
+import os
+from typing import Optional
+
+import jaclang.compiler.absyntree as ast
+from jaclang.compiler.passes.main.sym_tab_build_pass import SymTabPass, SymbolAccess
+
+
+class AccessCheckPass(SymTabPass):
+    """Jac Ast Access Check pass."""
+
+    def after_pass(self) -> None:
+        """After pass."""
+        pass
+
+    def access_check(self, node: ast.Name) -> None:
+        """Access check."""
+        node_info = (
+            node.sym_tab.lookup(node.sym_name)
+            if isinstance(node.sym_tab, ast.SymbolTable)
+            else None
+        )
+
+        if node.sym_link:
+            decl_package_path = os.path.dirname(
+                os.path.abspath(node.sym_link.defn[-1].loc.mod_path)
+            )
+            use_package_path = os.path.dirname(os.path.abspath(node.loc.mod_path))
+        else:
+            decl_package_path = use_package_path = ""
+
+        if (
+            node_info
+            and node.sym_link
+            and node_info.access == SymbolAccess.PROTECTED
+            and decl_package_path != use_package_path
+        ):
+            return self.error(
+                f'Can not access protected variable "{node.sym_name}" from {decl_package_path}'
+                f" to {use_package_path}."
+            )
+
+        if (
+            node_info
+            and node.sym_link
+            and node_info.access == SymbolAccess.PRIVATE
+            and node.sym_link.defn[-1].loc.mod_path != node.loc.mod_path
+        ):
+            return self.error(
+                f'Can not access private variable "{node.sym_name}" from {node.sym_link.defn[-1].loc.mod_path}'
+                f" to {node.loc.mod_path}."
+            )
+
+    def access_register(
+        self, node: ast.AstSymbolNode, acc_tag: Optional[SymbolAccess] = None
+    ) -> None:
+        """Access register."""
+        node.sym_info.acc_tag = acc_tag
+
+    def enter_global_vars(self, node: ast.GlobalVars) -> None:
+        """Sub objects.
+
+        access: Optional[SubTag[Token]],
+        assignments: SubNodeList[Assignment],
+        is_frozen: bool,
+        """
+        pass
+
+    def enter_module(self, node: ast.Module) -> None:
+        """Sub objects.
+
+        name: str,
+        doc: Token,
+        body: Optional['Elements'],
+        mod_path: str,
+        is_imported: bool,
+        """
+
+    def enter_architype(self, node: ast.Architype) -> None:
+        """Sub objects.
+
+        name: Name,
+        arch_type: Token,
+        access: Optional[SubTag[Token]],
+        base_classes: Optional[SubNodeList[Expr]],
+        body: Optional[SubNodeList[ArchBlockStmt] | ArchDef],
+        decorators: Optional[SubNodeList[Expr]] = None,
+        """
+        pass
+
+    def enter_enum(self, node: ast.Enum) -> None:
+        """Sub objects.
+
+        name: Name,
+        access: Optional[SubTag[Token]],
+        base_classes: Optional[SubNodeList[Expr]],
+        body: Optional[SubNodeList[EnumBlockStmt] | EnumDef],
+        decorators: Optional[SubNodeList[Expr]] = None,
+        """
+        pass
+
+    def enter_ability(self, node: ast.Ability) -> None:
+        """Sub objects.
+
+        name_ref: NameSpec,
+        is_func: bool,
+        is_async: bool,
+        is_override: bool,
+        is_static: bool,
+        is_abstract: bool,
+        access: Optional[SubTag[Token]],
+        signature: Optional[FuncSignature | EventSignature],
+        body: Optional[SubNodeList[CodeBlockStmt] | AbilityDef],
+        decorators: Optional[SubNodeList[Expr]] = None,
+        """
+        pass
+
+    def enter_sub_node_list(self, node: ast.SubNodeList) -> None:
+        """Sub objects.
+
+        items: list[T]
+        """
+
+    def enter_arch_has(self, node: ast.ArchHas) -> None:
+        """Sub objects.
+
+        is_static: bool,
+        access: Optional[SubTag[Token]],
+        vars: SubNodeList[HasVar],
+        is_frozen: bool,
+        """
+        pass
+
+    def enter_atom_trailer(self, node: ast.AtomTrailer) -> None:
+        """Sub objects.
+
+        access: Optional[SubTag[Token]],
+        """
+        pass
+
+    def enter_func_call(self, node: ast.FuncCall) -> None:
+        """Sub objects.
+
+        target: Expr,
+        params: Optional[SubNodeList[Expr | KWPair]],
+        genai_call: Optional[FuncCall],
+        kid: Sequence[AstNode],
+        """
+        pass
+
+    def enter_name(self, node: ast.Name) -> None:
+        """Sub objects.
+
+        name: str,
+        value: str,
+        col_start: int,
+        col_end: int,
+        pos_start: int,
+        pos_end: int,
+        """
+        from jaclang.compiler.passes import Pass
+
+        if isinstance(node.parent, ast.FuncCall):
+            self.access_check(node)
+
+        if node.sym_link and Pass.has_parent_of_type(
+            node=node.sym_link.defn[-1], typ=ast.GlobalVars
+        ):
+            self.access_check(node)

jaclang/compiler/passes/main/fuse_typeinfo_pass.py

@@ -6,15 +6,16 @@ mypy apis into Jac and use jac py ast in it.
 
 from __future__ import annotations
 
-import os
 import traceback
 from typing import Callable, TypeVar
 
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.passes import Pass
+from jaclang.settings import settings
 from jaclang.utils.helpers import pascal_to_snake
 from jaclang.vendor.mypy.nodes import Node as VNode  # bit of a hack
 
+
 import mypy.nodes as MypyNodes  # noqa N812
 import mypy.types as MypyTypes  # noqa N812
 from mypy.checkexpr import Type as MyType
@@ -29,7 +30,7 @@ class FuseTypeInfoPass(Pass):
     node_type_hash: dict[MypyNodes.Node | VNode, MyType] = {}
 
     def __debug_print(self, *argv: object) -> None:
-        if "FuseTypeInfoDebug" in os.environ:
+        if settings.fuse_type_info_debug:
             print("FuseTypeInfo::", *argv)
 
     def __call_type_handler(

jaclang/compiler/passes/main/import_pass.py

@@ -7,7 +7,6 @@ symbols are available for matching.
 
 import ast as py_ast
 import importlib.util
-import os
 import sys
 from os import path
 from typing import Optional
@@ -16,11 +15,12 @@ from typing import Optional
 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
 
 
-class ImportPass(Pass):
-    """Jac statically imports all modules."""
+class JacImportPass(Pass):
+    """Jac statically imports Jac modules."""
 
     def before_pass(self) -> None:
         """Run once before pass."""
@@ -29,6 +29,7 @@ class ImportPass(Pass):
     def enter_module(self, node: ast.Module) -> None:
         """Run Importer."""
         self.cur_node = node
+        self.import_table[node.loc.mod_path] = node
         self.annex_impl(node)
         self.terminate()  # Turns off auto traversal for deliberate traversal
         self.run_again = True
@@ -36,29 +37,26 @@ class ImportPass(Pass):
             self.run_again = False
             all_imports = self.get_all_sub_nodes(node, ast.ModulePath)
             for i in all_imports:
-                if i.parent.hint.tag.value == "jac" and not i.sub_module:
-                    self.run_again = True
-                    mod = self.import_module(
-                        node=i,
-                        mod_path=node.loc.mod_path,
-                    )
-                    if not mod:
-                        self.run_again = False
-                        continue
-                    self.annex_impl(mod)
-                    i.sub_module = mod
-                    i.add_kids_right([mod], pos_update=False)
-                elif i.parent.hint.tag.value == "py" and os.environ.get(
-                    "JAC_PROC_DEBUG", False
-                ):
-                    mod = self.import_py_module(node=i, mod_path=node.loc.mod_path)
-                    i.sub_module = mod
-                    i.add_kids_right([mod], pos_update=False)
+                self.process_import(node, i)
                 self.enter_module_path(i)
             SubNodeTabPass(prior=self, input_ir=node)
         self.annex_impl(node)
         node.mod_deps = self.import_table
 
+    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:
+            mod = self.import_module(
+                node=i,
+                mod_path=node.loc.mod_path,
+            )
+            if mod:
+                self.run_again = True
+                self.annex_impl(mod)
+                i.sub_module = mod
+                i.add_kids_right([mod], pos_update=False)
+
     def annex_impl(self, node: ast.Module) -> None:
         """Annex impl and test modules."""
         if not node.loc.mod_path:
@@ -166,3 +164,17 @@ class ImportPass(Pass):
             )
             raise e
         return None
+
+
+class PyImportPass(JacImportPass):
+    """Jac statically imports Python modules."""
+
+    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 settings.py_raise:
+            mod = self.import_py_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)