jaclang 0.5.18__py3-none-any.whl → 0.6.1__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

jaclang/compiler/parser.py

@@ -140,7 +140,7 @@ class JacParser(Pass):
             body = kid[1:] if doc else kid
             body = [i for i in body if isinstance(i, ast.ElementStmt)]
             mod = ast.Module(
-                name=self.parse_ref.mod_path.split(os.path.sep)[-1].split(".")[0],
+                name=self.parse_ref.mod_path.split(os.path.sep)[-1].rstrip(".jac"),
                 source=self.parse_ref.source,
                 doc=doc,
                 body=body,
@@ -3739,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)
@@ -3762,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/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/def_impl_match_pass.py

@@ -72,7 +72,10 @@ class DeclDefMatchPass(Pass):
                     continue
                 decl_node.body = sym.decl  # type: ignore
                 sym.decl.decl_link = decl_node  # type: ignore
-                decl_node.add_kids_right([sym.decl], pos_update=False)  # type: ignore
+                source_node = sym.decl.parent
+                decl_node.add_kids_right([sym.decl])  # type: ignore
+                if source_node and sym.decl in source_node.kid:
+                    source_node.kid.remove(sym.decl)
                 decl_node.sym_tab.tab = sym.decl.sym_tab.tab  # type: ignore
         for i in sym_tab.kid:
             self.connect_def_impl(i)

jaclang/compiler/passes/main/fuse_typeinfo_pass.py

@@ -48,8 +48,16 @@ class FuseTypeInfoPass(Pass):
     def __set_sym_table_link(self, node: ast.AstSymbolNode) -> None:
         typ = node.sym_info.typ.split(".")
         typ_sym_table = self.ir.sym_tab
-        if typ_sym_table and typ[0] == typ_sym_table.name:
-            for i in typ[1:]:
+
+        if typ[0] == "builtins":
+            return
+
+        assert isinstance(self.ir, ast.Module)
+
+        if typ_sym_table:
+            for i in typ:
+                if i == self.ir.name:
+                    continue
                 f = typ_sym_table.find_scope(i)
                 if f:
                     typ_sym_table = f
@@ -159,11 +167,6 @@ class FuseTypeInfoPass(Pass):
                     type(mypy_node),
                 )
 
-    def enter_import(self, node: ast.Import) -> None:
-        """Pass handler for import nodes."""
-        # Pruning the import nodes
-        self.prune()
-
     @__handle_node
     def enter_name(self, node: ast.NameSpec) -> None:
         """Pass handler for name nodes."""

jaclang/compiler/passes/main/import_pass.py

@@ -7,8 +7,8 @@ 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
 
 
@@ -19,8 +19,8 @@ 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,48 +37,63 @@ class ImportPass(Pass):
             self.run_again = False
             all_imports = self.get_all_sub_nodes(node, ast.ModulePath)
             for i in all_imports:
-                lang = i.parent_of_type(ast.Import).hint.tag.value
-                if lang == "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 lang == "py" and settings.jac_proc_debug:
-                    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
+                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:
             self.error("Module has no path")
-        if node.loc.mod_path.endswith(".jac") and path.exists(
-            f"{node.loc.mod_path[:-4]}.impl.jac"
-        ):
-            mod = self.import_mod_from_file(f"{node.loc.mod_path[:-4]}.impl.jac")
-            if mod:
-                node.impl_mod = mod
-                node.add_kids_left([mod], pos_update=False)
-                mod.parent = node
-        if node.loc.mod_path.endswith(".jac") and path.exists(
-            f"{node.loc.mod_path[:-4]}.test.jac"
-        ):
-            mod = self.import_mod_from_file(f"{node.loc.mod_path[:-4]}.test.jac")
-            if mod:
-                node.test_mod = mod
-                node.add_kids_right([mod], pos_update=False)
-                mod.parent = node
+        if not node.loc.mod_path.endswith(".jac"):
+            return
+        base_path = node.loc.mod_path[:-4]
+        directory = os.path.dirname(node.loc.mod_path)
+        if not directory:
+            directory = os.getcwd()
+            base_path = os.path.join(directory, base_path)
+        impl_folder = base_path + ".impl"
+        search_files = [
+            os.path.join(directory, impl_file) for impl_file in os.listdir(directory)
+        ]
+        if os.path.exists(impl_folder):
+            search_files += [
+                os.path.join(impl_folder, impl_file)
+                for impl_file in os.listdir(impl_folder)
+            ]
+        for impl_file in search_files:
+            if node.loc.mod_path.endswith(impl_file):
+                continue
+            if (
+                impl_file.startswith(f"{base_path}.") or impl_folder in impl_file
+            ) and impl_file.endswith(".impl.jac"):
+                mod = self.import_mod_from_file(impl_file)
+                if mod:
+                    node.impl_mod.append(mod)
+                    node.add_kids_left([mod], pos_update=False)
+                    mod.parent = node
+            if (
+                impl_file.startswith(f"{base_path}.") or impl_folder in impl_file
+            ) and impl_file.endswith(".test.jac"):
+                mod = self.import_mod_from_file(impl_file)
+                if mod:
+                    node.test_mod = mod
+                    node.add_kids_right([mod], pos_update=False)
+                    mod.parent = node
 
     def enter_module_path(self, node: ast.ModulePath) -> None:
         """Sub objects.
@@ -97,7 +113,7 @@ class ImportPass(Pass):
         """Import a module."""
         self.cur_node = node  # impacts error reporting
         target = import_target_to_relative_path(
-            node.level, node.path_str, path.dirname(node.loc.mod_path)
+            node.level, node.path_str, os.path.dirname(node.loc.mod_path)
         )
         return self.import_mod_from_file(target)
 
@@ -106,7 +122,7 @@ class ImportPass(Pass):
         from jaclang.compiler.compile import jac_file_to_pass
         from jaclang.compiler.passes.main import SubNodeTabPass
 
-        if not path.exists(target):
+        if not os.path.exists(target):
             self.error(f"Could not find module {target}")
             return None
         if target in self.import_table:
@@ -134,7 +150,7 @@ class ImportPass(Pass):
         """Import a module."""
         from jaclang.compiler.passes.main import PyastBuildPass
 
-        base_dir = path.dirname(mod_path)
+        base_dir = os.path.dirname(mod_path)
         sys.path.append(base_dir)
 
         try:
@@ -165,3 +181,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)