jaclang 0.7.18__py3-none-any.whl → 0.7.20__py3-none-any.whl

jaclang/stubs/jaclang/compiler/parser.pyi

@@ -0,0 +1,266 @@
+import jaclang.compiler.absyntree as ast
+from _typeshed import Incomplete
+from jaclang.compiler import jac_lark as jl
+from jaclang.compiler.constant import EdgeDir as EdgeDir
+from jaclang.compiler.passes.ir_pass import Pass as Pass
+from jaclang.vendor.lark import (
+    Lark as Lark,
+    Transformer as Transformer,
+    Tree as Tree,
+    logger as logger,
+)
+from typing import Callable, TypeAlias
+
+class JacParser(Pass):
+    dev_mode: bool
+    source: Incomplete
+    mod_path: Incomplete
+    node_list: Incomplete
+    def __init__(self, input_ir: ast.JacSource) -> None: ...
+    def transform(self, ir: ast.AstNode) -> ast.Module: ...
+    @staticmethod
+    def proc_comment(token: jl.Token, mod: ast.AstNode) -> ast.CommentToken: ...
+    def error_callback(self, e: jl.UnexpectedInput) -> bool: ...
+    @staticmethod
+    def parse(
+        ir: str, on_error: Callable[[jl.UnexpectedInput], bool]
+    ) -> tuple[jl.Tree[jl.Tree[str]], list[jl.Token]]: ...
+    @staticmethod
+    def make_dev() -> None: ...
+    comment_cache: list[jl.Token]
+    parser: Incomplete
+    JacTransformer: TypeAlias
+
+    class TreeToAST(JacTransformer):
+        parse_ref: Incomplete
+        terminals: Incomplete
+        def __init__(self, parser: JacParser, *args: bool, **kwargs: bool) -> None: ...
+        def ice(self) -> Exception: ...
+        def nu(self, node: ast.T) -> ast.T: ...
+        def start(self, kid: list[ast.Module]) -> ast.Module: ...
+        def module(
+            self, kid: list[ast.ElementStmt | ast.String | ast.EmptyToken]
+        ) -> ast.Module: ...
+        def element_with_doc(
+            self, kid: list[ast.ElementStmt | ast.String]
+        ) -> ast.ElementStmt: ...
+        def element(self, kid: list[ast.AstNode]) -> ast.ElementStmt: ...
+        def global_var(self, kid: list[ast.AstNode]) -> ast.GlobalVars: ...
+        def access_tag(self, kid: list[ast.AstNode]) -> ast.SubTag[ast.Token]: ...
+        def test(self, kid: list[ast.AstNode]) -> ast.Test: ...
+        def free_code(self, kid: list[ast.AstNode]) -> ast.ModuleCode: ...
+        def doc_tag(self, kid: list[ast.AstNode]) -> ast.String: ...
+        def py_code_block(self, kid: list[ast.AstNode]) -> ast.PyInlineCode: ...
+        def import_stmt(self, kid: list[ast.AstNode]) -> ast.Import: ...
+        def from_path(self, kid: list[ast.AstNode]) -> ast.ModulePath: ...
+        def include_stmt(self, kid: list[ast.AstNode]) -> ast.Import: ...
+        def import_path(self, kid: list[ast.AstNode]) -> ast.ModulePath: ...
+        def import_items(
+            self, kid: list[ast.AstNode]
+        ) -> ast.SubNodeList[ast.ModuleItem]: ...
+        def import_item(self, kid: list[ast.AstNode]) -> ast.ModuleItem: ...
+        def architype(
+            self, kid: list[ast.AstNode]
+        ) -> ast.ArchSpec | ast.ArchDef | ast.Enum | ast.EnumDef: ...
+        def architype_decl(self, kid: list[ast.AstNode]) -> ast.ArchSpec: ...
+        def architype_def(self, kid: list[ast.AstNode]) -> ast.ArchDef: ...
+        def arch_type(self, kid: list[ast.AstNode]) -> ast.Token: ...
+        def decorators(self, kid: list[ast.AstNode]) -> ast.SubNodeList[ast.Expr]: ...
+        def inherited_archs(
+            self, kid: list[ast.AstNode]
+        ) -> ast.SubNodeList[ast.Expr]: ...
+        def sub_name(self, kid: list[ast.AstNode]) -> ast.SubTag[ast.Name]: ...
+        def named_ref(self, kid: list[ast.AstNode]) -> ast.NameAtom: ...
+        def special_ref(self, kid: list[ast.AstNode]) -> ast.SpecialVarRef: ...
+        def enum(self, kid: list[ast.AstNode]) -> ast.Enum | ast.EnumDef: ...
+        def enum_decl(self, kid: list[ast.AstNode]) -> ast.Enum: ...
+        def enum_def(self, kid: list[ast.AstNode]) -> ast.EnumDef: ...
+        def enum_block(
+            self, kid: list[ast.AstNode]
+        ) -> ast.SubNodeList[ast.EnumBlockStmt]: ...
+        def enum_stmt(self, kid: list[ast.AstNode]) -> ast.EnumBlockStmt: ...
+        def ability(
+            self, kid: list[ast.AstNode]
+        ) -> ast.Ability | ast.AbilityDef | ast.FuncCall: ...
+        def ability_decl(self, kid: list[ast.AstNode]) -> ast.Ability: ...
+        def ability_def(self, kid: list[ast.AstNode]) -> ast.AbilityDef: ...
+        def abstract_ability(self, kid: list[ast.AstNode]) -> ast.Ability: ...
+        def genai_ability(self, kid: list[ast.AstNode]) -> ast.Ability: ...
+        def event_clause(self, kid: list[ast.AstNode]) -> ast.EventSignature: ...
+        def func_decl(self, kid: list[ast.AstNode]) -> ast.FuncSignature: ...
+        def func_decl_params(
+            self, kid: list[ast.AstNode]
+        ) -> ast.SubNodeList[ast.ParamVar]: ...
+        def param_var(self, kid: list[ast.AstNode]) -> ast.ParamVar: ...
+        def member_block(
+            self, kid: list[ast.AstNode]
+        ) -> ast.SubNodeList[ast.ArchBlockStmt]: ...
+        def member_stmt(self, kid: list[ast.AstNode]) -> ast.ArchBlockStmt: ...
+        def has_stmt(self, kid: list[ast.AstNode]) -> ast.ArchHas: ...
+        def has_assign_list(
+            self, kid: list[ast.AstNode]
+        ) -> ast.SubNodeList[ast.HasVar]: ...
+        def typed_has_clause(self, kid: list[ast.AstNode]) -> ast.HasVar: ...
+        def type_tag(self, kid: list[ast.AstNode]) -> ast.SubTag[ast.Expr]: ...
+        def builtin_type(self, kid: list[ast.AstNode]) -> ast.Token: ...
+        def code_block(
+            self, kid: list[ast.AstNode]
+        ) -> ast.SubNodeList[ast.CodeBlockStmt]: ...
+        def statement(self, kid: list[ast.AstNode]) -> ast.CodeBlockStmt: ...
+        def typed_ctx_block(self, kid: list[ast.AstNode]) -> ast.TypedCtxBlock: ...
+        def if_stmt(self, kid: list[ast.AstNode]) -> ast.IfStmt: ...
+        def elif_stmt(self, kid: list[ast.AstNode]) -> ast.ElseIf: ...
+        def else_stmt(self, kid: list[ast.AstNode]) -> ast.ElseStmt: ...
+        def try_stmt(self, kid: list[ast.AstNode]) -> ast.TryStmt: ...
+        def except_list(
+            self, kid: list[ast.AstNode]
+        ) -> ast.SubNodeList[ast.Except]: ...
+        def except_def(self, kid: list[ast.AstNode]) -> ast.Except: ...
+        def finally_stmt(self, kid: list[ast.AstNode]) -> ast.FinallyStmt: ...
+        def for_stmt(
+            self, kid: list[ast.AstNode]
+        ) -> ast.IterForStmt | ast.InForStmt: ...
+        def while_stmt(self, kid: list[ast.AstNode]) -> ast.WhileStmt: ...
+        def with_stmt(self, kid: list[ast.AstNode]) -> ast.WithStmt: ...
+        def expr_as_list(
+            self, kid: list[ast.AstNode]
+        ) -> ast.SubNodeList[ast.ExprAsItem]: ...
+        def expr_as(self, kid: list[ast.AstNode]) -> ast.ExprAsItem: ...
+        def raise_stmt(self, kid: list[ast.AstNode]) -> ast.RaiseStmt: ...
+        def assert_stmt(self, kid: list[ast.AstNode]) -> ast.AssertStmt: ...
+        def check_stmt(self, kid: list[ast.AstNode]) -> ast.CheckStmt: ...
+        def ctrl_stmt(self, kid: list[ast.AstNode]) -> ast.CtrlStmt: ...
+        def delete_stmt(self, kid: list[ast.AstNode]) -> ast.DeleteStmt: ...
+        def report_stmt(self, kid: list[ast.AstNode]) -> ast.ReportStmt: ...
+        def return_stmt(self, kid: list[ast.AstNode]) -> ast.ReturnStmt: ...
+        def walker_stmt(self, kid: list[ast.AstNode]) -> ast.CodeBlockStmt: ...
+        def ignore_stmt(self, kid: list[ast.AstNode]) -> ast.IgnoreStmt: ...
+        def visit_stmt(self, kid: list[ast.AstNode]) -> ast.VisitStmt: ...
+        def revisit_stmt(self, kid: list[ast.AstNode]) -> ast.RevisitStmt: ...
+        def disengage_stmt(self, kid: list[ast.AstNode]) -> ast.DisengageStmt: ...
+        def global_ref(self, kid: list[ast.AstNode]) -> ast.GlobalStmt: ...
+        def nonlocal_ref(self, kid: list[ast.AstNode]) -> ast.NonLocalStmt: ...
+        def assignment(self, kid: list[ast.AstNode]) -> ast.Assignment: ...
+        def expression(self, kid: list[ast.AstNode]) -> ast.Expr: ...
+        def walrus_assign(self, kid: list[ast.AstNode]) -> ast.Expr: ...
+        def binary_expr_unwind(self, kid: list[ast.AstNode]) -> ast.Expr: ...
+        def lambda_expr(self, kid: list[ast.AstNode]) -> ast.LambdaExpr: ...
+        def pipe(self, kid: list[ast.AstNode]) -> ast.Expr: ...
+        def pipe_back(self, kid: list[ast.AstNode]) -> ast.Expr: ...
+        def elvis_check(self, kid: list[ast.AstNode]) -> ast.Expr: ...
+        def bitwise_or(self, kid: list[ast.AstNode]) -> ast.Expr: ...
+        def bitwise_xor(self, kid: list[ast.AstNode]) -> ast.Expr: ...
+        def bitwise_and(self, kid: list[ast.AstNode]) -> ast.Expr: ...
+        def shift(self, kid: list[ast.AstNode]) -> ast.Expr: ...
+        def logical_or(self, kid: list[ast.AstNode]) -> ast.Expr: ...
+        def logical_and(self, kid: list[ast.AstNode]) -> ast.Expr: ...
+        def logical_not(self, kid: list[ast.AstNode]) -> ast.Expr: ...
+        def compare(self, kid: list[ast.AstNode]) -> ast.Expr: ...
+        def cmp_op(self, kid: list[ast.AstNode]) -> ast.Token: ...
+        def arithmetic(self, kid: list[ast.AstNode]) -> ast.Expr: ...
+        def term(self, kid: list[ast.AstNode]) -> ast.Expr: ...
+        def factor(self, kid: list[ast.AstNode]) -> ast.Expr: ...
+        def power(self, kid: list[ast.AstNode]) -> ast.Expr: ...
+        def connect(self, kid: list[ast.AstNode]) -> ast.Expr: ...
+        def atomic_pipe(self, kid: list[ast.AstNode]) -> ast.Expr: ...
+        def atomic_pipe_back(self, kid: list[ast.AstNode]) -> ast.Expr: ...
+        def ds_spawn(self, kid: list[ast.AstNode]) -> ast.Expr: ...
+        def unpack(self, kid: list[ast.AstNode]) -> ast.Expr: ...
+        def ref(self, kid: list[ast.AstNode]) -> ast.Expr: ...
+        def pipe_call(self, kid: list[ast.AstNode]) -> ast.Expr: ...
+        def aug_op(self, kid: list[ast.AstNode]) -> ast.Token: ...
+        def atomic_chain(self, kid: list[ast.AstNode]) -> ast.Expr: ...
+        def atomic_call(self, kid: list[ast.AstNode]) -> ast.FuncCall: ...
+        def index_slice(self, kid: list[ast.AstNode]) -> ast.IndexSlice: ...
+        def atom(self, kid: list[ast.AstNode]) -> ast.Expr: ...
+        def yield_expr(self, kid: list[ast.AstNode]) -> ast.YieldExpr: ...
+        def atom_literal(self, kid: list[ast.AstNode]) -> ast.AtomExpr: ...
+        def atom_collection(self, kid: list[ast.AstNode]) -> ast.AtomExpr: ...
+        def multistring(self, kid: list[ast.AstNode]) -> ast.AtomExpr: ...
+        def fstring(self, kid: list[ast.AstNode]) -> ast.FString: ...
+        def fstr_parts(
+            self, kid: list[ast.AstNode]
+        ) -> ast.SubNodeList[ast.String | ast.ExprStmt]: ...
+        def fstr_sq_parts(
+            self, kid: list[ast.AstNode]
+        ) -> ast.SubNodeList[ast.String | ast.ExprStmt]: ...
+        def list_val(self, kid: list[ast.AstNode]) -> ast.ListVal: ...
+        def tuple_val(self, kid: list[ast.AstNode]) -> ast.TupleVal: ...
+        def set_val(self, kid: list[ast.AstNode]) -> ast.SetVal: ...
+        def expr_list(self, kid: list[ast.AstNode]) -> ast.SubNodeList[ast.Expr]: ...
+        def kw_expr_list(
+            self, kid: list[ast.AstNode]
+        ) -> ast.SubNodeList[ast.KWPair]: ...
+        def kw_expr(self, kid: list[ast.AstNode]) -> ast.KWPair: ...
+        def name_list(self, kid: list[ast.AstNode]) -> ast.SubNodeList[ast.Name]: ...
+        def tuple_list(
+            self, kid: list[ast.AstNode]
+        ) -> ast.SubNodeList[ast.Expr | ast.KWPair]: ...
+        def dict_val(self, kid: list[ast.AstNode]) -> ast.DictVal: ...
+        def kv_pair(self, kid: list[ast.AstNode]) -> ast.KVPair: ...
+        def list_compr(self, kid: list[ast.AstNode]) -> ast.ListCompr: ...
+        def gen_compr(self, kid: list[ast.AstNode]) -> ast.GenCompr: ...
+        def set_compr(self, kid: list[ast.AstNode]) -> ast.SetCompr: ...
+        def dict_compr(self, kid: list[ast.AstNode]) -> ast.DictCompr: ...
+        def inner_compr(self, kid: list[ast.AstNode]) -> ast.InnerCompr: ...
+        def param_list(
+            self, kid: list[ast.AstNode]
+        ) -> ast.SubNodeList[ast.Expr | ast.KWPair]: ...
+        def assignment_list(
+            self, kid: list[ast.AstNode]
+        ) -> ast.SubNodeList[ast.Assignment]: ...
+        def arch_ref(self, kid: list[ast.AstNode]) -> ast.ArchRef: ...
+        def node_ref(self, kid: list[ast.AstNode]) -> ast.ArchRef: ...
+        def edge_ref(self, kid: list[ast.AstNode]) -> ast.ArchRef: ...
+        def walker_ref(self, kid: list[ast.AstNode]) -> ast.ArchRef: ...
+        def class_ref(self, kid: list[ast.AstNode]) -> ast.ArchRef: ...
+        def object_ref(self, kid: list[ast.AstNode]) -> ast.ArchRef: ...
+        def type_ref(self, kid: list[ast.AstNode]) -> ast.ArchRef: ...
+        def enum_ref(self, kid: list[ast.AstNode]) -> ast.ArchRef: ...
+        def ability_ref(self, kid: list[ast.AstNode]) -> ast.ArchRef: ...
+        def arch_or_ability_chain(self, kid: list[ast.AstNode]) -> ast.ArchRefChain: ...
+        def abil_to_arch_chain(self, kid: list[ast.AstNode]) -> ast.ArchRefChain: ...
+        def arch_to_abil_chain(self, kid: list[ast.AstNode]) -> ast.ArchRefChain: ...
+        def arch_to_enum_chain(self, kid: list[ast.AstNode]) -> ast.ArchRefChain: ...
+        def edge_ref_chain(self, kid: list[ast.AstNode]) -> ast.EdgeRefTrailer: ...
+        def edge_op_ref(self, kid: list[ast.AstNode]) -> ast.EdgeOpRef: ...
+        def edge_to(self, kid: list[ast.AstNode]) -> ast.EdgeOpRef: ...
+        def edge_from(self, kid: list[ast.AstNode]) -> ast.EdgeOpRef: ...
+        def edge_any(self, kid: list[ast.AstNode]) -> ast.EdgeOpRef: ...
+        def connect_op(self, kid: list[ast.AstNode]) -> ast.ConnectOp: ...
+        def disconnect_op(self, kid: list[ast.AstNode]) -> ast.DisconnectOp: ...
+        def connect_to(self, kid: list[ast.AstNode]) -> ast.ConnectOp: ...
+        def connect_from(self, kid: list[ast.AstNode]) -> ast.ConnectOp: ...
+        def connect_any(self, kid: list[ast.AstNode]) -> ast.ConnectOp: ...
+        def filter_compr(self, kid: list[ast.AstNode]) -> ast.FilterCompr: ...
+        def filter_compare_list(
+            self, kid: list[ast.AstNode]
+        ) -> ast.SubNodeList[ast.CompareExpr]: ...
+        def typed_filter_compare_list(
+            self, kid: list[ast.AstNode]
+        ) -> ast.FilterCompr: ...
+        def filter_compare_item(self, kid: list[ast.AstNode]) -> ast.CompareExpr: ...
+        def assign_compr(self, kid: list[ast.AstNode]) -> ast.AssignCompr: ...
+        def match_stmt(self, kid: list[ast.AstNode]) -> ast.MatchStmt: ...
+        def match_case_block(self, kid: list[ast.AstNode]) -> ast.MatchCase: ...
+        def pattern_seq(self, kid: list[ast.AstNode]) -> ast.MatchPattern: ...
+        def or_pattern(self, kid: list[ast.AstNode]) -> ast.MatchPattern: ...
+        def as_pattern(self, kid: list[ast.AstNode]) -> ast.MatchPattern: ...
+        def pattern(self, kid: list[ast.AstNode]) -> ast.MatchPattern: ...
+        def literal_pattern(self, kid: list[ast.AstNode]) -> ast.MatchPattern: ...
+        def singleton_pattern(self, kid: list[ast.AstNode]) -> ast.MatchPattern: ...
+        def capture_pattern(self, kid: list[ast.AstNode]) -> ast.MatchPattern: ...
+        def sequence_pattern(self, kid: list[ast.AstNode]) -> ast.MatchPattern: ...
+        def mapping_pattern(self, kid: list[ast.AstNode]) -> ast.MatchMapping: ...
+        def list_inner_pattern(self, kid: list[ast.AstNode]) -> ast.MatchPattern: ...
+        def dict_inner_pattern(
+            self, kid: list[ast.AstNode]
+        ) -> ast.MatchKVPair | ast.MatchStar: ...
+        def class_pattern(self, kid: list[ast.AstNode]) -> ast.MatchArch: ...
+        def pattern_list(
+            self, kid: list[ast.AstNode]
+        ) -> ast.SubNodeList[ast.MatchPattern]: ...
+        def kw_pattern_list(
+            self, kid: list[ast.AstNode]
+        ) -> ast.SubNodeList[ast.MatchKVPair]: ...
+        def __default_token__(self, token: jl.Token) -> ast.Token: ...

