jaclang 0.8.0__py3-none-any.whl → 0.8.1__py3-none-any.whl

jaclang/langserve/sem_manager.py

@@ -1,383 +0,0 @@
-"""Semantic Token Manager module."""
-
-from __future__ import annotations
-
-from typing import List, Optional, Tuple
-
-import jaclang.compiler.unitree as uni
-from jaclang import JacMachineInterface as Jac
-
-import lsprotocol.types as lspt
-
-(utils,) = Jac.py_jac_import(".utils", base_path=__file__)
-
-
-class SemTokManager:
-    """Semantic Token Manager class."""
-
-    def __init__(self, ir: uni.Module) -> None:
-        """Initialize semantic token manager."""
-        self.sem_tokens: List[int] = self.gen_sem_tokens(ir)
-        self.static_sem_tokens: List[
-            Tuple[lspt.Position, int, int, uni.AstSymbolNode]
-        ] = self.gen_sem_tok_node(ir)
-
-    def gen_sem_tokens(self, ir: uni.Module) -> list[int]:
-        """Return semantic tokens."""
-        tokens = []
-        prev_line, prev_col = 0, 0
-        for node in ir._in_mod_nodes:
-            if isinstance(node, uni.NameAtom) and node.sem_token:
-                line, col_start, col_end = (
-                    node.loc.first_line - 1,
-                    node.loc.col_start - 1,
-                    node.loc.col_end - 1,
-                )
-                length = col_end - col_start
-                tokens += [
-                    line - prev_line,
-                    col_start if line != prev_line else col_start - prev_col,
-                    length,
-                    *node.sem_token,
-                ]
-                prev_line, prev_col = line, col_start
-        return tokens
-
-    def gen_sem_tok_node(
-        self, ir: uni.Module
-    ) -> List[Tuple[lspt.Position, int, int, uni.AstSymbolNode]]:
-        """Return semantic tokens."""
-        tokens: List[Tuple[lspt.Position, int, int, uni.AstSymbolNode]] = []
-        for node in ir._in_mod_nodes:
-            if isinstance(node, uni.NameAtom) and node.sem_token:
-                line, col_start, col_end = (
-                    node.loc.first_line - 1,
-                    node.loc.col_start - 1,
-                    node.loc.col_end - 1,
-                )
-                length = col_end - col_start
-                pos = lspt.Position(line, col_start)
-                tokens += [(pos, col_end, length, node)]
-        return tokens
-
-    def update_sem_tokens(
-        self,
-        content_changes: lspt.DidChangeTextDocumentParams,
-        sem_tokens: list[int],
-        document_lines: List[str],
-    ) -> list[int]:
-        """Update semantic tokens on change."""
-        for change in [
-            x
-            for x in content_changes.content_changes
-            if isinstance(x, lspt.TextDocumentContentChangeEvent_Type1)
-        ]:
-            change_start_line = change.range.start.line
-            change_start_char = change.range.start.character
-            change_end_line = change.range.end.line
-            change_end_char = change.range.end.character
-
-            is_delete = change.text == ""
-            prev_token_index, next_token_index, insert_inside_token = (
-                utils.find_surrounding_tokens(
-                    change_start_line,
-                    change_start_char,
-                    change_end_line,
-                    change_end_char,
-                    sem_tokens,
-                )
-            )
-            prev_tok_pos = utils.get_token_start(prev_token_index, sem_tokens)
-            nxt_tok_pos = utils.get_token_start(next_token_index, sem_tokens)
-            changing_line_text = utils.get_line_of_code(
-                change_start_line, document_lines
-            )
-            if not changing_line_text:
-                return sem_tokens
-            is_edit_between_tokens = bool(
-                (
-                    change_start_line > prev_tok_pos[0]
-                    or (
-                        change_start_line == prev_tok_pos[0]
-                        and change_start_char
-                        > prev_tok_pos[1] + sem_tokens[prev_token_index + 2]
-                        if prev_token_index and prev_token_index + 2 < len(sem_tokens)
-                        else 0
-                    )
-                )
-                and (
-                    change_end_line < nxt_tok_pos[0]
-                    or (
-                        change_end_line == nxt_tok_pos[0]
-                        and change_end_char < nxt_tok_pos[1]
-                    )
-                )
-            )
-            text = r"%s" % change.text
-            line_delta = len(text.split("\n")) - 1
-
-            is_multiline_insertion = line_delta > 0
-            is_next_token_same_line = change_end_line == nxt_tok_pos[0]
-
-            if is_delete:
-                next_token_index = (
-                    prev_token_index + 5
-                    if insert_inside_token
-                    and prev_token_index is not None
-                    or (
-                        next_token_index
-                        and prev_token_index is not None
-                        and next_token_index >= 10
-                        and next_token_index - prev_token_index == 10
-                    )
-                    else next_token_index
-                )
-                if next_token_index is None:
-                    return sem_tokens
-                nxt_tok_pos = utils.get_token_start(next_token_index, sem_tokens)
-                is_single_line_change = change_end_line == change_start_line
-                is_next_token_same_line = change_end_line == nxt_tok_pos[0]
-                if (
-                    is_single_line_change
-                    and insert_inside_token
-                    and prev_token_index is not None
-                ):
-                    sem_tokens = SemTokManager.handle_single_line_delete(
-                        sem_tokens,
-                        next_token_index,
-                        prev_token_index,
-                        is_next_token_same_line,
-                        change,
-                    )
-                elif is_single_line_change and is_edit_between_tokens:
-                    sem_tokens = SemTokManager.handle_single_line_delete_between_tokens(
-                        sem_tokens,
-                        next_token_index,
-                        is_next_token_same_line,
-                        change,
-                        change_start_line,
-                        change_end_line,
-                    )
-                else:
-                    sem_tokens = SemTokManager.handle_multi_line_delete(
-                        sem_tokens,
-                        next_token_index,
-                        nxt_tok_pos,
-                        change_start_line,
-                        change_end_line,
-                        change_start_char,
-                        change_end_char,
-                        prev_tok_pos,
-                        is_next_token_same_line,
-                    )
-                return sem_tokens
-
-            is_token_boundary_edit = False
-            if insert_inside_token and prev_token_index is not None:
-                sem_tokens, is_token_boundary_edit, nxt_tok_pos, next_token_index = (
-                    SemTokManager.handle_insert_inside_token(
-                        change,
-                        sem_tokens,
-                        prev_token_index,
-                        changing_line_text,
-                        line_delta,
-                        prev_tok_pos,
-                        change_start_char,
-                        change_end_char,
-                        is_token_boundary_edit,
-                        nxt_tok_pos,
-                    )
-                )
-            tokens_on_same_line = prev_tok_pos[0] == nxt_tok_pos[0]
-            if (
-                is_edit_between_tokens
-                or is_token_boundary_edit
-                or is_multiline_insertion
-            ) and next_token_index is not None:
-                if is_multiline_insertion:
-                    sem_tokens = SemTokManager.handle_multi_line_insertion(
-                        sem_tokens,
-                        next_token_index,
-                        nxt_tok_pos,
-                        change_start_line,
-                        change_end_line,
-                        change_end_char,
-                        prev_tok_pos,
-                        tokens_on_same_line,
-                        changing_line_text,
-                        line_delta,
-                    )
-                else:
-                    sem_tokens = SemTokManager.handle_single_line_insertion(
-                        sem_tokens,
-                        next_token_index,
-                        is_next_token_same_line,
-                        change,
-                        tokens_on_same_line,
-                        nxt_tok_pos,
-                        change_start_line,
-                        line_delta,
-                    )
-        return sem_tokens
-
-    @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]:
-        """Handle multi line deletion."""
-        if is_next_token_same_line:
-            char_del = nxt_tok_pos[1] - change_end_char
-            total_char_del = change_start_char + char_del
-            sem_tokens[next_token_index + 1] = (
-                (total_char_del - prev_tok_pos[1])
-                if prev_tok_pos[0] == change_start_line
-                else total_char_del
-            )
-        sem_tokens[next_token_index] -= change_end_line - change_start_line
-        return sem_tokens
-
-    @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]:
-        """Handle single line deletion between tokens."""
-        if is_next_token_same_line and change.range_length:
-            sem_tokens[next_token_index + 1] -= change.range_length
-
-        else:
-            sem_tokens[next_token_index] -= change_end_line - change_start_line
-        return sem_tokens
-
-    @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]:
-        """Handle single line deletion."""
-        assert change.range_length is not None
-        sem_tokens[prev_token_index + 2] -= change.range_length
-        if is_next_token_same_line:
-            sem_tokens[next_token_index + 1] -= change.range_length
-        return sem_tokens
-
-    @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]:
-        """Handle single line insertion."""
-        if tokens_on_same_line:
-            sem_tokens[next_token_index + 1] += len(change.text)
-            sem_tokens[next_token_index] += line_delta
-        else:
-            is_next_token_same_line = change_start_line == nxt_tok_pos[0]
-            if is_next_token_same_line:
-                sem_tokens[next_token_index] += line_delta
-                sem_tokens[next_token_index + 1] += len(change.text)
-            else:
-                sem_tokens[next_token_index] += line_delta
-        return sem_tokens
-
-    @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]:
-        """Handle multi line insertion."""
-        if tokens_on_same_line:
-            char_del = nxt_tok_pos[1] - change_end_char
-            total_char_del = changing_line_text[1] + char_del
-
-        else:
-            is_prev_token_same_line = change_end_line == prev_tok_pos[0]
-            is_next_token_same_line = change_start_line == nxt_tok_pos[0]
-            if is_prev_token_same_line:
-                total_char_del = nxt_tok_pos[1]
-            elif is_next_token_same_line:
-                char_del = nxt_tok_pos[1] - change_end_char
-                total_char_del = changing_line_text[1] + char_del
-            else:
-                total_char_del = sem_tokens[next_token_index + 1]
-                line_delta -= change_end_line - change_start_line
-        sem_tokens[next_token_index + 1] = total_char_del
-        sem_tokens[next_token_index] += line_delta
-        return sem_tokens
-
-    @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], Optional[int]]:
-        """Handle insert inside token."""
-        next_token_index = None
-        for i in ["\n", " ", "\t"]:
-            if i in change.text:
-                if prev_tok_pos[1] == change_start_char:
-                    if i == "\n":
-                        sem_tokens[prev_token_index] += line_delta
-                        sem_tokens[prev_token_index + 1] = changing_line_text[1]
-                    else:
-                        sem_tokens[prev_token_index + 1] += len(change.text)
-                    return (
-                        sem_tokens,
-                        is_token_boundary_edit,
-                        nxt_tok_pos,
-                        next_token_index,
-                    )
-                else:
-                    is_token_boundary_edit = True
-                    next_token_index = prev_token_index + 5
-                    nxt_tok_pos = utils.get_token_start(next_token_index, sem_tokens)
-                    break
-        if not is_token_boundary_edit:
-            selected_region = change_end_char - change_start_char
-            index_offset = 2
-            sem_tokens[prev_token_index + index_offset] += (
-                len(change.text) - selected_region
-            )
-            if (
-                prev_tok_pos[0]
-                == utils.get_token_start(prev_token_index + 5, sem_tokens)[0]
-            ):
-                sem_tokens[prev_token_index + index_offset + 4] += (
-                    len(change.text) - selected_region
-                )
-        return sem_tokens, is_token_boundary_edit, nxt_tok_pos, next_token_index

