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

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

@@ -0,0 +1,178 @@
+import ast as ast3
+import jaclang.compiler.absyntree as ast
+from _typeshed import Incomplete
+from jaclang.compiler.constant import EdgeDir as EdgeDir
+from jaclang.compiler.passes import Pass as Pass
+from jaclang.runtimelib.utils import (
+    extract_params as extract_params,
+    extract_type as extract_type,
+    get_sem_scope as get_sem_scope,
+)
+from typing import Sequence, TypeVar
+
+T = TypeVar("T", bound=ast3.AST)
+
+class PyastGenPass(Pass):
+    debuginfo: Incomplete
+    already_added: Incomplete
+    preamble: Incomplete
+    def before_pass(self) -> None: ...
+    def enter_node(self, node: ast.AstNode) -> None: ...
+    def exit_node(self, node: ast.AstNode) -> None: ...
+    def needs_jac_import(self) -> None: ...
+    def needs_typing(self) -> None: ...
+    def needs_abc(self) -> None: ...
+    def needs_enum(self) -> None: ...
+    def needs_jac_feature(self) -> None: ...
+    def needs_dataclass(self) -> None: ...
+    def needs_dataclass_field(self) -> None: ...
+    def flatten(self, body: list[T | list[T] | None]) -> list[T]: ...
+    def sync(
+        self, py_node: T, jac_node: ast.AstNode | None = None, deep: bool = False
+    ) -> T: ...
+    def pyinline_sync(self, py_nodes: list[ast3.AST]) -> list[ast3.AST]: ...
+    def resolve_stmt_block(
+        self,
+        node: (
+            ast.SubNodeList[ast.CodeBlockStmt]
+            | ast.SubNodeList[ast.ArchBlockStmt]
+            | ast.SubNodeList[ast.EnumBlockStmt]
+            | None
+        ),
+        doc: ast.String | None = None,
+    ) -> list[ast3.AST]: ...
+    def sync_many(self, py_nodes: list[T], jac_node: ast.AstNode) -> list[T]: ...
+    def list_to_attrib(
+        self, attribute_list: list[str], sync_node_list: Sequence[ast.AstNode]
+    ) -> ast3.AST: ...
+    def exit_sub_tag(self, node: ast.SubTag[ast.T]) -> None: ...
+    def exit_sub_node_list(self, node: ast.SubNodeList[ast.T]) -> None: ...
+    def exit_module(self, node: ast.Module) -> None: ...
+    def exit_global_vars(self, node: ast.GlobalVars) -> None: ...
+    def exit_test(self, node: ast.Test) -> None: ...
+    def exit_module_code(self, node: ast.ModuleCode) -> None: ...
+    def exit_py_inline_code(self, node: ast.PyInlineCode) -> None: ...
+    def exit_import(self, node: ast.Import) -> None: ...
+    def exit_module_path(self, node: ast.ModulePath) -> None: ...
+    def exit_module_item(self, node: ast.ModuleItem) -> None: ...
+    def enter_architype(self, node: ast.Architype) -> None: ...
+    def exit_architype(self, node: ast.Architype) -> None: ...
+    def collect_events(
+        self, node: ast.Architype
+    ) -> tuple[list[ast3.AST], list[ast3.AST]]: ...
+    def exit_arch_def(self, node: ast.ArchDef) -> None: ...
+    def enter_enum(self, node: ast.Enum) -> None: ...
+    def exit_enum(self, node: ast.Enum) -> None: ...
+    def exit_enum_def(self, node: ast.EnumDef) -> None: ...
+    def enter_ability(self, node: ast.Ability) -> None: ...
+    def exit_ability(self, node: ast.Ability) -> None: ...
+    def gen_llm_body(self, node: ast.Ability) -> list[ast3.AST]: ...
+    def by_llm_call(
+        self,
+        model: ast3.AST,
+        model_params: dict[str, ast.Expr],
+        scope: ast3.AST,
+        inputs: Sequence[ast3.AST | None],
+        outputs: Sequence[ast3.AST | None] | ast3.Call,
+        action: ast3.AST | None,
+        include_info: list[tuple[str, ast3.AST]],
+        exclude_info: list[tuple[str, ast3.AST]],
+    ) -> ast3.Call: ...
+    def exit_ability_def(self, node: ast.AbilityDef) -> None: ...
+    def exit_func_signature(self, node: ast.FuncSignature) -> None: ...
+    def exit_event_signature(self, node: ast.EventSignature) -> None: ...
+    def exit_arch_ref(self, node: ast.ArchRef) -> None: ...
+    def exit_arch_ref_chain(self, node: ast.ArchRefChain) -> None: ...
+    def exit_param_var(self, node: ast.ParamVar) -> None: ...
+    def exit_arch_has(self, node: ast.ArchHas) -> None: ...
+    def exit_has_var(self, node: ast.HasVar) -> None: ...
+    def exit_typed_ctx_block(self, node: ast.TypedCtxBlock) -> None: ...
+    def exit_if_stmt(self, node: ast.IfStmt) -> None: ...
+    def exit_else_if(self, node: ast.ElseIf) -> None: ...
+    def exit_else_stmt(self, node: ast.ElseStmt) -> None: ...
+    def exit_expr_stmt(self, node: ast.ExprStmt) -> None: ...
+    def exit_try_stmt(self, node: ast.TryStmt) -> None: ...
+    def exit_except(self, node: ast.Except) -> None: ...
+    def exit_finally_stmt(self, node: ast.FinallyStmt) -> None: ...
+    def exit_iter_for_stmt(self, node: ast.IterForStmt) -> None: ...
+    def exit_in_for_stmt(self, node: ast.InForStmt) -> None: ...
+    def exit_while_stmt(self, node: ast.WhileStmt) -> None: ...
+    def exit_with_stmt(self, node: ast.WithStmt) -> None: ...
+    def exit_expr_as_item(self, node: ast.ExprAsItem) -> None: ...
+    def exit_raise_stmt(self, node: ast.RaiseStmt) -> None: ...
+    def exit_assert_stmt(self, node: ast.AssertStmt) -> None: ...
+    def exit_check_stmt(self, node: ast.CheckStmt) -> None: ...
+    def exit_ctrl_stmt(self, node: ast.CtrlStmt) -> None: ...
+    def exit_delete_stmt(self, node: ast.DeleteStmt) -> None: ...
+    def exit_report_stmt(self, node: ast.ReportStmt) -> None: ...
+    def exit_return_stmt(self, node: ast.ReturnStmt) -> None: ...
+    def exit_yield_expr(self, node: ast.YieldExpr) -> None: ...
+    def exit_ignore_stmt(self, node: ast.IgnoreStmt) -> None: ...
+    def exit_visit_stmt(self, node: ast.VisitStmt) -> None: ...
+    def exit_revisit_stmt(self, node: ast.RevisitStmt) -> None: ...
+    def exit_disengage_stmt(self, node: ast.DisengageStmt) -> None: ...
+    def exit_await_expr(self, node: ast.AwaitExpr) -> None: ...
+    def exit_global_stmt(self, node: ast.GlobalStmt) -> None: ...
+    def exit_non_local_stmt(self, node: ast.NonLocalStmt) -> None: ...
+    def exit_assignment(self, node: ast.Assignment) -> None: ...
+    def exit_binary_expr(self, node: ast.BinaryExpr) -> None: ...
+    def translate_jac_bin_op(self, node: ast.BinaryExpr) -> list[ast3.AST]: ...
+    def exit_compare_expr(self, node: ast.CompareExpr) -> None: ...
+    def exit_bool_expr(self, node: ast.BoolExpr) -> None: ...
+    def exit_lambda_expr(self, node: ast.LambdaExpr) -> None: ...
+    def exit_unary_expr(self, node: ast.UnaryExpr) -> None: ...
+    def exit_if_else_expr(self, node: ast.IfElseExpr) -> None: ...
+    def exit_multi_string(self, node: ast.MultiString) -> None: ...
+    def exit_f_string(self, node: ast.FString) -> None: ...
+    def exit_list_val(self, node: ast.ListVal) -> None: ...
+    def exit_set_val(self, node: ast.SetVal) -> None: ...
+    def exit_tuple_val(self, node: ast.TupleVal) -> None: ...
+    def exit_dict_val(self, node: ast.DictVal) -> None: ...
+    def exit_k_v_pair(self, node: ast.KVPair) -> None: ...
+    def exit_k_w_pair(self, node: ast.KWPair) -> None: ...
+    def exit_inner_compr(self, node: ast.InnerCompr) -> None: ...
+    def exit_list_compr(self, node: ast.ListCompr) -> None: ...
+    def exit_gen_compr(self, node: ast.GenCompr) -> None: ...
+    def exit_set_compr(self, node: ast.SetCompr) -> None: ...
+    def exit_dict_compr(self, node: ast.DictCompr) -> None: ...
+    def exit_atom_trailer(self, node: ast.AtomTrailer) -> None: ...
+    def exit_atom_unit(self, node: ast.AtomUnit) -> None: ...
+    def exit_func_call(self, node: ast.FuncCall) -> None: ...
+    def exit_index_slice(self, node: ast.IndexSlice) -> None: ...
+    def exit_special_var_ref(self, node: ast.SpecialVarRef) -> None: ...
+    def exit_edge_ref_trailer(self, node: ast.EdgeRefTrailer) -> None: ...
+    def exit_edge_op_ref(self, node: ast.EdgeOpRef) -> None: ...
+    def translate_edge_op_ref(
+        self,
+        loc: ast3.AST,
+        node: ast.EdgeOpRef,
+        targ: ast3.AST | None,
+        edges_only: bool,
+    ) -> ast3.AST: ...
+    def exit_disconnect_op(self, node: ast.DisconnectOp) -> None: ...
+    def exit_connect_op(self, node: ast.ConnectOp) -> None: ...
+    def exit_filter_compr(self, node: ast.FilterCompr) -> None: ...
+    def exit_assign_compr(self, node: ast.AssignCompr) -> None: ...
+    def exit_match_stmt(self, node: ast.MatchStmt) -> None: ...
+    def exit_match_case(self, node: ast.MatchCase) -> None: ...
+    def exit_match_or(self, node: ast.MatchOr) -> None: ...
+    def exit_match_as(self, node: ast.MatchAs) -> None: ...
+    def exit_match_wild(self, node: ast.MatchWild) -> None: ...
+    def exit_match_value(self, node: ast.MatchValue) -> None: ...
+    def exit_match_singleton(self, node: ast.MatchSingleton) -> None: ...
+    def exit_match_sequence(self, node: ast.MatchSequence) -> None: ...
+    def exit_match_mapping(self, node: ast.MatchMapping) -> None: ...
+    def exit_match_k_v_pair(self, node: ast.MatchKVPair) -> None: ...
+    def exit_match_star(self, node: ast.MatchStar) -> None: ...
+    def exit_match_arch(self, node: ast.MatchArch) -> None: ...
+    def exit_token(self, node: ast.Token) -> None: ...
+    def exit_name(self, node: ast.Name) -> None: ...
+    def exit_float(self, node: ast.Float) -> None: ...
+    def exit_int(self, node: ast.Int) -> None: ...
+    def exit_string(self, node: ast.String) -> None: ...
+    def exit_bool(self, node: ast.Bool) -> None: ...
+    def exit_builtin_type(self, node: ast.BuiltinType) -> None: ...
+    def exit_null(self, node: ast.Null) -> None: ...
+    def exit_ellipsis(self, node: ast.Ellipsis) -> None: ...
+    def exit_semi(self, node: ast.Semi) -> None: ...
+    def exit_comment_token(self, node: ast.CommentToken) -> None: ...

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