jaclang/stubs/jaclang/compiler/passes/__init__.pyi

@@ -0,0 +1,3 @@
+from .ir_pass import Pass as Pass
+
+__all__ = ["Pass"]

jaclang/stubs/jaclang/compiler/passes/ir_pass.pyi

@@ -0,0 +1,40 @@
+import jaclang.compiler.absyntree as ast
+from _typeshed import Incomplete
+from jaclang.compiler.passes.transform import Transform as Transform
+from jaclang.settings import settings as settings
+from jaclang.utils.helpers import pascal_to_snake as pascal_to_snake
+from typing import TypeVar
+
+T = TypeVar("T", bound=ast.AstNode)
+
+class Pass(Transform[T]):
+    term_signal: bool
+    prune_signal: bool
+    ir: Incomplete
+    time_taken: float
+    def __init__(self, input_ir: T, prior: Transform | None) -> None: ...
+    def before_pass(self) -> None: ...
+    def after_pass(self) -> None: ...
+    def enter_node(self, node: ast.AstNode) -> None: ...
+    def exit_node(self, node: ast.AstNode) -> None: ...
+    def terminate(self) -> None: ...
+    def prune(self) -> None: ...
+    @staticmethod
+    def get_all_sub_nodes(
+        node: ast.AstNode, typ: type[T], brute_force: bool = False
+    ) -> list[T]: ...
+    @staticmethod
+    def has_parent_of_type(node: ast.AstNode, typ: type[T]) -> T | None: ...
+    @staticmethod
+    def has_parent_of_node(node: ast.AstNode, parent: ast.AstNode) -> bool: ...
+    def recalculate_parents(self, node: ast.AstNode) -> None: ...
+    def transform(self, ir: T) -> ast.AstNode: ...
+    cur_node: Incomplete
+    def traverse(self, node: ast.AstNode) -> ast.AstNode: ...
+    def error(self, msg: str, node_override: ast.AstNode | None = None) -> None: ...
+    def warning(self, msg: str, node_override: ast.AstNode | None = None) -> None: ...
+    def ice(self, msg: str = "Something went horribly wrong!") -> RuntimeError: ...
+
+class PrinterPass(Pass):
+    def enter_node(self, node: ast.AstNode) -> None: ...
+    def exit_node(self, node: ast.AstNode) -> None: ...

