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

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

@@ -0,0 +1,134 @@
+import jaclang.compiler.absyntree as ast
+from _typeshed import Incomplete
+from jaclang.compiler.absyntree import AstNode as AstNode
+from jaclang.compiler.passes import Pass as Pass
+from jaclang.settings import settings as settings
+
+class JacFormatPass(Pass):
+    comments: Incomplete
+    indent_size: int
+    indent_level: int
+    MAX_LINE_LENGTH: Incomplete
+    def before_pass(self) -> None: ...
+    def enter_node(self, node: ast.AstNode) -> None: ...
+    def token_before(self, node: ast.Token) -> ast.Token | None: ...
+    def token_after(self, node: ast.Token) -> ast.Token | None: ...
+    def indent_str(self) -> str: ...
+    def emit(self, node: ast.AstNode, s: str, strip_mode: bool = True) -> None: ...
+    def emit_ln(self, node: ast.AstNode, s: str) -> None: ...
+    def comma_sep_node_list(self, node: ast.SubNodeList) -> str: ...
+    def dot_sep_node_list(self, node: ast.SubNodeList) -> str: ...
+    def nl_sep_node_list(self, node: ast.SubNodeList) -> str: ...
+    def sep_node_list(self, node: ast.SubNodeList, delim: str = " ") -> str: ...
+    def enter_module(self, node: ast.Module) -> None: ...
+    def exit_module(self, node: ast.Module) -> None: ...
+    def exit_global_vars(self, node: ast.GlobalVars) -> None: ...
+    def exit_module_code(self, node: ast.ModuleCode) -> None: ...
+    def exit_sub_node_list(self, node: ast.SubNodeList) -> None: ...
+    def exit_sub_tag(self, node: ast.SubTag) -> None: ...
+    def exit_func_call(self, node: ast.FuncCall) -> None: ...
+    def exit_multi_string(self, node: ast.MultiString) -> None: ...
+    def exit_module_path(self, node: ast.ModulePath) -> None: ...
+    def exit_tuple_val(self, node: ast.TupleVal) -> None: ...
+    def exit_special_var_ref(self, node: ast.SpecialVarRef) -> None: ...
+    def exit_ability_def(self, node: ast.AbilityDef) -> None: ...
+    def exit_event_signature(self, node: ast.EventSignature) -> None: ...
+    def exit_import(self, node: ast.Import) -> None: ...
+    def exit_arch_def(self, node: ast.ArchDef) -> None: ...
+    def exit_ability(self, node: ast.Ability) -> None: ...
+    def exit_func_signature(self, node: ast.FuncSignature) -> None: ...
+    def exit_arch_has(self, node: ast.ArchHas) -> None: ...
+    def exit_arch_ref(self, node: ast.ArchRef) -> None: ...
+    def exit_param_var(self, node: ast.ParamVar) -> None: ...
+    def exit_enum(self, node: ast.Enum) -> None: ...
+    def exit_enum_def(self, node: ast.EnumDef) -> None: ...
+    def exit_atom_trailer(self, node: ast.AtomTrailer) -> None: ...
+    def exit_atom_unit(self, node: ast.AtomUnit) -> None: ...
+    def exit_yield_expr(self, node: ast.YieldExpr) -> None: ...
+    def is_line_break_needed(self, content: str, max_line_length: int = 0) -> bool: ...
+    def exit_binary_expr(self, node: ast.BinaryExpr) -> None: ...
+    def exit_compare_expr(self, node: ast.CompareExpr) -> None: ...
+    def exit_has_var(self, node: ast.HasVar) -> None: ...
+    def exit_if_stmt(self, node: ast.IfStmt) -> None: ...
+    def exit_else_if(self, node: ast.ElseIf) -> None: ...
+    def exit_disengage_stmt(self, node: ast.DisengageStmt) -> None: ...
+    def exit_else_stmt(self, node: ast.ElseStmt) -> None: ...
+    def exit_expr_stmt(self, node: ast.ExprStmt) -> None: ...
+    def exit_iter_for_stmt(self, node: ast.IterForStmt) -> 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_while_stmt(self, node: ast.WhileStmt) -> None: ...
+    def exit_with_stmt(self, node: ast.WithStmt) -> None: ...
+    def exit_module_item(self, node: ast.ModuleItem) -> None: ...
+    def exit_global_stmt(self, node: ast.GlobalStmt) -> None: ...
+    def exit_non_local_stmt(self, node: ast.GlobalStmt) -> None: ...
+    def handle_long_assignment(
+        self, node: ast.Assignment, kid: ast.AstNode
+    ) -> None: ...
+    def handle_long_expression(self, node: ast.AstNode, kid: ast.AstNode) -> None: ...
+    def exit_assignment(self, node: ast.Assignment) -> None: ...
+    def exit_architype(self, node: ast.Architype) -> None: ...
+    def exit_f_string(self, node: ast.FString) -> None: ...
+    def exit_if_else_expr(self, node: ast.IfElseExpr) -> None: ...
+    def decl_def_missing(self, decl: str = "this") -> 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_raise_stmt(self, node: ast.RaiseStmt) -> None: ...
+    def exit_edge_ref_trailer(self, node: ast.EdgeRefTrailer) -> None: ...
+    def exit_edge_op_ref(self, node: ast.EdgeOpRef) -> None: ...
+    def exit_index_slice(self, node: ast.IndexSlice) -> None: ...
+    def exit_list_val(self, node: ast.ListVal) -> None: ...
+    def exit_set_val(self, node: ast.ListVal) -> None: ...
+    def exit_dict_val(self, node: ast.DictVal) -> 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_k_v_pair(self, node: ast.KVPair) -> None: ...
+    def exit_k_w_pair(self, node: ast.KWPair) -> None: ...
+    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_await_expr(self, node: ast.AwaitExpr) -> None: ...
+    def exit_revisit_stmt(self, node: ast.RevisitStmt) -> None: ...
+    def exit_visit_stmt(self, node: ast.VisitStmt) -> None: ...
+    def exit_ignore_stmt(self, node: ast.IgnoreStmt) -> None: ...
+    def exit_return_stmt(self, node: ast.ReturnStmt) -> 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_expr_as_item(self, node: ast.ExprAsItem) -> None: ...
+    def exit_in_for_stmt(self, node: ast.InForStmt) -> None: ...
+    def exit_test(self, node: ast.Test) -> None: ...
+    def exit_py_inline_code(self, node: ast.PyInlineCode) -> None: ...
+    def exit_arch_ref_chain(self, node: ast.ArchRefChain) -> None: ...
+    def exit_typed_ctx_block(self, node: ast.TypedCtxBlock) -> 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 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 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/tool/schedules.pyi