@@ -0,0 +1,135 @@
+import ast as py_ast
+import jaclang.compiler.absyntree as ast
+from _typeshed import Incomplete
+from jaclang.compiler.constant import Tokens as Tok
+from jaclang.compiler.passes.ir_pass import Pass as Pass
+from jaclang.utils.helpers import pascal_to_snake as pascal_to_snake
+from typing import TypeAlias, TypeVar
+
+T = TypeVar("T", bound=ast.AstNode)
+
+class PyastBuildPass(Pass[ast.PythonModuleAst]):
+    mod_path: Incomplete
+    def __init__(self, input_ir: ast.PythonModuleAst) -> None: ...
+    cur_node: Incomplete
+    def nu(self, node: T) -> T: ...
+    def pp(self, node: py_ast.AST) -> None: ...
+    def convert(self, node: py_ast.AST) -> ast.AstNode: ...
+    ir: Incomplete
+    def transform(self, ir: ast.PythonModuleAst) -> ast.Module: ...
+    def extract_with_entry(
+        self, body: list[ast.AstNode], exclude_types: TypeAlias = ...
+    ) -> list[T | ast.ModuleCode]: ...
+    def proc_module(self, node: py_ast.Module) -> ast.Module: ...
+    def proc_function_def(
+        self, node: py_ast.FunctionDef | py_ast.AsyncFunctionDef
+    ) -> ast.Ability: ...
+    def proc_async_function_def(self, node: py_ast.AsyncFunctionDef) -> ast.Ability: ...
+    def proc_class_def(self, node: py_ast.ClassDef) -> ast.Architype | ast.Enum: ...
+    def proc_return(self, node: py_ast.Return) -> ast.ReturnStmt | None: ...
+    def proc_delete(self, node: py_ast.Delete) -> ast.DeleteStmt: ...
+    def proc_assign(self, node: py_ast.Assign) -> ast.Assignment: ...
+    def proc_aug_assign(self, node: py_ast.AugAssign) -> ast.Assignment: ...
+    def proc_ann_assign(self, node: py_ast.AnnAssign) -> ast.Assignment: ...
+    def proc_for(self, node: py_ast.For) -> ast.InForStmt: ...
+    def proc_async_for(self, node: py_ast.AsyncFor) -> ast.InForStmt: ...
+    def proc_while(self, node: py_ast.While) -> ast.WhileStmt: ...
+    def proc_if(self, node: py_ast.If) -> ast.IfStmt: ...
+    def proc_with(self, node: py_ast.With) -> ast.WithStmt: ...
+    def proc_async_with(self, node: py_ast.AsyncWith) -> ast.WithStmt: ...
+    def proc_raise(self, node: py_ast.Raise) -> ast.RaiseStmt: ...
+    def proc_assert(self, node: py_ast.Assert) -> ast.AssertStmt: ...
+    def proc_attribute(self, node: py_ast.Attribute) -> ast.AtomTrailer: ...
+    def proc_await(self, node: py_ast.Await) -> ast.AwaitExpr: ...
+    def proc_bin_op(self, node: py_ast.BinOp) -> ast.AtomUnit: ...
+    def proc_unary_op(self, node: py_ast.UnaryOp) -> ast.UnaryExpr: ...
+    def proc_bool_op(self, node: py_ast.BoolOp) -> ast.BoolExpr: ...
+    def proc_break(self, node: py_ast.Break) -> ast.CtrlStmt: ...
+    def proc_call(self, node: py_ast.Call) -> ast.FuncCall: ...
+    def proc_compare(self, node: py_ast.Compare) -> ast.CompareExpr: ...
+    def proc_constant(self, node: py_ast.Constant) -> ast.Literal: ...
+    def proc_continue(self, node: py_ast.Continue) -> ast.CtrlStmt: ...
+    def proc_dict(self, node: py_ast.Dict) -> ast.DictVal: ...
+    def proc_dict_comp(self, node: py_ast.DictComp) -> ast.DictCompr: ...
+    def proc_ellipsis(self, node: py_ast.Ellipsis) -> None: ...
+    def proc_except_handler(self, node: py_ast.ExceptHandler) -> ast.Except: ...
+    def proc_expr(self, node: py_ast.Expr) -> ast.ExprStmt: ...
+    def proc_formatted_value(self, node: py_ast.FormattedValue) -> ast.ExprStmt: ...
+    def proc_function_type(self, node: py_ast.FunctionType) -> None: ...
+    def proc_generator_exp(self, node: py_ast.GeneratorExp) -> ast.GenCompr: ...
+    def proc_global(self, node: py_ast.Global) -> ast.GlobalStmt: ...
+    def proc_if_exp(self, node: py_ast.IfExp) -> ast.IfElseExpr: ...
+    def proc_import(self, node: py_ast.Import) -> ast.Import: ...
+    def proc_import_from(self, node: py_ast.ImportFrom) -> ast.Import: ...
+    def proc_joined_str(self, node: py_ast.JoinedStr) -> ast.FString: ...
+    def proc_lambda(self, node: py_ast.Lambda) -> ast.LambdaExpr: ...
+    def proc_list(self, node: py_ast.List) -> ast.ListVal: ...
+    def proc_list_comp(self, node: py_ast.ListComp) -> ast.ListCompr: ...
+    def proc_match(self, node: py_ast.Match) -> ast.MatchStmt: ...
+    def proc_match_as(self, node: py_ast.MatchAs) -> ast.MatchAs | ast.MatchWild: ...
+    def proc_match_class(self, node: py_ast.MatchClass) -> ast.MatchArch: ...
+    def proc_match_mapping(self, node: py_ast.MatchMapping) -> ast.MatchMapping: ...
+    def proc_match_or(self, node: py_ast.MatchOr) -> ast.MatchOr: ...
+    def proc_match_sequence(self, node: py_ast.MatchSequence) -> ast.MatchSequence: ...
+    def proc_match_singleton(
+        self, node: py_ast.MatchSingleton
+    ) -> ast.MatchSingleton: ...
+    def proc_match_star(self, node: py_ast.MatchStar) -> ast.MatchStar: ...
+    def proc_match_value(self, node: py_ast.MatchValue) -> ast.MatchValue: ...
+    def proc_name(self, node: py_ast.Name) -> ast.Name: ...
+    def proc_named_expr(self, node: py_ast.NamedExpr) -> ast.BinaryExpr: ...
+    def proc_nonlocal(self, node: py_ast.Nonlocal) -> ast.NonLocalStmt: ...
+    def proc_pass(self, node: py_ast.Pass) -> ast.Semi: ...
+    def proc_set(self, node: py_ast.Set) -> ast.SetVal: ...
+    def proc_set_comp(self, node: py_ast.SetComp) -> ast.ListCompr: ...
+    def proc_slice(self, node: py_ast.Slice) -> ast.IndexSlice: ...
+    def proc_starred(self, node: py_ast.Starred) -> ast.UnaryExpr: ...
+    def proc_subscript(self, node: py_ast.Subscript) -> ast.AtomTrailer: ...
+    def proc_try(self, node: py_ast.Try | py_ast.TryStar) -> ast.TryStmt: ...
+    def proc_try_star(self, node: py_ast.TryStar) -> ast.TryStmt: ...
+    def proc_tuple(self, node: py_ast.Tuple) -> ast.TupleVal: ...
+    def proc_yield(self, node: py_ast.Yield) -> ast.YieldExpr: ...
+    def proc_yield_from(self, node: py_ast.YieldFrom) -> ast.YieldExpr: ...
+    def proc_alias(self, node: py_ast.alias) -> ast.ExprAsItem: ...
+    def proc_arg(self, node: py_ast.arg) -> ast.ParamVar: ...
+    def proc_arguments(self, node: py_ast.arguments) -> ast.FuncSignature: ...
+    def operator(self, tok: Tok, value: str) -> ast.Token: ...
+    def proc_and(self, node: py_ast.And) -> ast.Token: ...
+    def proc_or(self, node: py_ast.Or) -> ast.Token: ...
+    def proc_add(self, node: py_ast.Add) -> ast.Token: ...
+    def proc_bit_and(self, node: py_ast.BitAnd) -> ast.Token: ...
+    def proc_bit_or(self, node: py_ast.BitOr) -> ast.Token: ...
+    def proc_bit_xor(self, node: py_ast.BitXor) -> ast.Token: ...
+    def proc_div(self, node: py_ast.Div) -> ast.Token: ...
+    def proc_floor_div(self, node: py_ast.FloorDiv) -> ast.Token: ...
+    def proc_l_shift(self, node: py_ast.LShift) -> ast.Token: ...
+    def proc_mod(self, node: py_ast.Mod) -> ast.Token: ...
+    def proc_mult(self, node: py_ast.Mult) -> ast.Token: ...
+    def proc_mat_mult(self, node: py_ast.MatMult) -> ast.Token: ...
+    def proc_pow(self, node: py_ast.Pow) -> ast.Token: ...
+    def proc_r_shift(self, node: py_ast.RShift) -> ast.Token: ...
+    def proc_sub(self, node: py_ast.Sub) -> ast.Token: ...
+    def proc_invert(self, node: py_ast.Invert) -> ast.Token: ...
+    def proc_not(self, node: py_ast.Not) -> ast.Token: ...
+    def proc_u_add(self, node: py_ast.UAdd) -> ast.Token: ...
+    def proc_u_sub(self, node: py_ast.USub) -> ast.Token: ...
+    def proc_eq(self, node: py_ast.Eq) -> ast.Token: ...
+    def proc_gt(self, node: py_ast.Gt) -> ast.Token: ...
+    def proc_gt_e(self, node: py_ast.GtE) -> ast.Token: ...
+    def proc_in(self, node: py_ast.In) -> ast.Token: ...
+    def proc_is(self, node: py_ast.Is) -> ast.Token: ...
+    def proc_is_not(self, node: py_ast.IsNot) -> ast.Token: ...
+    def proc_lt(self, node: py_ast.Lt) -> ast.Token: ...
+    def proc_lt_e(self, node: py_ast.LtE) -> ast.Token: ...
+    def proc_not_eq(self, node: py_ast.NotEq) -> ast.Token: ...
+    def proc_not_in(self, node: py_ast.NotIn) -> ast.Token: ...
+    def proc_comprehension(self, node: py_ast.comprehension) -> ast.InnerCompr: ...
+    def proc_keyword(self, node: py_ast.keyword) -> ast.KWPair: ...
+    def proc_match_case(self, node: py_ast.match_case) -> ast.MatchCase: ...
+    def proc_withitem(self, node: py_ast.withitem) -> ast.ExprAsItem: ...
+    def proc_param_spec(self, node: py_ast.ParamSpec) -> None: ...
+    def proc_type_alias(self, node: py_ast.TypeAlias) -> None: ...
+    def proc_type_var(self, node: py_ast.TypeVar) -> None: ...
+    def proc_type_var_tuple(self, node: py_ast.TypeVarTuple) -> None: ...
+    def convert_to_doc(self, string: ast.String) -> None: ...
+    def aug_op_map(self, tok_dict: dict, op: ast.Token) -> str: ...

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

