jaclang 0.7.2__py3-none-any.whl → 0.7.5__py3-none-any.whl

jaclang/compiler/passes/main/def_use_pass.py

@@ -19,29 +19,60 @@ class DefUsePass(SymTabPass):
     def after_pass(self) -> None:
         """After pass."""
 
+    def inherit_baseclasses_sym(self, node: ast.Architype | ast.Enum) -> None:
+        """Inherit base classes symbol tables."""
+        if node.base_classes:
+            for cls in node.base_classes.items:
+                if (
+                    isinstance(cls, ast.AstSymbolNode)
+                    and (found := self.use_lookup(cls))
+                    and found
+                    and found.decl.sym_tab
+                    and node.sym_tab
+                ):
+                    node.sym_tab.inherit.append(found.decl.sym_tab)
+
     def enter_architype(self, node: ast.Architype) -> None:
         """Sub objects.
 
         name: Name,
-        doc: Optional[Token],
-        body: Optional[SubNodeList[ArchStmt]],
-        sym_tab: Optional[SymbolTable],
+        arch_type: Token,
+        access: Optional[SubTag[Token]],
+        base_classes: Optional[SubNodeList[Expr]],
+        body: Optional[SubNodeList[ArchBlockStmt] | ArchDef],
+        doc: Optional[String] = None,
+        semstr: Optional[String] = None,
+        decorators: Optional[SubNodeList[Expr]] = None,
         """
+        self.inherit_baseclasses_sym(node)
+
+        def inform_from_walker(node: ast.AstNode) -> None:
+            for i in (
+                node.get_all_sub_nodes(ast.VisitStmt)
+                + node.get_all_sub_nodes(ast.IgnoreStmt)
+                + node.get_all_sub_nodes(ast.DisengageStmt)
+                + node.get_all_sub_nodes(ast.EdgeOpRef)
+            ):
+                i.from_walker = True
+
         if node.arch_type.name == Tok.KW_WALKER:
-            self.inform_from_walker(node)
+            inform_from_walker(node)
             for i in self.get_all_sub_nodes(node, ast.Ability):
                 if isinstance(i.body, ast.AbilityDef):
-                    self.inform_from_walker(i.body)
-
-    def inform_from_walker(self, node: ast.AstNode) -> None:
-        """Inform all sub nodes that they are from a walker."""
-        for i in (
-            self.get_all_sub_nodes(node, ast.VisitStmt)
-            + self.get_all_sub_nodes(node, ast.IgnoreStmt)
-            + self.get_all_sub_nodes(node, ast.DisengageStmt)
-            + self.get_all_sub_nodes(node, ast.EdgeOpRef)
-        ):
-            i.from_walker = True
+                    inform_from_walker(i.body)
+
+    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],
+        doc: Optional[String] = None,
+        semstr: Optional[String] = None,
+        decorators: Optional[SubNodeList[Expr]] = None,
+        """
+        self.inherit_baseclasses_sym(node)
 
     def enter_arch_ref(self, node: ast.ArchRef) -> None:
         """Sub objects.
@@ -296,9 +327,9 @@ class DefUsePass(SymTabPass):
         )
         for i in items:
             if isinstance(i, ast.AtomTrailer):
-                self.unwind_atom_trailer(i)[-1].py_ctx_func = ast3.Del
+                self.unwind_atom_trailer(i)[-1].name_spec.py_ctx_func = ast3.Del
             elif isinstance(i, ast.AstSymbolNode):
-                i.py_ctx_func = ast3.Del
+                i.name_spec.py_ctx_func = ast3.Del
             else:
                 self.error("Delete target not valid")
 

jaclang/compiler/passes/main/fuse_typeinfo_pass.py

@@ -46,7 +46,7 @@ class FuseTypeInfoPass(Pass):
             )
 
     def __set_sym_table_link(self, node: ast.AstSymbolNode) -> None:
-        typ = node.sym_info.typ.split(".")
+        typ = node.sym_type.split(".")
         typ_sym_table = self.ir.sym_tab
 
         if typ[0] == "builtins":