@@ -0,0 +1,11 @@
+from jaclang.compiler.passes.ir_pass import Pass
+from jaclang.compiler.passes.tool.fuse_comments_pass import (
+    FuseCommentsPass as FuseCommentsPass,
+)
+from jaclang.compiler.passes.tool.jac_formatter_pass import (
+    JacFormatPass as JacFormatPass,
+)
+
+__all__ = ["FuseCommentsPass", "JacFormatPass", "format_pass"]
+
+format_pass: list[type[Pass]]

jaclang/stubs/jaclang/compiler/passes/transform.pyi

@@ -0,0 +1,28 @@
+import abc
+from _typeshed import Incomplete
+from abc import ABC, abstractmethod
+from jaclang.compiler.absyntree import AstNode as AstNode, T as T
+from jaclang.compiler.codeloc import CodeLocInfo as CodeLocInfo
+from jaclang.utils.log import logging as logging
+from typing import Generic
+
+class Alert:
+    msg: Incomplete
+    loc: Incomplete
+    from_pass: Incomplete
+    def __init__(
+        self, msg: str, loc: CodeLocInfo, from_pass: type[Transform]
+    ) -> None: ...
+
+class Transform(ABC, Generic[T], metaclass=abc.ABCMeta):
+    logger: Incomplete
+    errors_had: Incomplete
+    warnings_had: Incomplete
+    cur_node: Incomplete
+    ir: Incomplete
+    def __init__(self, input_ir: T, prior: Transform | None = None) -> None: ...
+    @abstractmethod
+    def transform(self, ir: T) -> AstNode: ...
+    def log_error(self, msg: str, node_override: AstNode | None = None) -> None: ...
+    def log_warning(self, msg: str, node_override: AstNode | None = None) -> None: ...
+    def log_info(self, msg: str) -> None: ...

