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

jaclang/compiler/passes/main/def_impl_match_pass.py

@@ -9,7 +9,7 @@ body field.
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.passes import Pass
 from jaclang.compiler.passes.main import SubNodeTabPass
-from jaclang.compiler.symtable import Symbol, SymbolTable, SymbolType
+from jaclang.compiler.symtable import Symbol, SymbolTable
 
 
 class DeclImplMatchPass(Pass):
@@ -28,35 +28,42 @@ class DeclImplMatchPass(Pass):
         """Rebuild sub node table."""
         self.ir = SubNodeTabPass(input_ir=self.ir, prior=self).ir
 
-    def defn_lookup(self, lookup: Symbol) -> ast.AstImplNeedingNode | None:
+    def defn_lookup(self, lookup: Symbol) -> ast.NameAtom | None:
         """Lookup a definition in a symbol table."""
         for defn in range(len(lookup.defn)):
             candidate = lookup.defn[len(lookup.defn) - (defn + 1)]
-            if isinstance(candidate, ast.AstImplNeedingNode) and candidate.needs_impl:
+            if (
+                isinstance(candidate.name_of, ast.AstImplNeedingNode)
+                and candidate.name_of.needs_impl
+            ):
                 return candidate
         return None
 
     def connect_def_impl(self, sym_tab: SymbolTable) -> None:
         """Connect Decls and Defs."""
         for sym in sym_tab.tab.values():
-            if sym.sym_type == SymbolType.IMPL:
+            if isinstance(sym.decl.name_of, ast.AstImplOnlyNode):
                 # currently strips the type info from impls
                 arch_refs = [x[3:] for x in sym.sym_name.split(".")]
+                name_of_links: list[ast.NameAtom] = []  # to link archref names to decls
                 lookup = sym_tab.lookup(arch_refs[0])
-                # Below may need to be a while instead of if to skip over local
+                # If below may need to be a while instead of if to skip over local
                 # import name collisions (see test: test_impl_decl_resolution_fix)
-                if lookup and not isinstance(lookup.decl, ast.AstImplNeedingNode):
+                if lookup and not isinstance(
+                    lookup.decl.name_of, ast.AstImplNeedingNode
+                ):
                     lookup = sym_tab.parent.lookup(arch_refs[0])
                 decl_node = (
                     self.defn_lookup(lookup)
                     if len(arch_refs) == 1 and lookup
                     else lookup.defn[-1] if lookup else None
                 )
+                name_of_links.append(decl_node) if decl_node else None
                 for name in arch_refs[1:]:
                     if decl_node:
                         lookup = (
-                            decl_node.sym_tab.lookup(name)
-                            if decl_node.sym_tab
+                            decl_node.name_of.sym_tab.lookup(name, deep=False)
+                            if decl_node.name_of.sym_tab
                             else None
                         )
                         decl_node = (
@@ -64,6 +71,7 @@ class DeclImplMatchPass(Pass):
                             if len(arch_refs) == 1 and lookup
                             else lookup.defn[-1] if lookup else None
                         )
+                        name_of_links.append(decl_node) if decl_node else None
                     else:
                         break
                 if not decl_node:
@@ -74,8 +82,18 @@ class DeclImplMatchPass(Pass):
                         decl_node,
                     )
                     continue
-                decl_node.body = sym.decl  # type: ignore
-                sym.decl.decl_link = decl_node  # type: ignore
-                decl_node.sym_tab.tab = sym.decl.sym_tab.tab  # type: ignore
+                if not isinstance(
+                    valid_decl := decl_node.name_of, ast.AstImplNeedingNode
+                ) or not (valid_decl.sym_tab and sym.decl.name_of.sym_tab):
+                    raise self.ice(
+                        f"Expected AstImplNeedingNode, got {valid_decl.__class__.__name__}. Not possible."
+                    )
+                valid_decl.body = sym.decl.name_of
+                sym.decl.name_of.decl_link = valid_decl
+                for idx, a in enumerate(sym.decl.name_of.target.archs):
+                    a.name_spec.name_of = name_of_links[idx].name_of
+                    a.name_spec.sym = name_of_links[idx].sym
+                sym.decl.name_of.sym_tab.tab.update(valid_decl.sym_tab.tab)
+                valid_decl.sym_tab.tab = sym.decl.name_of.sym_tab.tab
         for i in sym_tab.kid:
             self.connect_def_impl(i)

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(
@@ -129,9 +129,11 @@ class FuseTypeInfoPass(Pass):
         if isinstance(mypy_node, MypyNodes.MemberExpr):
             if mypy_node in self.node_type_hash:
                 t = str(self.node_type_hash[mypy_node])
-                if "->" in t:
+                if "def" in t and "->" in t:
                     t = t.split("->")[1].strip()
-                node.sym_info.typ = t
+                elif "def" in t:
+                    t = "None"
+                node.name_spec.sym_type = t
             else:
                 self.__debug_print(f"{node.loc} MemberExpr type is not found")
 
@@ -143,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(
@@ -162,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)
@@ -177,10 +179,22 @@ 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)
 
+        # Assign correct symbols to sym_link in case of
+        # AtomTrailer Object
+        if isinstance(node.parent, ast.AtomTrailer):
+            target_node = node.parent.target
+            if isinstance(target_node, ast.AstSymbolNode):
+                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.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:
         """Pass handler for ModulePath nodes."""
@@ -263,10 +277,15 @@ class FuseTypeInfoPass(Pass):
                 "Getting type of 'HasVar' is only supported with AssignmentStmt"
             )
 
+    def exit_has_var(self, node: ast.HasVar) -> None:
+        """Pass handler for HasVar nodes."""
+        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:
@@ -278,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:
@@ -331,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]
@@ -365,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:
@@ -391,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(
@@ -410,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

@@ -63,6 +63,8 @@ class JacImportPass(Pass):
 
     def __annex_impl(self, node: ast.Module) -> None:
         """Annex impl and test modules."""
+        if node.stub_only:
+            return
         if not node.loc.mod_path:
             self.error("Module has no path")
         if not node.loc.mod_path.endswith(".jac"):
@@ -105,7 +107,7 @@ class JacImportPass(Pass):
             ) and cur_file.endswith(".test.jac"):
                 mod = self.import_jac_mod_from_file(cur_file)
                 if mod:
-                    node.test_mod = mod
+                    node.test_mod.append(mod)
                     node.add_kids_right([mod], pos_update=False)
                     mod.parent = node
 
@@ -167,6 +169,7 @@ class JacImportPass(Pass):
                 doc=None,
                 body=[],
                 is_imported=False,
+                stub_only=True,
                 kid=[ast.EmptyToken()],
             )
 
@@ -201,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