@@ -0,0 +1,6 @@
+import jaclang.compiler.absyntree as ast
+from jaclang.compiler.passes import Pass as Pass
+
+class PyBytecodeGenPass(Pass):
+    def before_pass(self) -> None: ...
+    def enter_module(self, node: ast.Module) -> None: ...

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

@@ -0,0 +1,22 @@
+import ast as ast3
+import jaclang.compiler.absyntree as ast
+from jaclang.compiler.passes import Pass as Pass
+
+class PyJacAstLinkPass(Pass):
+    def link_jac_py_nodes(
+        self, jac_node: ast.AstNode, py_nodes: list[ast3.AST]
+    ) -> None: ...
+    def exit_module_path(self, node: ast.ModulePath) -> None: ...
+    def exit_architype(self, node: ast.Architype) -> None: ...
+    def exit_arch_def(self, node: ast.ArchDef) -> None: ...
+    def exit_enum(self, node: ast.Enum) -> None: ...
+    def exit_enum_def(self, node: ast.EnumDef) -> None: ...
+    def exit_ability(self, node: ast.Ability) -> None: ...
+    def exit_ability_def(self, node: ast.AbilityDef) -> None: ...
+    def exit_param_var(self, node: ast.ParamVar) -> None: ...
+    def exit_except(self, node: ast.Except) -> None: ...
+    def exit_expr_as_item(self, node: ast.ExprAsItem) -> None: ...
+    def exit_global_stmt(self, node: ast.GlobalStmt) -> None: ...
+    def exit_non_local_stmt(self, node: ast.NonLocalStmt) -> None: ...
+    def exit_k_w_pair(self, node: ast.KWPair) -> None: ...
+    def exit_atom_trailer(self, node: ast.AtomTrailer) -> None: ...

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