jaclang/stubs/jaclang/compiler/passes/main/__init__.pyi

@@ -0,0 +1,27 @@
+from .def_impl_match_pass import DeclImplMatchPass as DeclImplMatchPass
+from .def_use_pass import DefUsePass as DefUsePass
+from .import_pass import JacImportPass as JacImportPass, PyImportPass as PyImportPass
+from .pyast_gen_pass import PyastGenPass as PyastGenPass
+from .pyast_load_pass import PyastBuildPass as PyastBuildPass
+from .pyout_pass import PyOutPass as PyOutPass
+from .registry_pass import RegistryPass as RegistryPass
+from .schedules import py_code_gen
+from .sub_node_tab_pass import SubNodeTabPass as SubNodeTabPass
+from .sym_tab_build_pass import SymTabBuildPass as SymTabBuildPass
+from .type_check_pass import JacTypeCheckPass as JacTypeCheckPass
+
+__all__ = [
+    "SubNodeTabPass",
+    "JacImportPass",
+    "PyImportPass",
+    "SymTabBuildPass",
+    "DeclImplMatchPass",
+    "DefUsePass",
+    "PyOutPass",
+    "PyastBuildPass",
+    "PyastGenPass",
+    "JacTypeCheckPass",
+    "RegistryPass",
+]
+
+pass_schedule = py_code_gen