jaclang/stubs/jaclang/compiler/passes/utils/mypy_ast_build.pyi

@@ -0,0 +1,151 @@
+import ast
+import mypy.build as myb
+import mypy.checkexpr as mycke
+import mypy.errors as mye
+import mypy.fastparse as myfp
+from _typeshed import Incomplete
+from jaclang.compiler.passes import Pass
+from mypy.build import (
+    BuildSource as BuildSource,
+    BuildSourceSet as BuildSourceSet,
+    FileSystemCache as FileSystemCache,
+    Graph,
+    compute_search_paths as compute_search_paths,
+    load_plugins as load_plugins,
+    process_graph as process_graph,
+)
+from mypy.options import Options as Options
+from mypy.semanal_main import semantic_analysis_for_scc as semantic_analysis_for_scc
+
+__all__ = [
+    "BuildManager",
+    "State",
+    "BuildSource",
+    "BuildSourceSet",
+    "FileSystemCache",
+    "compute_search_paths",
+    "load_graph",
+    "load_plugins",
+    "process_graph",
+    "Errors",
+    "Options",
+    "ASTConverter",
+    "semantic_analysis_for_scc",
+]
+
+class BuildManager(myb.BuildManager):
+    def parse_file(
+        self,
+        id: str,
+        path: str,
+        source: str,
+        ignore_errors: bool,
+        options: myb.Options,
+        ast_override: myb.MypyFile | None = None,
+    ) -> myb.MypyFile: ...
+
+class ExpressionChecker(mycke.ExpressionChecker):
+    def __init__(
+        self,
+        tc: mycke.mypy.checker.TypeChecker,
+        msg: mycke.MessageBuilder,
+        plugin: mycke.Plugin,
+        per_line_checking_time_ns: dict[int, int],
+    ) -> None: ...
+    def visit_list_expr(self, e: mycke.ListExpr) -> mycke.Type: ...
+    def visit_set_expr(self, e: mycke.SetExpr) -> mycke.Type: ...
+    def visit_tuple_expr(self, e: myfp.TupleExpr) -> myb.Type: ...
+    def visit_dict_expr(self, e: myfp.DictExpr) -> myb.Type: ...
+    def visit_list_comprehension(self, e: myfp.ListComprehension) -> myb.Type: ...
+    def visit_set_comprehension(self, e: myfp.SetComprehension) -> myb.Type: ...
+    def visit_generator_expr(self, e: myfp.GeneratorExpr) -> myb.Type: ...
+    def visit_dictionary_comprehension(
+        self, e: myfp.DictionaryComprehension
+    ) -> myb.Type: ...
+    def visit_member_expr(
+        self, e: myfp.MemberExpr, is_lvalue: bool = False
+    ) -> myb.Type: ...
+
+class State(myb.State):
+    manager: BuildManager
+    tree: myb.MypyFile | None
+    order: Incomplete
+    caller_state: Incomplete
+    caller_line: Incomplete
+    import_context: Incomplete
+    id: Incomplete
+    options: Incomplete
+    early_errors: Incomplete
+    ignore_all: bool
+    path: Incomplete
+    abspath: Incomplete
+    xpath: Incomplete
+    meta: Incomplete
+    interface_hash: Incomplete
+    meta_source_hash: Incomplete
+    source: Incomplete
+    per_line_checking_time_ns: Incomplete
+    dependencies: Incomplete
+    dependencies_set: Incomplete
+    suppressed: Incomplete
+    suppressed_set: Incomplete
+    priorities: Incomplete
+    dep_line_map: Incomplete
+    def __init__(
+        self,
+        id: str | None,
+        path: str | None,
+        source: str | None,
+        manager: BuildManager,
+        caller_state: myb.State | None = None,
+        caller_line: int = 0,
+        ancestor_for: myb.State | None = None,
+        root_source: bool = False,
+        temporary: bool = False,
+        ast_override: myb.MypyFile | None = None,
+    ) -> None: ...
+    def type_checker(self) -> myb.TypeChecker: ...
+    source_hash: Incomplete
+    def parse_file(
+        self, *, temporary: bool = False, ast_override: myb.MypyFile | None = None
+    ) -> None: ...
+
+class ASTConverter(myfp.ASTConverter):
+    def visit(self, node: ast.AST | None) -> myfp.Any: ...
+    def make_argument(
+        self,
+        arg: ast.arg,
+        default: ast.expr | None,
+        kind: myfp.ArgKind,
+        no_type_check: bool,
+        pos_only: bool = False,
+    ) -> myfp.Argument: ...
+    def link_mypy_to_jac_node(self, node: ast.AST, ret: myfp.Any) -> None: ...
+
+class Errors(mye.Errors):
+    cur_pass: Incomplete
+    def __init__(self, cur_pass: Pass, *args, **kwargs) -> None: ...
+    def report(
+        self,
+        line: int,
+        column: int | None,
+        message: str,
+        code: mye.ErrorCode | None = None,
+        *,
+        blocker: bool = False,
+        severity: str = "error",
+        file: str | None = None,
+        only_once: bool = False,
+        allow_dups: bool = False,
+        origin_span: mye.Iterable[int] | None = None,
+        offset: int = 0,
+        end_line: int | None = None,
+        end_column: int | None = None
+    ) -> None: ...
+
+def load_graph(
+    sources: list[BuildSource],
+    manager: BuildManager,
+    old_graph: Graph | None = None,
+    new_modules: list[State] | None = None,
+) -> Graph: ...