@@ -0,0 +1,9 @@
+import jaclang.compiler.absyntree as ast
+from jaclang.compiler.passes import Pass as Pass
+
+class PyOutPass(Pass):
+    def before_pass(self) -> None: ...
+    def enter_module(self, node: ast.Module) -> None: ...
+    def gen_python(self, node: ast.Module, out_path: str) -> None: ...
+    def dump_bytecode(self, node: ast.Module, mod_path: str, out_path: str) -> None: ...
+    def get_output_targets(self, node: ast.Module) -> tuple[str, str, str]: ...

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

@@ -0,0 +1,15 @@
+import jaclang.compiler.absyntree as ast
+from jaclang.compiler.passes import Pass as Pass
+from jaclang.compiler.semtable import SemInfo as SemInfo, SemRegistry as SemRegistry
+from jaclang.runtimelib.utils import get_sem_scope as get_sem_scope
+
+class RegistryPass(Pass):
+    modules_visited: list[ast.Module]
+    def enter_module(self, node: ast.Module) -> None: ...
+    def exit_module(self, node: ast.Module) -> None: ...
+    def exit_architype(self, node: ast.Architype) -> None: ...
+    def exit_enum(self, node: ast.Enum) -> None: ...
+    def exit_has_var(self, node: ast.HasVar) -> None: ...
+    def exit_assignment(self, node: ast.Assignment) -> None: ...
+    def exit_name(self, node: ast.Name) -> None: ...
+    def extract_type(self, node: ast.AstNode) -> list[str]: ...

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