jaclang/langserve/server.py

@@ -1,167 +0,0 @@
-"""Jaclang Language Server."""
-
-from __future__ import annotations
-
-from typing import Optional
-
-from jaclang.compiler.constant import (
-    JacSemTokenModifier as SemTokMod,
-    JacSemTokenType as SemTokType,
-)
-from jaclang.langserve.engine import JacLangServer
-from jaclang.settings import settings
-
-import lsprotocol.types as lspt
-
-server = JacLangServer()
-
-
-@server.feature(lspt.TEXT_DOCUMENT_DID_OPEN)
-async def did_open(ls: JacLangServer, params: lspt.DidOpenTextDocumentParams) -> None:
-    """Check syntax on change."""
-    await ls.launch_deep_check(params.text_document.uri)
-    ls.lsp.send_request(lspt.WORKSPACE_SEMANTIC_TOKENS_REFRESH)
-
-
-@server.feature(lspt.TEXT_DOCUMENT_DID_SAVE)
-async def did_save(ls: JacLangServer, params: lspt.DidOpenTextDocumentParams) -> None:
-    """Check syntax on change."""
-    file_path = params.text_document.uri
-    await ls.launch_deep_check(file_path)
-    ls.lsp.send_request(lspt.WORKSPACE_SEMANTIC_TOKENS_REFRESH)
-
-
-@server.feature(lspt.TEXT_DOCUMENT_DID_CHANGE)
-async def did_change(
-    ls: JacLangServer, params: lspt.DidChangeTextDocumentParams
-) -> None:
-    """Check syntax on change."""
-    file_path = params.text_document.uri
-    await ls.launch_quick_check(file_path)
-    ls.lsp.send_request(lspt.WORKSPACE_SEMANTIC_TOKENS_REFRESH)
-
-
-@server.feature(lspt.TEXT_DOCUMENT_FORMATTING)
-def formatting(
-    ls: JacLangServer, params: lspt.DocumentFormattingParams
-) -> list[lspt.TextEdit]:
-    """Format the given document."""
-    return ls.formatted_jac(params.text_document.uri)
-
-
-@server.feature(
-    lspt.WORKSPACE_DID_CREATE_FILES,
-    lspt.FileOperationRegistrationOptions(
-        filters=[
-            lspt.FileOperationFilter(pattern=lspt.FileOperationPattern("**/*.jac"))
-        ]
-    ),
-)
-def did_create_files(ls: JacLangServer, params: lspt.CreateFilesParams) -> None:
-    """Check syntax on file creation."""
-
-
-@server.feature(
-    lspt.WORKSPACE_DID_RENAME_FILES,
-    lspt.FileOperationRegistrationOptions(
-        filters=[
-            lspt.FileOperationFilter(pattern=lspt.FileOperationPattern("**/*.jac"))
-        ]
-    ),
-)
-def did_rename_files(ls: JacLangServer, params: lspt.RenameFilesParams) -> None:
-    """Check syntax on file rename."""
-    new_uris = [file.new_uri for file in params.files]
-    old_uris = [file.old_uri for file in params.files]
-    for i in range(len(new_uris)):
-        ls.rename_module(old_uris[i], new_uris[i])
-
-
-@server.feature(
-    lspt.WORKSPACE_DID_DELETE_FILES,
-    lspt.FileOperationRegistrationOptions(
-        filters=[
-            lspt.FileOperationFilter(pattern=lspt.FileOperationPattern("**/*.jac"))
-        ]
-    ),
-)
-def did_delete_files(ls: JacLangServer, params: lspt.DeleteFilesParams) -> None:
-    """Check syntax on file delete."""
-    for file in params.files:
-        ls.delete_module(file.uri)
-
-
-@server.feature(
-    lspt.TEXT_DOCUMENT_COMPLETION,
-    lspt.CompletionOptions(trigger_characters=[".", ":", "a-zA-Z0-9"]),
-)
-def completion(ls: JacLangServer, params: lspt.CompletionParams) -> lspt.CompletionList:
-    """Provide completion."""
-    return ls.get_completion(
-        params.text_document.uri,
-        params.position,
-        params.context.trigger_character if params.context else None,
-    )
-
-
-@server.feature(lspt.TEXT_DOCUMENT_HOVER, lspt.HoverOptions(work_done_progress=True))
-def hover(
-    ls: JacLangServer, params: lspt.TextDocumentPositionParams
-) -> Optional[lspt.Hover]:
-    """Provide hover information for the given hover request."""
-    return ls.get_hover_info(params.text_document.uri, params.position)
-
-
-@server.feature(lspt.TEXT_DOCUMENT_DOCUMENT_SYMBOL)
-def document_symbol(
-    ls: JacLangServer, params: lspt.DocumentSymbolParams
-) -> list[lspt.DocumentSymbol]:
-    """Provide document symbols."""
-    return ls.get_outline(params.text_document.uri)
-
-
-@server.feature(lspt.TEXT_DOCUMENT_DEFINITION)
-def definition(
-    ls: JacLangServer, params: lspt.TextDocumentPositionParams
-) -> Optional[lspt.Location]:
-    """Provide definition."""
-    return ls.get_definition(params.text_document.uri, params.position)
-
-
-@server.feature(lspt.TEXT_DOCUMENT_REFERENCES)
-def references(ls: JacLangServer, params: lspt.ReferenceParams) -> list[lspt.Location]:
-    """Provide references."""
-    return ls.get_references(params.text_document.uri, params.position)
-
-
-@server.feature(lspt.TEXT_DOCUMENT_RENAME)
-def rename(
-    ls: JacLangServer, params: lspt.RenameParams
-) -> Optional[lspt.WorkspaceEdit]:
-    """Rename symbol."""
-    ls.log_warning("Auto Rename is Experimental, Please use with caution.")
-    return ls.rename_symbol(params.text_document.uri, params.position, params.new_name)
-
-
-@server.feature(
-    lspt.TEXT_DOCUMENT_SEMANTIC_TOKENS_FULL,
-    lspt.SemanticTokensLegend(
-        token_types=SemTokType.as_str_list(),
-        token_modifiers=SemTokMod.as_str_list(),
-    ),
-)
-def semantic_tokens_full(
-    ls: JacLangServer, params: lspt.SemanticTokensParams
-) -> lspt.SemanticTokens:
-    """Provide semantic tokens."""
-    return ls.get_semantic_tokens(params.text_document.uri)
-
-
-def run_lang_server() -> None:
-    """Run the language server."""
-    settings.pass_timer = True
-    server.start_io()
-
-
-if __name__ == "__main__":
-    run_lang_server()