jaclang/stubs/jaclang/compiler/passes/main/access_modifier_pass.pyi

@@ -0,0 +1,23 @@
+import jaclang.compiler.absyntree as ast
+from jaclang.compiler.constant import SymbolAccess as SymbolAccess
+from jaclang.compiler.passes import Pass as Pass
+from jaclang.compiler.symtable import SymbolTable as SymbolTable
+from jaclang.settings import settings as settings
+
+class AccessCheckPass(Pass):
+    def after_pass(self) -> None: ...
+    def exit_node(self, node: ast.AstNode) -> None: ...
+    def access_check(self, node: ast.Name) -> None: ...
+    def access_register(
+        self, node: ast.AstSymbolNode, acc_tag: SymbolAccess | None = None
+    ) -> None: ...
+    def enter_global_vars(self, node: ast.GlobalVars) -> None: ...
+    def enter_module(self, node: ast.Module) -> None: ...
+    def enter_architype(self, node: ast.Architype) -> None: ...
+    def enter_enum(self, node: ast.Enum) -> None: ...
+    def enter_ability(self, node: ast.Ability) -> None: ...
+    def enter_sub_node_list(self, node: ast.SubNodeList) -> None: ...
+    def enter_arch_has(self, node: ast.ArchHas) -> None: ...
+    def enter_atom_trailer(self, node: ast.AtomTrailer) -> None: ...
+    def enter_func_call(self, node: ast.FuncCall) -> None: ...
+    def enter_name(self, node: ast.Name) -> None: ...