@@ -0,0 +1,19 @@
+from .access_modifier_pass import AccessCheckPass as AccessCheckPass
+from .def_impl_match_pass import DeclImplMatchPass as DeclImplMatchPass
+from .def_use_pass import DefUsePass as DefUsePass
+from .fuse_typeinfo_pass import FuseTypeInfoPass as FuseTypeInfoPass
+from .import_pass import JacImportPass as JacImportPass, PyImportPass as PyImportPass
+from .pyast_gen_pass import PyastGenPass as PyastGenPass
+from .pybc_gen_pass import PyBytecodeGenPass as PyBytecodeGenPass
+from .pyjac_ast_link_pass import PyJacAstLinkPass as PyJacAstLinkPass
+from .pyout_pass import PyOutPass as PyOutPass
+from .registry_pass import RegistryPass as RegistryPass
+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
+from _typeshed import Incomplete
+
+py_code_gen: Incomplete
+type_checker_sched: Incomplete
+py_code_gen_typed: Incomplete
+py_compiler: Incomplete

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

@@ -0,0 +1,6 @@
+import jaclang.compiler.absyntree as ast
+from jaclang.compiler.passes import Pass as Pass
+
+class SubNodeTabPass(Pass):
+    def enter_node(self, node: ast.AstNode) -> None: ...
+    def exit_node(self, node: ast.AstNode) -> None: ...

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