jaclang/stubs/jaclang/compiler/semtable.pyi

@@ -0,0 +1,35 @@
+from _typeshed import Incomplete
+
+class SemInfo:
+    name: Incomplete
+    type: Incomplete
+    semstr: Incomplete
+    def __init__(
+        self, name: str, type: str | None = None, semstr: str = ""
+    ) -> None: ...
+
+class SemScope:
+    parent: Incomplete
+    type: Incomplete
+    scope: Incomplete
+    def __init__(
+        self, scope: str, type: str, parent: SemScope | None = None
+    ) -> None: ...
+    @staticmethod
+    def get_scope_from_str(scope_str: str) -> SemScope | None: ...
+    @property
+    def as_type_str(self) -> str | None: ...
+
+class SemRegistry:
+    registry: Incomplete
+    def __init__(self) -> None: ...
+    def add(self, scope: SemScope, seminfo: SemInfo) -> None: ...
+    def lookup(
+        self,
+        scope: SemScope | None = None,
+        name: str | None = None,
+        type: str | None = None,
+    ) -> tuple[SemScope | None, SemInfo | list[SemInfo] | None]: ...
+    @property
+    def module_scope(self) -> SemScope: ...
+    def pp(self) -> str: ...

jaclang/stubs/jaclang/compiler/symtable.pyi