jaclang/stubs/jaclang/compiler/passes/main/def_impl_match_pass.pyi

@@ -0,0 +1,12 @@
+import jaclang.compiler.absyntree as ast
+from _typeshed import Incomplete
+from jaclang.compiler.passes import Pass as Pass
+from jaclang.compiler.passes.main import SubNodeTabPass as SubNodeTabPass
+from jaclang.compiler.symtable import Symbol as Symbol, SymbolTable as SymbolTable
+
+class DeclImplMatchPass(Pass):
+    def enter_module(self, node: ast.Module) -> None: ...
+    ir: Incomplete
+    def after_pass(self) -> None: ...
+    def defn_lookup(self, lookup: Symbol) -> ast.NameAtom | None: ...
+    def connect_def_impl(self, sym_tab: SymbolTable) -> None: ...

jaclang/stubs/jaclang/compiler/passes/main/def_use_pass.pyi

@@ -0,0 +1,31 @@
+import jaclang.compiler.absyntree as ast
+from jaclang.compiler.passes import Pass as Pass
+
+class DefUsePass(Pass):
+    def after_pass(self) -> None: ...
+    def enter_architype(self, node: ast.Architype) -> None: ...
+    def enter_enum(self, node: ast.Enum) -> None: ...
+    def enter_arch_ref(self, node: ast.ArchRef) -> None: ...
+    def enter_arch_ref_chain(self, node: ast.ArchRefChain) -> None: ...
+    def enter_param_var(self, node: ast.ParamVar) -> None: ...
+    def enter_has_var(self, node: ast.HasVar) -> None: ...
+    def enter_assignment(self, node: ast.Assignment) -> None: ...
+    def enter_inner_compr(self, node: ast.InnerCompr) -> None: ...
+    def enter_atom_trailer(self, node: ast.AtomTrailer) -> None: ...
+    def enter_func_call(self, node: ast.FuncCall) -> None: ...
+    def enter_index_slice(self, node: ast.IndexSlice) -> None: ...
+    def enter_special_var_ref(self, node: ast.SpecialVarRef) -> None: ...
+    def enter_edge_op_ref(self, node: ast.EdgeOpRef) -> None: ...
+    def enter_disconnect_op(self, node: ast.DisconnectOp) -> None: ...
+    def enter_connect_op(self, node: ast.ConnectOp) -> None: ...
+    def enter_filter_compr(self, node: ast.FilterCompr) -> None: ...
+    def enter_token(self, node: ast.Token) -> None: ...
+    def enter_float(self, node: ast.Float) -> None: ...
+    def enter_int(self, node: ast.Int) -> None: ...
+    def enter_string(self, node: ast.String) -> None: ...
+    def enter_bool(self, node: ast.Bool) -> None: ...
+    def enter_builtin_type(self, node: ast.BuiltinType) -> None: ...
+    def enter_name(self, node: ast.Name) -> None: ...
+    def enter_in_for_stmt(self, node: ast.InForStmt) -> None: ...
+    def enter_delete_stmt(self, node: ast.DeleteStmt) -> None: ...
+    def enter_expr_as_item(self, node: ast.ExprAsItem) -> None: ...