@@ -63,7 +63,7 @@ class FuseTypeInfoPass(Pass):
                     typ_sym_table = f
 
         if typ_sym_table != self.ir.sym_tab:
-            node.sym_info.typ_sym_table = typ_sym_table
+            node.name_spec.type_sym_tab = typ_sym_table
 
     @staticmethod
     def __handle_node(
@@ -133,7 +133,7 @@ class FuseTypeInfoPass(Pass):
                     t = t.split("->")[1].strip()
                 elif "def" in t:
                     t = "None"
-                node.sym_info.typ = t
+                node.name_spec.sym_type = t
             else:
                 self.__debug_print(f"{node.loc} MemberExpr type is not found")
 
@@ -145,16 +145,16 @@ class FuseTypeInfoPass(Pass):
                 self.__call_type_handler(node, mypy_node.type)
 
             elif isinstance(mypy_node, MypyNodes.MypyFile):
-                node.sym_info = ast.SymbolInfo("types.ModuleType")
+                node.name_spec.sym_type = "types.ModuleType"
 
             elif isinstance(mypy_node, MypyNodes.TypeInfo):
-                node.sym_info = ast.SymbolInfo(mypy_node.fullname)
+                node.name_spec.sym_type = mypy_node.fullname
 
             elif isinstance(mypy_node, MypyNodes.OverloadedFuncDef):
                 self.__call_type_handler(node, mypy_node.items[0].func.type)
 
             elif mypy_node is None:
-                node.sym_info = ast.SymbolInfo("None")
+                node.name_spec.sym_type = "None"
 
             else:
                 self.__debug_print(
@@ -164,7 +164,7 @@ class FuseTypeInfoPass(Pass):
 
         else:
             if isinstance(mypy_node, MypyNodes.ClassDef):
-                node.sym_info.typ = mypy_node.fullname
+                node.name_spec.sym_type = mypy_node.fullname
                 self.__set_sym_table_link(node)
             elif isinstance(mypy_node, MypyNodes.FuncDef):
                 self.__call_type_handler(node, mypy_node.type)
@@ -179,7 +179,7 @@ class FuseTypeInfoPass(Pass):
                 )
 
     @__handle_node
-    def enter_name(self, node: ast.NameSpec) -> None:
+    def enter_name(self, node: ast.NameAtom) -> None:
         """Pass handler for name nodes."""
         self.__collect_type_from_symbol(node)
 
@@ -188,12 +188,12 @@ class FuseTypeInfoPass(Pass):
         if isinstance(node.parent, ast.AtomTrailer):
             target_node = node.parent.target
             if isinstance(target_node, ast.AstSymbolNode):
-                parent_symbol_table = target_node.sym_info.typ_sym_table
+                parent_symbol_table = target_node.type_sym_tab
                 if isinstance(parent_symbol_table, ast.SymbolTable):
                     owner = parent_symbol_table.owner
                     if isinstance(owner, ast.AstSymbolNode):
-                        target_node.sym_link = owner.sym_link
-                        node.sym_link = parent_symbol_table.lookup(node.sym_name)
+                        target_node.name_spec.sym = owner.sym
+                        node.sym = parent_symbol_table.lookup(node.sym_name)
 
     @__handle_node
     def enter_module_path(self, node: ast.ModulePath) -> None:
@@ -279,13 +279,13 @@ class FuseTypeInfoPass(Pass):
 
     def exit_has_var(self, node: ast.HasVar) -> None:
         """Pass handler for HasVar nodes."""
-        node.sym_info.typ = node.name.sym_info.typ
-        node.sym_info.typ_sym_table = node.name.sym_info.typ_sym_table
+        node.name_spec.sym_type = node.name.sym_type
+        node.name_spec.type_sym_tab = node.name.type_sym_tab
 
     @__handle_node
     def enter_multi_string(self, node: ast.MultiString) -> None:
         """Pass handler for MultiString nodes."""
-        node.sym_info = ast.SymbolInfo("builtins.str")
+        node.name_spec.sym_type = "builtins.str"
 
     @__handle_node
     def enter_f_string(self, node: ast.FString) -> None:
@@ -297,48 +297,48 @@ class FuseTypeInfoPass(Pass):
         """Pass handler for ListVal nodes."""
         mypy_node = node.gen.mypy_ast[0]
         if mypy_node in self.node_type_hash:
-            node.sym_info.typ = str(self.node_type_hash[mypy_node])
+            node.name_spec.sym_type = str(self.node_type_hash[mypy_node])
         else:
-            node.sym_info.typ = "builtins.list"
+            node.name_spec.sym_type = "builtins.list"
 
     @__handle_node
     def enter_set_val(self, node: ast.SetVal) -> None:
         """Pass handler for SetVal nodes."""
         mypy_node = node.gen.mypy_ast[0]
         if mypy_node in self.node_type_hash:
-            node.sym_info.typ = str(self.node_type_hash[mypy_node])
+            node.name_spec.sym_type = str(self.node_type_hash[mypy_node])
         else:
-            node.sym_info.typ = "builtins.set"
+            node.name_spec.sym_type = "builtins.set"
 
     @__handle_node
     def enter_tuple_val(self, node: ast.TupleVal) -> None:
         """Pass handler for TupleVal nodes."""
         mypy_node = node.gen.mypy_ast[0]
         if mypy_node in self.node_type_hash:
-            node.sym_info.typ = str(self.node_type_hash[mypy_node])
+            node.name_spec.sym_type = str(self.node_type_hash[mypy_node])
         else:
-            node.sym_info.typ = "builtins.tuple"
+            node.name_spec.sym_type = "builtins.tuple"
 
     @__handle_node
     def enter_dict_val(self, node: ast.DictVal) -> None:
         """Pass handler for DictVal nodes."""
         mypy_node = node.gen.mypy_ast[0]
         if mypy_node in self.node_type_hash:
-            node.sym_info.typ = str(self.node_type_hash[mypy_node])
+            node.name_spec.sym_type = str(self.node_type_hash[mypy_node])
         else:
-            node.sym_info.typ = "builtins.dict"
+            node.name_spec.sym_type = "builtins.dict"
 
     @__handle_node
     def enter_list_compr(self, node: ast.ListCompr) -> None:
         """Pass handler for ListCompr nodes."""
         mypy_node = node.gen.mypy_ast[0]
-        node.sym_info.typ = str(self.node_type_hash[mypy_node])
+        node.name_spec.sym_type = str(self.node_type_hash[mypy_node])
 
     @__handle_node
     def enter_dict_compr(self, node: ast.DictCompr) -> None:
         """Pass handler for DictCompr nodes."""
         mypy_node = node.gen.mypy_ast[0]
-        node.sym_info.typ = str(self.node_type_hash[mypy_node])
+        node.name_spec.sym_type = str(self.node_type_hash[mypy_node])
 
     @__handle_node
     def enter_index_slice(self, node: ast.IndexSlice) -> None:
@@ -350,7 +350,7 @@ class FuseTypeInfoPass(Pass):
         """Pass handler for ArchRef nodes."""
         if isinstance(node.gen.mypy_ast[0], MypyNodes.ClassDef):
             mypy_node: MypyNodes.ClassDef = node.gen.mypy_ast[0]
-            node.sym_info.typ = mypy_node.fullname
+            node.name_spec.sym_type = mypy_node.fullname
             self.__set_sym_table_link(node)
         elif isinstance(node.gen.mypy_ast[0], MypyNodes.FuncDef):
             mypy_node2: MypyNodes.FuncDef = node.gen.mypy_ast[0]
@@ -384,22 +384,22 @@ class FuseTypeInfoPass(Pass):
     @__handle_node
     def enter_int(self, node: ast.Int) -> None:
         """Pass handler for Int nodes."""
-        node.sym_info.typ = "builtins.int"
+        node.name_spec.sym_type = "builtins.int"
 
     @__handle_node
     def enter_float(self, node: ast.Float) -> None:
         """Pass handler for Float nodes."""
-        node.sym_info.typ = "builtins.float"
+        node.name_spec.sym_type = "builtins.float"
 
     @__handle_node
     def enter_string(self, node: ast.String) -> None:
         """Pass handler for String nodes."""
-        node.sym_info.typ = "builtins.str"
+        node.name_spec.sym_type = "builtins.str"
 
     @__handle_node
     def enter_bool(self, node: ast.Bool) -> None:
         """Pass handler for Bool nodes."""
-        node.sym_info.typ = "builtins.bool"
+        node.name_spec.sym_type = "builtins.bool"
 
     @__handle_node
     def enter_builtin_type(self, node: ast.BuiltinType) -> None:
@@ -410,13 +410,13 @@ class FuseTypeInfoPass(Pass):
         self, node: ast.AstSymbolNode, mypy_type: MypyTypes.Instance
     ) -> None:
         """Get type info from mypy type Instance."""