@@ -0,0 +1,65 @@
+import jaclang.compiler.absyntree as ast
+from _typeshed import Incomplete
+from jaclang.compiler.constant import (
+    SymbolAccess as SymbolAccess,
+    SymbolType as SymbolType,
+)
+from typing import Sequence
+
+__all__ = ["Symbol", "SymbolTable", "SymbolType", "SymbolAccess"]
+
+class Symbol:
+    defn: Incomplete
+    uses: Incomplete
+    access: Incomplete
+    parent_tab: Incomplete
+    def __init__(
+        self, defn: ast.NameAtom, access: SymbolAccess, parent_tab: SymbolTable
+    ) -> None: ...
+    @property
+    def decl(self) -> ast.NameAtom: ...
+    @property
+    def sym_name(self) -> str: ...
+    @property
+    def sym_type(self) -> SymbolType: ...
+    @property
+    def sym_dotted_name(self) -> str: ...
+    def add_defn(self, node: ast.NameAtom) -> None: ...
+    def add_use(self, node: ast.NameAtom) -> None: ...
+
+class SymbolTable:
+    name: Incomplete
+    owner: Incomplete
+    parent: Incomplete
+    kid: Incomplete
+    tab: Incomplete
+    inherit: Incomplete
+    def __init__(
+        self, name: str, owner: ast.AstNode, parent: SymbolTable | None = None
+    ) -> None: ...
+    def get_parent(self) -> SymbolTable | None: ...
+    def lookup(self, name: str, deep: bool = True) -> Symbol | None: ...
+    def insert(
+        self,
+        node: ast.AstSymbolNode,
+        access_spec: ast.AstAccessNode | None | SymbolAccess = None,
+        single: bool = False,
+    ) -> ast.AstNode | None: ...
+    def find_scope(self, name: str) -> SymbolTable | None: ...
+    def push_scope(self, name: str, key_node: ast.AstNode) -> SymbolTable: ...
+    def inherit_sym_tab(self, target_sym_tab: SymbolTable) -> None: ...
+    def def_insert(
+        self,
+        node: ast.AstSymbolNode,
+        access_spec: ast.AstAccessNode | None | SymbolAccess = None,
+        single_decl: str | None = None,
+    ) -> Symbol | None: ...
+    def chain_def_insert(self, node_list: list[ast.AstSymbolNode]) -> None: ...
+    def use_lookup(
+        self, node: ast.AstSymbolNode, sym_table: SymbolTable | None = None
+    ) -> Symbol | None: ...
+    def chain_use_lookup(self, node_list: Sequence[ast.AstSymbolNode]) -> None: ...
+    def update_py_ctx_for_def(self, node: ast.AstSymbolNode) -> None: ...
+    def inherit_baseclasses_sym(self, node: ast.Architype | ast.Enum) -> None: ...
+    def pp(self, depth: int | None = None) -> str: ...
+    def dotgen(self) -> str: ...

jaclang/stubs/jaclang/langserve/engine.pyi