jaclang/stubs/jaclang/compiler/passes/main/fuse_typeinfo_pass.pyi

@@ -0,0 +1,66 @@
+import jaclang.compiler.absyntree as ast
+import mypy.nodes as MypyNodes
+import mypy.types as MypyTypes
+from jaclang.compiler.passes import Pass as Pass
+from jaclang.compiler.symtable import SymbolTable as SymbolTable
+from jaclang.settings import settings as settings
+from jaclang.utils.helpers import pascal_to_snake as pascal_to_snake
+from jaclang.vendor.mypy.nodes import Node as VNode
+from mypy.checkexpr import Type as MyType
+from typing import TypeVar
+
+T = TypeVar("T", bound=ast.AstSymbolNode)
+
+class FuseTypeInfoPass(Pass):
+    node_type_hash: dict[MypyNodes.Node | VNode, MyType]
+    def enter_name(self, node: ast.NameAtom) -> None: ...
+    def enter_module_path(self, node: ast.ModulePath) -> None: ...
+    def enter_module_item(self, node: ast.ModuleItem) -> None: ...
+    def enter_architype(self, node: ast.Architype) -> None: ...
+    def enter_arch_def(self, node: ast.ArchDef) -> None: ...
+    def enter_enum(self, node: ast.Enum) -> None: ...
+    def enter_enum_def(self, node: ast.EnumDef) -> None: ...
+    def enter_ability(self, node: ast.Ability) -> None: ...
+    def enter_ability_def(self, node: ast.AbilityDef) -> None: ...
+    def enter_param_var(self, node: ast.ParamVar) -> None: ...
+    def enter_has_var(self, node: ast.HasVar) -> None: ...
+    def exit_has_var(self, node: ast.HasVar) -> None: ...
+    def enter_multi_string(self, node: ast.MultiString) -> None: ...
+    def enter_f_string(self, node: ast.FString) -> None: ...
+    def enter_list_val(self, node: ast.ListVal) -> None: ...
+    def enter_set_val(self, node: ast.SetVal) -> None: ...
+    def enter_tuple_val(self, node: ast.TupleVal) -> None: ...
+    def enter_dict_val(self, node: ast.DictVal) -> None: ...
+    def enter_list_compr(self, node: ast.ListCompr) -> None: ...
+    def enter_dict_compr(self, node: ast.DictCompr) -> None: ...
+    def enter_index_slice(self, node: ast.IndexSlice) -> None: ...
+    def enter_arch_ref(self, node: ast.ArchRef) -> None: ...
+    def enter_special_var_ref(self, node: ast.SpecialVarRef) -> None: ...
+    def enter_edge_op_ref(self, node: ast.EdgeOpRef) -> None: ...
+    def enter_filter_compr(self, node: ast.FilterCompr) -> None: ...
+    def enter_assign_compr(self, node: ast.AssignCompr) -> None: ...
+    def enter_int(self, node: ast.Int) -> None: ...
+    def enter_float(self, node: ast.Float) -> None: ...
+    def enter_string(self, node: ast.String) -> None: ...
+    def enter_bool(self, node: ast.Bool) -> None: ...
+    def enter_builtin_type(self, node: ast.BuiltinType) -> None: ...
+    def get_type_from_instance(
+        self, node: ast.AstSymbolNode, mypy_type: MypyTypes.Instance
+    ) -> None: ...
+    def get_type_from_callable_type(
+        self, node: ast.AstSymbolNode, mypy_type: MypyTypes.CallableType
+    ) -> None: ...
+    def get_type_from_overloaded(
+        self, node: ast.AstSymbolNode, mypy_type: MypyTypes.Overloaded
+    ) -> None: ...
+    def get_type_from_none_type(
+        self, node: ast.AstSymbolNode, mypy_type: MypyTypes.NoneType
+    ) -> None: ...
+    def get_type_from_any_type(
+        self, node: ast.AstSymbolNode, mypy_type: MypyTypes.AnyType
+    ) -> None: ...
+    def get_type_from_tuple_type(
+        self, node: ast.AstSymbolNode, mypy_type: MypyTypes.TupleType
+    ) -> None: ...
+    def exit_assignment(self, node: ast.Assignment) -> None: ...
+    def exit_name(self, node: ast.Name) -> None: ...

