jaclang 0.7.14__py3-none-any.whl → 0.7.17__py3-none-any.whl

jaclang/compiler/constant.py

@@ -94,18 +94,18 @@ class Constants(StrEnum):
     HERE = "_jac_here_"
     JAC_FEATURE = "_Jac"
     ROOT = f"{JAC_FEATURE}.get_root()"
-    EDGES_TO_NODE = "_jac_.edges_to_nodes"
-    EDGE_REF = "_jac_.edge_ref"
-    CONNECT_NODE = "_jac_.connect_node"
-    DISCONNECT_NODE = "_jac_.disconnect_node"
-    WALKER_VISIT = "_jac_.visit_node"
-    WALKER_IGNORE = "_jac_.ignore_node"
-    DISENGAGE = "_jac_.disengage_now"
+    EDGES_TO_NODE = "__jac__.edges_to_nodes"
+    EDGE_REF = "__jac__.edge_ref"
+    CONNECT_NODE = "__jac__.connect_node"
+    DISCONNECT_NODE = "__jac__.disconnect_node"
+    WALKER_VISIT = "__jac__.visit_node"
+    WALKER_IGNORE = "__jac__.ignore_node"
+    DISENGAGE = "__jac__.disengage_now"
     OBJECT_CLASS = "_jac_Object_"
     NODE_CLASS = "_jac_Node_"
     EDGE_CLASS = "_jac_Edge_"
     WALKER_CLASS = "_jac_Walker_"
-    WITH_DIR = "_jac_.apply_dir"
+    WITH_DIR = "__jac__.apply_dir"
     EDGE_DIR = "_jac_Edge_Dir"
     ON_ENTRY = "_jac_ds_.on_entry"
     ON_EXIT = "_jac_ds_.on_exit"

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/compiler/parser.py

@@ -163,7 +163,11 @@ class JacParser(Pass):
                 body=body,
                 is_imported=False,
                 terminals=self.terminals,
-                kid=kid if len(kid) else [ast.EmptyToken()],
+                kid=(
+                    kid
+                    if len(kid)
+                    else [ast.EmptyToken(file_path=self.parse_ref.mod_path)]
+                ),
             )
             return self.nu(mod)
 
@@ -298,26 +302,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 +333,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 +379,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.
@@ -995,7 +1007,11 @@ class JacParser(Pass):
                         semstr=semstr,
                         params=params,
                         return_type=return_spec,
-                        kid=kid if len(kid) else [ast.EmptyToken()],
+                        kid=(
+                            kid
+                            if len(kid)
+                            else [ast.EmptyToken(file_path=self.parse_ref.mod_path)]
+                        ),
                     )
                 )
             else:

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):
@@ -115,7 +115,7 @@ class Pass(Transform[T]):
         self.after_pass()
         self.time_taken = time.time() - start_time
         if settings.pass_timer:
-            print(
+            self.log_info(
                 f"Time taken in {self.__class__.__name__}: {self.time_taken:.4f} seconds"
             )
         return self.ir
@@ -136,21 +136,12 @@ class Pass(Transform[T]):
         self.exit_node(node)
         return node
 
-    def update_code_loc(self, node: Optional[ast.AstNode] = None) -> None:
-        """Update code location."""
-        if node is None:
-            node = self.cur_node
-        if not isinstance(node, ast.AstNode):
-            self.ice("Current node is not an AstNode.")
-
     def error(self, msg: str, node_override: Optional[ast.AstNode] = None) -> None:
         """Pass Error."""
-        self.update_code_loc(node_override)
         self.log_error(f"{msg}", node_override=node_override)
 
     def warning(self, msg: str, node_override: Optional[ast.AstNode] = None) -> None:
         """Pass Error."""
-        self.update_code_loc(node_override)
         self.log_warning(f"{msg}", node_override=node_override)
 
     def ice(self, msg: str = "Something went horribly wrong!") -> RuntimeError:
@@ -166,10 +157,10 @@ class PrinterPass(Pass):
 
     def enter_node(self, node: ast.AstNode) -> None:
         """Run on entering node."""
-        print("Entering:", node)
+        self.log_info(f"Entering: {node.__class__.__name__}: {node.loc}")
         super().enter_node(node)
 
     def exit_node(self, node: ast.AstNode) -> None:
         """Run on exiting node."""
         super().exit_node(node)
-        print("Exiting:", node)
+        self.log_info(f"Exiting: {node.__class__.__name__}: {node.loc}")

jaclang/compiler/passes/main/__init__.py

@@ -1,8 +1,8 @@
 """Collection of passes for Jac IR."""
 
 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 .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

jaclang/compiler/passes/main/access_modifier_pass.py

@@ -3,162 +3,56 @@
 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.constant import SymbolAccess
 from jaclang.compiler.passes import Pass
-from jaclang.compiler.symtable import SymbolTable
+from jaclang.compiler.symtable import Symbol
 from jaclang.settings import settings
 
 
 class AccessCheckPass(Pass):
     """Jac Ast Access Check pass."""
 
-    def after_pass(self) -> None:
-        """After pass."""
-        pass
-
-    def exit_node(self, node: ast.AstNode) -> None:
+    # NOTE: This method is a hacky way to detect if the drivied class is inherit from base class, it
+    # doesn't work if the base class was provided as an expression (ex. obj Dri :module.Base: {...}).
+    def is_class_inherited_from(
+        self, dri_class: ast.Architype, base_class: ast.Architype
+    ) -> bool:
+        """Return true if the dri_class inherited from base_class."""
+        if dri_class.base_classes is None:
+            return False
+        for expr in dri_class.base_classes.items:
+            if not isinstance(expr, ast.Name):
+                continue
+            if not isinstance(expr.name_of, ast.Architype):
+                continue  # Unlikely.
+            if expr.name_of == base_class:
+                return True
+            if self.is_class_inherited_from(expr.name_of, base_class):
+                return True
+        return False
+
+    def report_error(self, message: str, node: Optional[ast.AstNode] = None) -> None:
+        """Report error message related to illegal access of attributes and objects."""
+        self.error(message, node)
+
+    def exit_node(self, node: ast.AstNode) -> None:  # TODO: Move to debug pass
         """Exit node."""
         super().exit_node(node)
-        if settings.lsp_debug and isinstance(node, ast.NameAtom) and not node.sym:
-            self.warning(f"Name {node.sym_name} not present in symbol table")
-
-    def access_check(self, node: ast.Name) -> None:
-        """Access check."""
-        node_info = (
-            node.sym_tab.lookup(node.sym_name)
-            if isinstance(node.sym_tab, SymbolTable)
-            else None
-        )
-
-        if node.sym:
-            decl_package_path = os.path.dirname(
-                os.path.abspath(node.sym.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
-            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}."
+            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.sym_name == "py"
+                and node.parent
+                and isinstance(node.parent.parent, ast.Import)
             )
-
-        if (
-            node_info
-            and node.sym
-            and node_info.access == SymbolAccess.PRIVATE
-            and node.sym.defn[-1].loc.mod_path != node.loc.mod_path
         ):
-            return self.error(
-                f'Can not access private variable "{node.sym_name}" from {node.sym.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."""
-
-    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
+            self.warning(f"Name {node.sym_name} not present in symbol table")
 
     def enter_name(self, node: ast.Name) -> None:
         """Sub objects.
@@ -170,12 +64,67 @@ class AccessCheckPass(Pass):
         pos_start: int,
         pos_end: int,
         """
-        from jaclang.compiler.passes import Pass
+        # TODO: Enums are not considered at the moment, I'll need to test and add them bellow.
 
-        if isinstance(node.parent, ast.FuncCall):
-            self.access_check(node)
+        # If the current node is a global variable's name there is no access, it's just the declaration.
+        if Pass.find_parent_of_type(node, ast.GlobalVars) is not None:
+            return
 
-        if node.sym and Pass.has_parent_of_type(
-            node=node.sym.defn[-1], typ=ast.GlobalVars
-        ):
-            self.access_check(node)
+        # Class name, and ability name are declarations and there is no access here as well.
+        if isinstance(node.name_of, (ast.Ability, ast.Architype, ast.Enum)):
+            return
+
+        # Get the context to check the access.
+        curr_class: Optional[ast.Architype] = Pass.find_parent_of_type(
+            node, ast.Architype
+        )
+        curr_module: Optional[ast.Module] = Pass.find_parent_of_type(node, ast.Module)
+        if curr_module is None:
+            return
+
+        # Note that currently we can only check for name + symbols, because expressions are not associated with the
+        # typeinfo thus they don't have a symbol. In the future the name nodes will become expression nodes.
+        if not isinstance(node.sym, Symbol):
+            return
+
+        # Public symbols are fine.
+        if node.sym.access == SymbolAccess.PUBLIC:
+            return
+
+        # Note that from bellow the access is either private or protected.
+        is_portect = node.sym.access == SymbolAccess.PROTECTED
+        access_type = "protected" if is_portect else "private"
+
+        # The class we're currently in (None if we're not inside any).
+        sym_owner: ast.AstNode = node.sym.parent_tab.owner
+
+        # If the symbol belongs to a class, we need to check if the access used properly
+        # within the class and in it's inherited classes.
+        if isinstance(sym_owner, ast.Architype):
+
+            # Accessing a private/protected member within the top level scope illegal.
+            if curr_class is None:
+                return self.report_error(
+                    f'Error: Invalid access of {access_type} member "{node.sym_name}".',
+                    node,
+                )
+
+            if curr_class != node.sym.parent_tab.owner:
+                if not is_portect:  # private member accessed in a different class.
+                    return self.report_error(
+                        f'Error: Invalid access of {access_type} member "{node.sym_name}".',
+                        node,
+                    )
+                else:  # Accessing a protected member, check we're in an inherited class.
+                    if not self.is_class_inherited_from(curr_class, sym_owner):
+                        return self.report_error(
+                            f'Error: Invalid access of {access_type} member "{node.sym_name}".',
+                            node,
+                        )
+
+        elif isinstance(sym_owner, ast.Module) and sym_owner != curr_module:
+            # Accessing a private/public member in a different module.
+            return self.report_error(
+                f'Error: Invalid access of {access_type} member "{node.sym_name}".',
+                node,
+            )