access check for symbols implemented

jaclang/compiler/passes/main/access_modifier_pass.py

@@ -3,22 +3,40 @@
 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
+    # 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."""
@@ -36,140 +54,6 @@ def exit_node(self, node: ast.AstNode) -> None:  # TODO: Move to debug pass
         ):
             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}."
-            )
-
-        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
-
     def enter_name(self, node: ast.Name) -> None:
         """Sub objects.
 
@@ -180,12 +64,67 @@ def enter_name(self, node: ast.Name) -> None:
         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.find_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,
+            )

jaclang/compiler/passes/main/fuse_typeinfo_pass.py

@@ -51,6 +51,9 @@ def __set_sym_table_link(self, node: ast.AstSymbolNode) -> None:
         if typ[0] == "builtins":
             return
 
+        if node.sym_type == "types.ModuleType" and node.sym:
+            node.name_spec.type_sym_tab = node.sym.parent_tab.find_scope(node.sym_name)
+
         assert isinstance(self.ir, ast.Module)
 
         if typ_sym_table:
@@ -489,3 +492,30 @@ def exit_atom_trailer(self, node: ast.AtomTrailer) -> None:
                 right, ast.IndexSlice
             ):  # TODO check why IndexSlice produce an issue
                 right.name_spec.sym = left.type_sym_tab.lookup(right.sym_name)
+
+    # # TODO [Gamal]: Need to support getting the type of an expression
+    # # NOTE: Note sure why we're inferring the symbol here instead of the sym table build pass
+    # # I afraid that moving this there might break something.
+    # def lookup_sym_from_node(self, node: ast.AstNode, member: str) -> Optional[Symbol]:
+    #     """Recursively look for the symbol of a member from a given node."""
+    #     if isinstance(node, ast.AstSymbolNode):
+    #         if node.type_sym_tab is None:
+    #             return None
+    #         return node.type_sym_tab.lookup(member)
+
+    #     if isinstance(node, ast.AtomTrailer):
+    #         if node.is_attr:  # <expr>.member access.
+    #             return self.lookup_sym_from_node(node.right, member)
+    #         elif isinstance(node.right, ast.IndexSlice):
+    #             # NOTE: if the 'node.target' is a variable of type list[T] the
+    #             # node.target.sym_type is "builtins.list[T]" string Not sure how
+    #             # to get the type_sym_tab of "T" from just the name itself. would
+    #             # be better if the symbols types are not just strings but references.
+    #             # For now I'll mark them as todos.
+    #             # TODO:
+    #             # case 1: expr[i]     -> regular indexing.
+    #             # case 2: expr[i:j:k] -> returns a sublist.
+    #             # case 3: expr["str"] -> dictionary lookup.
+    #             pass
+
+    #     return None

jaclang/tests/fixtures/access_checker.jac

@@ -1,19 +1,14 @@
-obj :priv BankAccount {
-    has account_no: int;
-    can register() {
-        print(f"{self.account_no} has been registered.");
-    }
-}
-can :priv privmethod() {
-    return "private method";
-}
-can :priv overide_check() {
-    return "inside access_check";
-}
-glob :priv b=1;
-glob :priv p=0;
+
+obj :pub  ModulePublObj {}
+obj :priv ModulePrivObj {}
+
+glob :pub  module_publ_glob:int = 0;
+glob :priv module_priv_glob:int = 0;
+
 with entry {
-    public = BankAccount(123);
-    public.register();
-    privmethod();
+    ModulePrivObj(); # <-- okey.
+    ModulePublObj(); # <-- okey.
+
+    module_publ_glob; # <-- okey.
+    module_priv_glob; # <-- okey.
 }