-        node.sym_info = ast.SymbolInfo(str(mypy_type))
+        node.name_spec.sym_type = str(mypy_type)
 
     def get_type_from_callable_type(
         self, node: ast.AstSymbolNode, mypy_type: MypyTypes.CallableType
     ) -> None:
         """Get type info from mypy type CallableType."""
-        node.sym_info = ast.SymbolInfo(str(mypy_type.ret_type))
+        node.name_spec.sym_type = str(mypy_type.ret_type)
 
     # TODO: Which overloaded function to get the return value from?
     def get_type_from_overloaded(
@@ -429,16 +429,16 @@ class FuseTypeInfoPass(Pass):
         self, node: ast.AstSymbolNode, mypy_type: MypyTypes.NoneType
     ) -> None:
         """Get type info from mypy type NoneType."""
-        node.sym_info = ast.SymbolInfo("None")
+        node.name_spec.sym_type = "None"
 
     def get_type_from_any_type(
         self, node: ast.AstSymbolNode, mypy_type: MypyTypes.AnyType
     ) -> None:
         """Get type info from mypy type NoneType."""
-        node.sym_info = ast.SymbolInfo("Any")
+        node.name_spec.sym_type = "Any"
 
     def get_type_from_tuple_type(
         self, node: ast.AstSymbolNode, mypy_type: MypyTypes.TupleType
     ) -> None:
         """Get type info from mypy type TupleType."""