@@ -0,0 +1,147 @@
+import jaclang.compiler.absyntree as ast
+from _typeshed import Incomplete
+from jaclang.compiler.passes import Pass as Pass
+from jaclang.compiler.symtable import SymbolTable as SymbolTable
+
+class SymTabBuildPass(Pass):
+    cur_sym_tab: Incomplete
+    def before_pass(self) -> None: ...
+    def push_scope(
+        self, name: str, key_node: ast.AstNode, fresh: bool = False
+    ) -> None: ...
+    def pop_scope(self) -> SymbolTable: ...
+    @property
+    def cur_scope(self) -> SymbolTable: ...
+    def sync_node_to_scope(self, node: ast.AstNode) -> None: ...
+    def enter_module(self, node: ast.Module) -> None: ...
+    def exit_module(self, node: ast.Module) -> None: ...
+    def enter_global_vars(self, node: ast.GlobalVars) -> None: ...
+    def exit_global_vars(self, node: ast.GlobalVars) -> None: ...
+    def enter_sub_tag(self, node: ast.SubTag) -> None: ...
+    def enter_sub_node_list(self, node: ast.SubNodeList) -> None: ...
+    def enter_test(self, node: ast.Test) -> None: ...
+    def exit_test(self, node: ast.Test) -> None: ...
+    def enter_module_code(self, node: ast.ModuleCode) -> None: ...
+    def exit_module_code(self, node: ast.ModuleCode) -> None: ...
+    def enter_py_inline_code(self, node: ast.PyInlineCode) -> None: ...
+    def enter_import(self, node: ast.Import) -> None: ...
+    def exit_import(self, node: ast.Import) -> None: ...
+    def enter_module_path(self, node: ast.ModulePath) -> None: ...
+    def exit_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 exit_architype(self, node: ast.Architype) -> None: ...
+    def enter_arch_def(self, node: ast.ArchDef) -> None: ...
+    def exit_arch_def(self, node: ast.ArchDef) -> None: ...
+    def enter_ability(self, node: ast.Ability) -> None: ...
+    def exit_ability(self, node: ast.Ability) -> None: ...
+    def enter_ability_def(self, node: ast.AbilityDef) -> None: ...
+    def exit_ability_def(self, node: ast.AbilityDef) -> None: ...
+    def enter_event_signature(self, node: ast.EventSignature) -> None: ...
+    def enter_arch_ref_chain(self, node: ast.ArchRefChain) -> None: ...
+    def enter_func_signature(self, node: ast.FuncSignature) -> None: ...
+    def enter_param_var(self, node: ast.ParamVar) -> None: ...
+    def enter_enum(self, node: ast.Enum) -> None: ...
+    def exit_enum(self, node: ast.Enum) -> None: ...
+    def enter_enum_def(self, node: ast.EnumDef) -> None: ...
+    def exit_enum_def(self, node: ast.EnumDef) -> None: ...
+    def enter_arch_has(self, node: ast.ArchHas) -> None: ...
+    def enter_has_var(self, node: ast.HasVar) -> None: ...
+    def enter_typed_ctx_block(self, node: ast.TypedCtxBlock) -> None: ...
+    def exit_typed_ctx_block(self, node: ast.TypedCtxBlock) -> None: ...
+    def enter_if_stmt(self, node: ast.IfStmt) -> None: ...
+    def exit_if_stmt(self, node: ast.IfStmt) -> None: ...
+    def enter_else_if(self, node: ast.ElseIf) -> None: ...
+    def exit_else_if(self, node: ast.ElseIf) -> None: ...
+    def enter_else_stmt(self, node: ast.ElseStmt) -> None: ...
+    def exit_else_stmt(self, node: ast.ElseStmt) -> None: ...
+    def enter_expr_stmt(self, node: ast.ExprStmt) -> None: ...
+    def enter_try_stmt(self, node: ast.TryStmt) -> None: ...
+    def exit_try_stmt(self, node: ast.TryStmt) -> None: ...
+    def enter_except(self, node: ast.Except) -> None: ...
+    def exit_except(self, node: ast.Except) -> None: ...
+    def enter_finally_stmt(self, node: ast.FinallyStmt) -> None: ...
+    def exit_finally_stmt(self, node: ast.FinallyStmt) -> None: ...
+    def enter_iter_for_stmt(self, node: ast.IterForStmt) -> None: ...
+    def exit_iter_for_stmt(self, node: ast.IterForStmt) -> None: ...
+    def enter_in_for_stmt(self, node: ast.InForStmt) -> None: ...
+    def exit_in_for_stmt(self, node: ast.InForStmt) -> None: ...
+    def enter_name(self, node: ast.Name) -> None: ...
+    def enter_while_stmt(self, node: ast.WhileStmt) -> None: ...
+    def exit_while_stmt(self, node: ast.WhileStmt) -> None: ...
+    def enter_with_stmt(self, node: ast.WithStmt) -> None: ...
+    def exit_with_stmt(self, node: ast.WithStmt) -> None: ...
+    def enter_expr_as_item(self, node: ast.ExprAsItem) -> None: ...
+    def enter_raise_stmt(self, node: ast.RaiseStmt) -> None: ...
+    def enter_assert_stmt(self, node: ast.AssertStmt) -> None: ...
+    def enter_check_stmt(self, node: ast.CheckStmt) -> None: ...
+    def enter_ctrl_stmt(self, node: ast.CtrlStmt) -> None: ...
+    def enter_delete_stmt(self, node: ast.DeleteStmt) -> None: ...
+    def enter_report_stmt(self, node: ast.ReportStmt) -> None: ...
+    def enter_return_stmt(self, node: ast.ReturnStmt) -> None: ...
+    def enter_yield_expr(self, node: ast.YieldExpr) -> None: ...
+    def enter_ignore_stmt(self, node: ast.IgnoreStmt) -> None: ...
+    def enter_visit_stmt(self, node: ast.VisitStmt) -> None: ...
+    def enter_revisit_stmt(self, node: ast.RevisitStmt) -> None: ...
+    def enter_disengage_stmt(self, node: ast.DisengageStmt) -> None: ...
+    def enter_await_expr(self, node: ast.AwaitExpr) -> None: ...
+    def enter_global_stmt(self, node: ast.GlobalStmt) -> None: ...
+    def enter_non_local_stmt(self, node: ast.NonLocalStmt) -> None: ...
+    def enter_assignment(self, node: ast.Assignment) -> None: ...
+    def enter_binary_expr(self, node: ast.BinaryExpr) -> None: ...
+    def enter_compare_expr(self, node: ast.CompareExpr) -> None: ...
+    def enter_if_else_expr(self, node: ast.IfElseExpr) -> None: ...
+    def enter_unary_expr(self, node: ast.UnaryExpr) -> None: ...
+    def enter_bool_expr(self, node: ast.BoolExpr) -> None: ...
+    def enter_lambda_expr(self, node: ast.LambdaExpr) -> None: ...
+    def exit_lambda_expr(self, node: ast.LambdaExpr) -> None: ...
+    def enter_multi_string(self, node: ast.MultiString) -> 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_k_v_pair(self, node: ast.KVPair) -> None: ...
+    def enter_k_w_pair(self, node: ast.KWPair) -> None: ...
+    def enter_list_compr(self, node: ast.ListCompr) -> None: ...
+    def enter_gen_compr(self, node: ast.GenCompr) -> None: ...
+    def enter_set_compr(self, node: ast.SetCompr) -> None: ...
+    def enter_inner_compr(self, node: ast.InnerCompr) -> None: ...
+    def exit_inner_compr(self, node: ast.InnerCompr) -> None: ...
+    def enter_dict_compr(self, node: ast.DictCompr) -> None: ...
+    def exit_dict_compr(self, node: ast.DictCompr) -> None: ...
+    def enter_atom_trailer(self, node: ast.AtomTrailer) -> None: ...
+    def enter_atom_unit(self, node: ast.AtomUnit) -> None: ...
+    def enter_func_call(self, node: ast.FuncCall) -> 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_ref_trailer(self, node: ast.EdgeRefTrailer) -> 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_assign_compr(self, node: ast.AssignCompr) -> None: ...
+    def enter_f_string(self, node: ast.FString) -> None: ...
+    def enter_match_stmt(self, node: ast.MatchStmt) -> None: ...
+    def enter_match_case(self, node: ast.MatchCase) -> None: ...
+    def exit_match_case(self, node: ast.MatchCase) -> None: ...
+    def enter_match_or(self, node: ast.MatchOr) -> None: ...
+    def enter_match_as(self, node: ast.MatchAs) -> None: ...
+    def enter_match_wild(self, node: ast.MatchWild) -> None: ...
+    def enter_match_value(self, node: ast.MatchValue) -> None: ...
+    def enter_match_singleton(self, node: ast.MatchSingleton) -> None: ...
+    def enter_match_sequence(self, node: ast.MatchSequence) -> None: ...
+    def enter_match_mapping(self, node: ast.MatchMapping) -> None: ...
+    def enter_match_k_v_pair(self, node: ast.MatchKVPair) -> None: ...
+    def enter_match_star(self, node: ast.MatchStar) -> None: ...
+    def enter_match_arch(self, node: ast.MatchArch) -> 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_null(self, node: ast.Null) -> None: ...
+    def enter_ellipsis(self, node: ast.Ellipsis) -> None: ...
+    def enter_builtin_type(self, node: ast.BuiltinType) -> None: ...
+    def enter_semi(self, node: ast.Semi) -> None: ...
+    def enter_comment_token(self, node: ast.CommentToken) -> None: ...

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