@@ -0,0 +1,73 @@
+import jaclang.compiler.absyntree as ast
+import lsprotocol.types as lspt
+from _typeshed import Incomplete
+from jaclang.compiler.compile import jac_str_to_pass as jac_str_to_pass
+from jaclang.compiler.parser import JacParser as JacParser
+from jaclang.compiler.passes import Pass as Pass
+from jaclang.compiler.passes.main.schedules import (
+    py_code_gen_typed as py_code_gen_typed,
+)
+from jaclang.compiler.passes.tool import (
+    FuseCommentsPass as FuseCommentsPass,
+    JacFormatPass as JacFormatPass,
+)
+from jaclang.langserve.sem_manager import SemTokManager as SemTokManager
+from jaclang.langserve.utils import (
+    collect_all_symbols_in_scope as collect_all_symbols_in_scope,
+    create_range as create_range,
+    find_index as find_index,
+    find_node_by_position as find_node_by_position,
+    gen_diagnostics as gen_diagnostics,
+    get_item_path as get_item_path,
+    get_mod_path as get_mod_path,
+    get_symbols_for_outline as get_symbols_for_outline,
+    parse_symbol_path as parse_symbol_path,
+    resolve_completion_symbol_table as resolve_completion_symbol_table,
+)
+from jaclang.vendor.pygls import uris as uris
+from jaclang.vendor.pygls.server import LanguageServer as LanguageServer
+
+class ModuleInfo:
+    ir: Incomplete
+    impl_parent: Incomplete
+    sem_manager: Incomplete
+    def __init__(
+        self, ir: ast.Module, impl_parent: ModuleInfo | None = None
+    ) -> None: ...
+    @property
+    def uri(self) -> str: ...
+
+class JacLangServer(LanguageServer):
+    modules: Incomplete
+    executor: Incomplete
+    tasks: Incomplete
+    def __init__(self) -> None: ...
+    def update_modules(
+        self, file_path: str, build: Pass, refresh: bool = False
+    ) -> None: ...
+    def quick_check(self, file_path: str) -> bool: ...
+    def deep_check(self, file_path: str, annex_view: str | None = None) -> bool: ...
+    async def launch_quick_check(self, uri: str) -> None: ...
+    async def launch_deep_check(self, uri: str) -> None: ...
+    def get_completion(
+        self, file_path: str, position: lspt.Position, completion_trigger: str | None
+    ) -> lspt.CompletionList: ...
+    def rename_module(self, old_path: str, new_path: str) -> None: ...
+    def delete_module(self, uri: str) -> None: ...
+    def formatted_jac(self, file_path: str) -> list[lspt.TextEdit]: ...
+    def get_hover_info(
+        self, file_path: str, position: lspt.Position
+    ) -> lspt.Hover | None: ...
+    def get_node_info(self, node: ast.AstSymbolNode) -> str | None: ...
+    def get_outline(self, file_path: str) -> list[lspt.DocumentSymbol]: ...
+    def get_definition(
+        self, file_path: str, position: lspt.Position
+    ) -> lspt.Location | None: ...
+    def get_references(
+        self, file_path: str, position: lspt.Position
+    ) -> list[lspt.Location]: ...
+    def get_semantic_tokens(self, file_path: str) -> lspt.SemanticTokens: ...
+    def log_error(self, message: str) -> None: ...
+    def log_warning(self, message: str) -> None: ...
+    def log_info(self, message: str) -> None: ...
+    def log_py(self, message: str) -> None: ...

jaclang/stubs/jaclang/langserve/sem_manager.pyi

