jaclang 0.5.18__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

jaclang/compiler/parser.py

@@ -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/import_pass.py

@@ -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,28 +37,26 @@ 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
+                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:
@@ -165,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)

jaclang/compiler/passes/main/pyast_gen_pass.py

@@ -611,9 +611,10 @@ class PyastGenPass(Pass):
                 )
             )
             if node.items:
-                self.warning(
-                    "Includes import * in target module into current namespace."
-                )
+                pass
+                # self.warning(
+                #     "Includes import * in target module into current namespace."
+                # )
         if not node.from_loc:
             py_nodes.append(self.sync(ast3.Import(names=node.items.gen.py_ast)))
         else:
@@ -676,8 +677,6 @@ class PyastGenPass(Pass):
         doc: Optional[String],
         decorators: Optional[SubNodeList[ExprType]],
         """
-        self.needs_jac_feature()
-        self.needs_dataclass()
         body = self.resolve_stmt_block(
             node.body.body if isinstance(node.body, ast.ArchDef) else node.body,
             doc=node.doc,
@@ -689,6 +688,8 @@ class PyastGenPass(Pass):
         )
         ds_on_entry, ds_on_exit = self.collect_events(node)
         if node.arch_type.name != Tok.KW_CLASS:
+            self.needs_jac_feature()
+            self.needs_dataclass()
             decorators.append(
                 self.sync(
                     ast3.Call(
@@ -723,24 +724,26 @@ class PyastGenPass(Pass):
                     )
                 )
             )
-        decorators.append(
-            self.sync(
-                ast3.Call(
-                    func=self.sync(ast3.Name(id="__jac_dataclass__", ctx=ast3.Load())),
-                    args=[],
-                    keywords=[
-                        self.sync(
-                            ast3.keyword(
-                                arg="eq",
-                                value=self.sync(
-                                    ast3.Constant(value=False),
-                                ),
+            decorators.append(
+                self.sync(
+                    ast3.Call(
+                        func=self.sync(
+                            ast3.Name(id="__jac_dataclass__", ctx=ast3.Load())
+                        ),
+                        args=[],
+                        keywords=[
+                            self.sync(
+                                ast3.keyword(
+                                    arg="eq",
+                                    value=self.sync(
+                                        ast3.Constant(value=False),
+                                    ),
+                                )
                             )
-                        )
-                    ],
+                        ],
+                    )
                 )
             )
-        )
         base_classes = node.base_classes.gen.py_ast if node.base_classes else []
         if node.is_abstract:
             self.needs_jac_feature()
@@ -1065,7 +1068,11 @@ class PyastGenPass(Pass):
                 if isinstance(node.signature, ast.FuncSignature)
                 else []
             )
-            action = node.semstr.gen.py_ast[0] if node.semstr else None
+            action = (
+                node.semstr.gen.py_ast[0]
+                if node.semstr
+                else self.sync(ast3.Constant(value=None))
+            )
             return [
                 self.sync(
                     ast3.Assign(
@@ -1385,12 +1392,20 @@ class PyastGenPass(Pass):
             ):
                 node.gen.py_ast = [
                     self.sync(
-                        ast3.Attribute(
-                            value=self.sync(
-                                ast3.Name(id=Con.JAC_FEATURE.value, ctx=ast3.Load())
+                        ast3.Call(
+                            func=self.sync(
+                                ast3.Attribute(
+                                    value=self.sync(
+                                        ast3.Name(
+                                            id=Con.JAC_FEATURE.value, ctx=ast3.Load()
+                                        )
+                                    ),
+                                    attr="get_root_type",
+                                    ctx=ast3.Load(),
+                                )
                             ),
-                            attr="RootType",
-                            ctx=ast3.Load(),
+                            args=[],
+                            keywords=[],
                         )
                     )
                 ]