jaclang/stubs/jaclang/compiler/passes/main/import_pass.pyi

@@ -0,0 +1,34 @@
+import jaclang.compiler.absyntree as ast
+from _typeshed import Incomplete
+from jaclang.compiler.passes import Pass as Pass
+from jaclang.compiler.passes.main import SubNodeTabPass as SubNodeTabPass
+from jaclang.settings import settings as settings
+from jaclang.utils.helpers import is_standard_lib_module as is_standard_lib_module
+from jaclang.utils.log import logging as logging
+
+logger: Incomplete
+
+class JacImportPass(Pass):
+    import_table: Incomplete
+    py_resolve_list: Incomplete
+    def before_pass(self) -> None: ...
+    cur_node: Incomplete
+    run_again: bool
+    def enter_module(self, node: ast.Module) -> None: ...
+    def process_import(self, node: ast.Module, i: ast.ModulePath) -> None: ...
+    def attach_mod_to_node(
+        self, node: ast.ModulePath | ast.ModuleItem, mod: ast.Module | None
+    ) -> None: ...
+    def enter_module_path(self, node: ast.ModulePath) -> None: ...
+    def enter_atom_trailer(self, node: ast.AtomTrailer) -> None: ...
+    def import_jac_module(self, node: ast.ModulePath) -> None: ...
+    def import_jac_mod_from_dir(self, target: str) -> ast.Module | None: ...
+    def import_jac_mod_from_file(self, target: str) -> ast.Module | None: ...
+
+class PyImportPass(JacImportPass):
+    def before_pass(self) -> None: ...
+    run_again: bool
+    def process_import(self, node: ast.Module, i: ast.ModulePath) -> None: ...
+    def import_py_module(
+        self, node: ast.ModulePath, mod_path: str
+    ) -> ast.Module | None: ...