@@ -0,0 +1,89 @@
+import jaclang.compiler.absyntree as ast
+import lsprotocol.types as lspt
+from _typeshed import Incomplete
+from jaclang.langserve.utils import (
+    find_surrounding_tokens as find_surrounding_tokens,
+    get_line_of_code as get_line_of_code,
+    get_token_start as get_token_start,
+)
+
+class SemTokManager:
+    sem_tokens: Incomplete
+    static_sem_tokens: Incomplete
+    def __init__(self, ir: ast.Module) -> None: ...
+    def gen_sem_tokens(self, ir: ast.Module) -> list[int]: ...
+    def gen_sem_tok_node(
+        self, ir: ast.Module
+    ) -> list[tuple[lspt.Position, int, int, ast.AstSymbolNode]]: ...
+    def update_sem_tokens(
+        self,
+        content_changes: lspt.DidChangeTextDocumentParams,
+        sem_tokens: list[int],
+        document_lines: list[str],
+    ) -> list[int]: ...
+    @staticmethod
+    def handle_multi_line_delete(
+        sem_tokens: list[int],
+        next_token_index: int,
+        nxt_tok_pos: tuple[int, int, int],
+        change_start_line: int,
+        change_end_line: int,
+        change_start_char: int,
+        change_end_char: int,
+        prev_tok_pos: tuple[int, int, int],
+        is_next_token_same_line: bool,
+    ) -> list[int]: ...
+    @staticmethod
+    def handle_single_line_delete_between_tokens(
+        sem_tokens: list[int],
+        next_token_index: int,
+        is_next_token_same_line: bool,
+        change: lspt.TextDocumentContentChangeEvent_Type1,
+        change_start_line: int,
+        change_end_line: int,
+    ) -> list[int]: ...
+    @staticmethod
+    def handle_single_line_delete(
+        sem_tokens: list[int],
+        next_token_index: int,
+        prev_token_index: int,
+        is_next_token_same_line: bool,
+        change: lspt.TextDocumentContentChangeEvent_Type1,
+    ) -> list[int]: ...
+    @staticmethod
+    def handle_single_line_insertion(
+        sem_tokens: list[int],
+        next_token_index: int,
+        is_next_token_same_line: bool,
+        change: lspt.TextDocumentContentChangeEvent_Type1,
+        tokens_on_same_line: bool,
+        nxt_tok_pos: tuple[int, int, int],
+        change_start_line: int,
+        line_delta: int,
+    ) -> list[int]: ...
+    @staticmethod
+    def handle_multi_line_insertion(
+        sem_tokens: list[int],
+        next_token_index: int,
+        nxt_tok_pos: tuple[int, int, int],
+        change_start_line: int,
+        change_end_line: int,
+        change_end_char: int,
+        prev_tok_pos: tuple[int, int, int],
+        tokens_on_same_line: bool,
+        changing_line_text: tuple[str, int],
+        line_delta: int,
+    ) -> list[int]: ...
+    @staticmethod
+    def handle_insert_inside_token(
+        change: lspt.TextDocumentContentChangeEvent_Type1,
+        sem_tokens: list[int],
+        prev_token_index: int,
+        changing_line_text: tuple[str, int],
+        line_delta: int,
+        prev_tok_pos: tuple[int, int, int],
+        change_start_char: int,
+        change_end_char: int,
+        is_token_boundary_edit: bool,
+        nxt_tok_pos: tuple[int, int, int],
+    ) -> tuple[list[int], bool, tuple[int, int, int], int | None]: ...

jaclang/stubs/jaclang/langserve/server.pyi

@@ -0,0 +1,38 @@
+import lsprotocol.types as lspt
+from _typeshed import Incomplete
+from jaclang.langserve.engine import JacLangServer as JacLangServer
+from jaclang.settings import settings as settings
+
+server: Incomplete
+
+async def did_open(
+    ls: JacLangServer, params: lspt.DidOpenTextDocumentParams
+) -> None: ...
+async def did_change(
+    ls: JacLangServer, params: lspt.DidChangeTextDocumentParams
+) -> None: ...
+def formatting(
+    ls: JacLangServer, params: lspt.DocumentFormattingParams
+) -> list[lspt.TextEdit]: ...
+def did_create_files(ls: JacLangServer, params: lspt.CreateFilesParams) -> None: ...
+def did_rename_files(ls: JacLangServer, params: lspt.RenameFilesParams) -> None: ...
+def did_delete_files(ls: JacLangServer, params: lspt.DeleteFilesParams) -> None: ...
+def completion(
+    ls: JacLangServer, params: lspt.CompletionParams
+) -> lspt.CompletionList: ...
+def hover(
+    ls: JacLangServer, params: lspt.TextDocumentPositionParams
+) -> lspt.Hover | None: ...
+def document_symbol(
+    ls: JacLangServer, params: lspt.DocumentSymbolParams
+) -> list[lspt.DocumentSymbol]: ...
+def definition(
+    ls: JacLangServer, params: lspt.TextDocumentPositionParams
+) -> lspt.Location | None: ...
+def references(
+    ls: JacLangServer, params: lspt.ReferenceParams
+) -> list[lspt.Location]: ...
+def semantic_tokens_full(
+    ls: JacLangServer, params: lspt.SemanticTokensParams
+) -> lspt.SemanticTokens: ...
+def run_lang_server() -> None: ...