@@ -0,0 +1,11 @@
+import jaclang.compiler.absyntree as ast
+from jaclang.compiler.passes import Pass as Pass
+
+class JacTypeCheckPass(Pass):
+    def before_pass(self) -> None: ...
+    def enter_module(self, node: ast.Module) -> None: ...
+    def after_pass(self) -> None: ...
+    def default_message_cb(
+        self, filename: str | None, new_messages: list[str], is_serious: bool
+    ) -> None: ...
+    def api(self) -> None: ...

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

@@ -0,0 +1,4 @@
+from .fuse_comments_pass import FuseCommentsPass as FuseCommentsPass
+from .jac_formatter_pass import JacFormatPass as JacFormatPass
+
+__all__ = ["FuseCommentsPass", "JacFormatPass"]

jaclang/stubs/jaclang/compiler/passes/tool/fuse_comments_pass.pyi

@@ -0,0 +1,12 @@
+import jaclang.compiler.absyntree as ast
+from _typeshed import Incomplete
+from jaclang.compiler.passes import Pass as Pass
+
+class FuseCommentsPass(Pass):
+    all_tokens: Incomplete
+    comments: Incomplete
+    def before_pass(self) -> None: ...
+    def exit_node(self, node: ast.AstNode) -> None: ...
+    def after_pass(self) -> None: ...
+
+def is_comment_next(cmt: ast.CommentToken, code: ast.Token) -> bool: ...