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

jaclang/langserve/sem_manager.jac

@@ -0,0 +1,309 @@
+"""Semantic Token Manager module."""
+
+import from __future__ { annotations }
+
+import from typing { List, Optional, Tuple }
+
+import jaclang.compiler.unitree as uni;
+import from jaclang { JacMachineInterface as Jac }
+import utils;
+import lsprotocol.types as lspt;
+
+
+"""Semantic Token Manager class."""
+class SemTokManager {
+    """Initialize semantic token manager."""
+    def init(self: SemTokManager, ir: uni.Module) -> None {
+        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);
+    }
+    """Return semantic tokens."""
+    def gen_sem_tokens(self: SemTokManager, ir: uni.Module) -> list[int] {
+        tokens= [];
+        (prev_line, prev_col)= (0, 0);
+        for nd in ir._in_mod_nodes {
+            if isinstance(nd, uni.NameAtom) and nd.sem_token {
+                (line, col_start, col_end)= (( nd.loc.first_line - 1 ),
+                ( nd.loc.col_start - 1 ), ( nd.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,
+                    * nd.sem_token
+                ];
+                (prev_line, prev_col)= (line, col_start);
+            }
+        }
+        return tokens ;
+    }
+    """Return semantic tokens."""
+    def gen_sem_tok_node(self: SemTokManager, ir: uni.Module) -> List[
+        Tuple[(lspt.Position, int, int, uni.AstSymbolNode)]
+    ] {
+        tokens: List[Tuple[(lspt.Position, int, int, uni.AstSymbolNode)]] = [];
+        for nd in ir._in_mod_nodes {
+            if isinstance(nd, uni.NameAtom) and nd.sem_token {
+                (line, col_start, col_end)= (( nd.loc.first_line - 1 ),
+                ( nd.loc.col_start - 1 ), ( nd.loc.col_end - 1 ));
+                length= ( col_end - col_start );
+                pos= lspt.Position(line, col_start);
+                tokens += [(pos, col_end, length, nd)];
+            }
+        }
+        return tokens ;
+    }
+    """Update semantic tokens on change."""
+    def update_sem_tokens(self: SemTokManager,
+    content_changes: lspt.DidChangeTextDocumentParams,
+    sem_tokens: list[int],
+    document_lines: List[str]) -> list[int] {
+        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= ( '%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(self,
+                    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(self,
+                    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(self,
+                    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(self,
+                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(self,
+                    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(self,
+                    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 ;
+    }
+    """Handle multi line deletion."""
+    static def handle_multi_line_delete(self: SemTokManager,
+    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] {
+        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 ;
+    }
+    """Handle single line deletion between tokens."""
+    static def handle_single_line_delete_between_tokens(self: SemTokManager,
+    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] {
+        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 ;
+    }
+    """Handle single line deletion."""
+    static def handle_single_line_delete(self: SemTokManager,
+    sem_tokens: list[int],
+    next_token_index: int,
+    prev_token_index: int,
+    is_next_token_same_line: bool,
+    change: lspt.TextDocumentContentChangeEvent_Type1) -> list[int] {
+        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 ;
+    }
+    """Handle single line insertion."""
+    static def handle_single_line_insertion(self: SemTokManager,
+    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] {
+        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 ;
+    }
+    """Handle multi line insertion."""
+    static def handle_multi_line_insertion(self: SemTokManager,
+    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] {
+        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 ;
+    }
+    """Handle insert inside token."""
+    static def handle_insert_inside_token(self: SemTokManager,
+    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]
+    ] {
+        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.jac

@@ -0,0 +1,186 @@
+"""Jaclang Language Server."""
+
+import from typing { Optional }
+
+import from jaclang.compiler.constant {
+    JacSemTokenModifier as SemTokMod,
+    JacSemTokenType as SemTokType
+}
+
+import from engine { JacLangServer }
+import from jaclang.settings { settings }
+
+import lsprotocol.types as lspt;
+
+
+with entry {
+    server = JacLangServer();
+}
+
+
+"""Check syntax on change."""
+@server.feature(lspt.TEXT_DOCUMENT_DID_OPEN)
+async def did_open(ls: JacLangServer, params: lspt.DidOpenTextDocumentParams) -> None {
+    await ls.launch_deep_check(params.text_document.uri);
+    ls.lsp.send_request(lspt.WORKSPACE_SEMANTIC_TOKENS_REFRESH);
+}
+
+
+"""Check syntax on change."""
+@server.feature(lspt.TEXT_DOCUMENT_DID_SAVE)
+async def did_save(ls: JacLangServer, params: lspt.DidOpenTextDocumentParams) -> None {
+    file_path = params.text_document.uri;
+    await ls.launch_deep_check(file_path);
+    ls.lsp.send_request(lspt.WORKSPACE_SEMANTIC_TOKENS_REFRESH);
+}
+
+
+"""Check syntax on change."""
+@server.feature(lspt.TEXT_DOCUMENT_DID_CHANGE)
+async def did_change(
+    ls: JacLangServer,
+    params: lspt.DidChangeTextDocumentParams
+) -> None {
+    file_path = params.text_document.uri;
+    await ls.launch_quick_check(file_path);
+    ls.lsp.send_request(lspt.WORKSPACE_SEMANTIC_TOKENS_REFRESH);
+}
+
+
+"""Format the given document."""
+@server.feature(lspt.TEXT_DOCUMENT_FORMATTING)
+def formatting(
+    ls: JacLangServer,
+    params: lspt.DocumentFormattingParams
+) -> list[lspt.TextEdit] {
+    return ls.formatted_jac(params.text_document.uri);
+}
+
+
+"""Check syntax on file creation."""
+@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 rename."""
+@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 {
+    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]);
+    }
+}
+
+
+"""Check syntax on file delete."""
+@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 {
+    for file in params.files {
+        ls.delete_module(file.uri);
+    }
+}
+
+
+"""Provide completion."""
+@server.feature(
+    lspt.TEXT_DOCUMENT_COMPLETION,
+    lspt.CompletionOptions(trigger_characters=['.', ':', 'a-zA-Z0-9'])
+)
+def completion(ls: JacLangServer, params: lspt.CompletionParams) -> lspt.CompletionList {
+    return ls.get_completion(
+        params.text_document.uri,
+        params.position,
+        params.context.trigger_character if params.context else None
+    );
+}
+
+
+"""Provide hover information for the given hover request."""
+@server.feature(lspt.TEXT_DOCUMENT_HOVER, lspt.HoverOptions(work_done_progress=True))
+def hover(
+    ls: JacLangServer,
+    params: lspt.TextDocumentPositionParams
+) -> Optional[lspt.Hover] {
+    return ls.get_hover_info(params.text_document.uri, params.position);
+}
+
+
+"""Provide document symbols."""
+@server.feature(lspt.TEXT_DOCUMENT_DOCUMENT_SYMBOL)
+def document_symbol(
+    ls: JacLangServer,
+    params: lspt.DocumentSymbolParams
+) -> list[lspt.DocumentSymbol] {
+    return ls.get_outline(params.text_document.uri);
+}
+
+
+"""Provide definition."""
+@server.feature(lspt.TEXT_DOCUMENT_DEFINITION)
+def definition(
+    ls: JacLangServer,
+    params: lspt.TextDocumentPositionParams
+) -> Optional[lspt.Location] {
+    return ls.get_definition(params.text_document.uri, params.position);
+}
+
+
+"""Provide references."""
+@server.feature(lspt.TEXT_DOCUMENT_REFERENCES)
+def references(ls: JacLangServer, params: lspt.ReferenceParams) -> list[lspt.Location] {
+    return ls.get_references(params.text_document.uri, params.position);
+}
+
+
+"""Rename symbol."""
+@server.feature(lspt.TEXT_DOCUMENT_RENAME)
+def rename(ls: JacLangServer, params: lspt.RenameParams) -> Optional[lspt.WorkspaceEdit] {
+    ls.log_warning('Auto Rename is Experimental, Please use with caution.');
+    return ls.rename_symbol(params.text_document.uri, params.position, params.new_name);
+}
+
+
+"""Provide semantic tokens."""
+@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 {
+    return ls.get_semantic_tokens(params.text_document.uri);
+}
+
+
+"""Run the language server."""
+def run_lang_server() -> None {
+    settings.pass_timer = True;
+    server.start_io();
+}
+
+
+with entry {
+    if __name__ == '__main__' {
+        run_lang_server();
+    }
+}

jaclang/langserve/tests/server_test/test_lang_serve.py

@@ -12,13 +12,6 @@ from lsprotocol.types import (
     VersionedTextDocumentIdentifier,
     TextDocumentIdentifier,
 )
-from jaclang.langserve.engine import JacLangServer
-from jaclang.langserve.server import (
-    did_open,
-    did_save,
-    did_change,
-    formatting,
-)
 from jaclang.langserve.tests.server_test.utils import (
     create_temp_jac_file,
     get_code,
@@ -27,6 +20,12 @@ from jaclang.langserve.tests.server_test.utils import (
 )
 from jaclang.vendor.pygls.uris import from_fs_path
 from jaclang.vendor.pygls.workspace import Workspace
+from jaclang import JacMachineInterface as _
+
+JacLangServer = _.py_jac_import(
+    "....langserve.engine", __file__, items={"JacLangServer": None}
+)[0]
+(did_open, did_save, did_change, formatting) = _.py_jac_import(    "....langserve.server", __file__, items={"did_open": None, "did_save": None, "did_change": None, "formatting": None})
 
 JAC_FILE = get_jac_file_path()
 

jaclang/langserve/tests/server_test/utils.py

@@ -2,11 +2,14 @@
 import os
 import tempfile
 
-from jaclang.langserve.engine import JacLangServer
 from jaclang.vendor.pygls.uris import from_fs_path
 from jaclang.vendor.pygls.workspace import Workspace
 
 from textwrap import dedent
+from jaclang import JacMachineInterface as _
+JacLangServer = _.py_jac_import(
+    "....langserve.engine", __file__, items={"JacLangServer": None}
+)[0]
 
 def get_jac_file_path():
     """Return the absolute path to the sample Jac file used for testing."""