-        node.sym_info = ast.SymbolInfo("builtins.tuple")
+        node.name_spec.sym_type = "builtins.tuple"

jaclang/compiler/passes/main/import_pass.py

@@ -204,15 +204,17 @@ class JacImportPass(Pass):
 class PyImportPass(JacImportPass):
     """Jac statically imports Python modules."""
 
+    def before_pass(self) -> None:
+        """Only run pass if settings are set to raise python."""
+        if not settings.py_raise:
+            self.terminate()
+        else:
+            return super().before_pass()
+
     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
-            and not is_standard_lib_module(i.path_str)
-        ):
+        if lang == "py" and not i.sub_module and not is_standard_lib_module(i.path_str):
             mod = self.import_py_module(node=i, mod_path=node.loc.mod_path)
             if mod:
                 i.sub_module = mod

jaclang/compiler/passes/main/pyast_gen_pass.py

@@ -42,7 +42,6 @@ class PyastGenPass(Pass):
         """Initialize pass."""
         self.debuginfo: dict[str, list[str]] = {"jac_mods": []}
         self.already_added: list[str] = []
-        self.method_sigs: list[ast.FuncSignature | ast.EventSignature] = []
         self.preamble: list[ast3.AST] = [
             self.sync(
                 ast3.ImportFrom(
@@ -393,7 +392,7 @@ class PyastGenPass(Pass):
                 args=self.sync(
                     ast3.arguments(
                         posonlyargs=[],
-                        args=[self.sync(ast3.arg(arg="check", annotation=None))],
+                        args=[self.sync(ast3.arg(arg="_jac_check", annotation=None))],
                         kwonlyargs=[],
                         vararg=None,
                         kwargs=None,
@@ -552,7 +551,7 @@ class PyastGenPass(Pass):
                                             arg="mod_bundle",
                                             value=self.sync(
                                                 ast3.Name(
-                                                    id="__jac_mod_bundle__",
+                                                    id="__name__",
                                                     ctx=ast3.Load(),
                                                 )
                                             ),
@@ -678,14 +677,6 @@ class PyastGenPass(Pass):
         doc: Optional[String],
         decorators: Optional[SubNodeList[ExprType]],
         """
-        # Record all signatures that are part of methods
-        for i in (
-            node.body.body.items
-            if isinstance(node.body, ast.ArchDef)
-            else node.body.items if node.body else []
-        ):
-            if isinstance(i, ast.Ability):
-                self.method_sigs.append(i.signature)
         if isinstance(node.body, ast.AstImplOnlyNode):
             self.traverse(node.body)
 
@@ -768,6 +759,18 @@ class PyastGenPass(Pass):
                 )
             )
         base_classes = node.base_classes.gen.py_ast if node.base_classes else []
+        if node.arch_type.name != Tok.KW_CLASS:
+            base_classes.append(
+                self.sync(
+                    ast3.Attribute(
+                        value=self.sync(
+                            ast3.Name(id=Con.JAC_FEATURE.value, ctx=ast3.Load())
+                        ),
+                        attr=node.arch_type.value.capitalize(),
+                        ctx=ast3.Load(),
+                    )
+                )
+            )
         if node.is_abstract:
             self.needs_jac_feature()
             base_classes.append(
@@ -1091,7 +1094,7 @@ class PyastGenPass(Pass):
                                 value=(
                                     node.signature.semstr.lit_value
                                     if node.signature.semstr
-                                    else None
+                                    else ""
                                 )
                             )
                         )
@@ -1333,7 +1336,7 @@ class PyastGenPass(Pass):
         """
         params = (
             [self.sync(ast3.arg(arg="self", annotation=None))]
-            if node in self.method_sigs and not node.is_static
+            if node.is_method and not node.is_static
             else []
         )
         vararg = None
@@ -1391,7 +1394,7 @@ class PyastGenPass(Pass):
                     posonlyargs=[],
                     args=(
                         [self.sync(ast3.arg(arg="self", annotation=None)), here]
-                        if node in self.method_sigs
+                        if node.is_method
                         else [here]
                     ),
                     kwonlyargs=[],
@@ -1409,27 +1412,19 @@ class PyastGenPass(Pass):
         name_ref: NameType,
         arch: Token,
         """
-        if node.arch.name == Tok.TYPE_OP:
+        if node.arch_type.name == Tok.TYPE_OP:
             if (
-                isinstance(node.name_ref, ast.SpecialVarRef)
-                and node.name_ref.var.name == Tok.KW_ROOT
+                isinstance(node.arch_name, ast.SpecialVarRef)
+                and node.arch_name.orig.name == Tok.KW_ROOT
             ):
                 node.gen.py_ast = [
                     self.sync(
-                        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(),
-                                )
+                        ast3.Attribute(
+                            value=self.sync(
+                                ast3.Name(id=Con.JAC_FEATURE.value, ctx=ast3.Load())
                             ),
-                            args=[],
-                            keywords=[],
+                            attr="RootType",
+                            ctx=ast3.Load(),
                         )
                     )
                 ]
@@ -1439,13 +1434,13 @@ class PyastGenPass(Pass):
                     self.sync(
                         ast3.Attribute(
                             value=self.sync(ast3.Name(id="_jac_typ", ctx=ast3.Load())),
-                            attr=node.name_ref.sym_name,
+                            attr=node.arch_name.sym_name,
                             ctx=ast3.Load(),
                         )
                     )
                 ]
         else:
-            node.gen.py_ast = node.name_ref.gen.py_ast
+            node.gen.py_ast = node.arch_name.gen.py_ast
 
     def exit_arch_ref_chain(self, node: ast.ArchRefChain) -> None:
         """Sub objects.
@@ -1463,7 +1458,7 @@ class PyastGenPass(Pass):
             attr = self.sync(
                 ast3.Attribute(
                     value=make_attr_chain(arch[:-1]),
-                    attr=cur.name_ref.sym_name,
+                    attr=cur.arch_name.sym_name,
                     ctx=ast3.Load(),
                 ),
                 jac_node=cur,
@@ -1881,6 +1876,38 @@ class PyastGenPass(Pass):
             )
         ]
 
+    def exit_check_stmt(self, node: ast.CheckStmt) -> None:
+        """Sub objects.
+
+        target: ExprType,
+        """
+        if isinstance(node.target, ast.FuncCall) and isinstance(
+            node.target.gen.py_ast[0], ast3.Call
+        ):
+            func = node.target.target.gen.py_ast[0]
+            if isinstance(func, ast3.Name):
+                new_func: ast3.expr = self.sync(
+                    ast3.Attribute(
+                        value=self.sync(ast3.Name(id="_jac_check", ctx=ast3.Load())),
+                        attr=func.id,
+                        ctx=ast3.Load(),
+                    )
+                )
+                node.target.gen.py_ast[0].func = new_func
+                node.gen.py_ast = [
+                    self.sync(
+                        ast3.Expr(
+                            value=node.target.gen.py_ast[0],
+                        )
+                    )
+                ]
+                return
+        self.error(
+            "For now, check statements must be function calls "
+            "in the style of assertTrue(), assertEqual(), etc.",
+            node,
+        )
+
     def exit_ctrl_stmt(self, node: ast.CtrlStmt) -> None:
         """Sub objects.
 
@@ -3090,14 +3117,42 @@ class PyastGenPass(Pass):
 
         var: Token,
         """
-        try:
-            var_ast_expr = ast3.parse(node.sym_name).body[0]
-            if not isinstance(var_ast_expr, ast3.Expr):
-                raise self.ice("Invalid special var ref for pyast generation")
-            var_ast = var_ast_expr.value
-        except Exception:
-            raise self.ice("Invalid special var ref for pyast generation")
-        node.gen.py_ast = [self.sync(var_ast, deep=True)]
+        if node.name == Tok.KW_SUPER:
+            node.gen.py_ast = [
+                self.sync(
+                    ast3.Call(
+                        func=self.sync(ast3.Name(id="super", ctx=node.py_ctx_func())),
+                        args=[],
+                        keywords=[],
+                    )
+                )
+            ]
+        elif node.name == Tok.KW_ROOT:
+            node.gen.py_ast = [
+                self.sync(
+                    ast3.Call(
+                        func=self.sync(
+                            ast3.Attribute(
+                                value=self.sync(
+                                    ast3.Name(
+                                        id=Con.JAC_FEATURE.value,
+                                        ctx=ast3.Load(),
+                                    )
+                                ),
+                                attr="get_root",
+                                ctx=ast3.Load(),
+                            )
+                        ),
+                        args=[],
+                        keywords=[],
+                    )
+                )
+            ]
+
+        else:
+            node.gen.py_ast = [
+                self.sync(ast3.Name(id=node.sym_name, ctx=node.py_ctx_func()))
+            ]
 
     def exit_edge_ref_trailer(self, node: ast.EdgeRefTrailer) -> None:
         """Sub objects.
@@ -3577,7 +3632,7 @@ class PyastGenPass(Pass):
                         [
                             x.key.sym_name
                             for x in node.kw_patterns.items
-                            if isinstance(x.key, ast.NameSpec)
+                            if isinstance(x.key, ast.NameAtom)
                         ]
                         if node.kw_patterns
                         else []