jaclang 0.7.14__py3-none-any.whl → 0.7.17__py3-none-any.whl

jaclang/langserve/sem_manager.py

@@ -0,0 +1,379 @@
+"""Semantic Token Manager module."""
+
+from __future__ import annotations
+
+from typing import List, Optional, Tuple
+
+import jaclang.compiler.absyntree as ast
+from jaclang.langserve.utils import (
+    find_surrounding_tokens,
+    get_line_of_code,
+    get_token_start,
+)
+
+import lsprotocol.types as lspt
+
+
+class SemTokManager:
+    """Semantic Token Manager class."""
+
+    def __init__(self, ir: ast.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, ast.AstSymbolNode]
+        ] = self.gen_sem_tok_node(ir)
+
+    def gen_sem_tokens(self, ir: ast.Module) -> list[int]:
+        """Return semantic tokens."""
+        tokens = []
+        prev_line, prev_col = 0, 0
+        for node in ir._in_mod_nodes:
+            if isinstance(node, ast.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: ast.Module
+    ) -> List[Tuple[lspt.Position, int, int, ast.AstSymbolNode]]:
+        """Return semantic tokens."""
+        tokens: List[Tuple[lspt.Position, int, int, ast.AstSymbolNode]] = []
+        for node in ir._in_mod_nodes:
+            if isinstance(node, ast.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 = (
+                find_surrounding_tokens(
+                    change_start_line,
+                    change_start_char,
+                    change_end_line,
+                    change_end_char,
+                    sem_tokens,
+                )
+            )
+            prev_tok_pos = get_token_start(prev_token_index, sem_tokens)
+            nxt_tok_pos = get_token_start(next_token_index, sem_tokens)
+            changing_line_text = 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 = 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:
+            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."""
+        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 = 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] == 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

@@ -9,6 +9,7 @@ from jaclang.compiler.constant import (
     JacSemTokenType as SemTokType,
 )
 from jaclang.langserve.engine import JacLangServer
+from jaclang.settings import settings
 
 import lsprotocol.types as lspt
 
@@ -16,8 +17,14 @@ server = JacLangServer()
 
 
 @server.feature(lspt.TEXT_DOCUMENT_DID_OPEN)
-@server.feature(lspt.TEXT_DOCUMENT_DID_SAVE)
 async def did_open(ls: JacLangServer, params: lspt.DidOpenTextDocumentParams) -> None:
+    """Check syntax on change."""
+    ls.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."""
     await ls.launch_deep_check(params.text_document.uri)
     ls.lsp.send_request(lspt.WORKSPACE_SEMANTIC_TOKENS_REFRESH)
@@ -30,7 +37,11 @@ async def did_change(
     """Check syntax on change."""
     await ls.launch_quick_check(file_path := params.text_document.uri)
     if file_path in ls.modules:
-        ls.modules[file_path].update_sem_tokens(params)
+        document = ls.workspace.get_text_document(file_path)
+        lines = document.source.splitlines()
+        ls.modules[file_path].sem_manager.update_sem_tokens(
+            params, ls.modules[file_path].sem_manager.sem_tokens, lines
+        )
         ls.lsp.send_request(lspt.WORKSPACE_SEMANTIC_TOKENS_REFRESH)
 
 
@@ -110,7 +121,7 @@ def document_symbol(
     ls: JacLangServer, params: lspt.DocumentSymbolParams
 ) -> list[lspt.DocumentSymbol]:
     """Provide document symbols."""
-    return ls.get_document_symbols(params.text_document.uri)
+    return ls.get_outline(params.text_document.uri)
 
 
 @server.feature(lspt.TEXT_DOCUMENT_DEFINITION)
@@ -127,6 +138,15 @@ def references(ls: JacLangServer, params: lspt.ReferenceParams) -> list[lspt.Loc
     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(
@@ -138,19 +158,12 @@ def semantic_tokens_full(
     ls: JacLangServer, params: lspt.SemanticTokensParams
 ) -> lspt.SemanticTokens:
     """Provide semantic tokens."""
-    # import logging
-
-    # logging.info("\nGetting semantic tokens\n")
-    # # logging.info(ls.get_semantic_tokens(params.text_document.uri))
-    # i = 0
-    # while i < len(ls.get_semantic_tokens(params.text_document.uri).data):
-    #     logging.info(ls.get_semantic_tokens(params.text_document.uri).data[i : i + 5])
-    #     i += 5
     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()
 
 

jaclang/langserve/tests/fixtures/base_module_structure.jac

@@ -35,20 +35,41 @@ obj Colour1 {
 }
 
 :obj:Colour1:can:get_color1 -> Colorenum {
-    return self.color;
+
+    return self.color1;
 }
 
 obj red :Colour1: {
-    has base_colorred: Colorenum = Color.RED,
+    has base_colorred: Colorenum = Colorenum.RED,
         pointred: int = 10;
-    obj color2 {
-        has color22: Color = Colorenum.BLUE,
+
+    obj inner_red {
+        has color22: enum_red = enum_red.BLUE22,
+            doublepoint22:doubleinner.double  = 2,
             point22: int = 20;
+
+        can apply_inner_red -> enum_red {
+            return self.color22;
+        }
+        enum enum_red {
+            RED22,
+            GREEN22,
+            BLUE22
+        }
     }
+    class doubleinner {
+        has double: int = 2;
+    }
+
+    can apply_red -> int {
+        x =
+        self.inner_red.color22.GREEN22;
+        return self.point1 + self.pointred;
+        }
 }
 
 with entry:__main__ {
-    r = red(color1=Color.GREEN, point1=20);
+    r = red(color1=Colorenum.GREEN, point1=20);
     print(r.get_color1());
-    print(r.color2.color22);
+    print(r.inner_red);
 }

jaclang/langserve/tests/fixtures/circle.jac

@@ -63,15 +63,15 @@ with entry:__main__ {
 glob expected_area = 78.53981633974483;
 
 test calc_area {
-    check assertAlmostEqual(calculate_area(RAD), expected_area);
+    check almostEqual(calculate_area(RAD), expected_area);
 }
 
 test circle_area {
     c = Circle(RAD);
-    check assertAlmostEqual(c.area(), expected_area);
+    check almostEqual(c.area(), expected_area);
 }
 
 test circle_type {
     c = Circle(RAD);
-    check assertEqual(c.shape_type, ShapeType.CIRCLE);
+    check c.shape_type == ShapeType.CIRCLE;
 }

jaclang/langserve/tests/fixtures/circle_err.jac

@@ -59,15 +59,15 @@ print(f"Area of a {c.shape_type.value} with radius {RAD} using class: {c.area()}
 glob expected_area = 78.53981633974483;
 
 test calc_area   {
-    check assertAlmostEqual(calculate_area(RAD), expected_area);
+    check almostEqual(calculate_area(RAD), expected_area);
 }
 
 test circle_area   {
     c = Circle(RAD);
-    check assertAlmostEqual(c.area(), expected_area);
+    check almostEqual(c.area(), expected_area);
 }
 
 test circle_type   {
     c = Circle(RAD);
-    check assertEqual(c.shape_type, ShapeType.CIRCLE);
+    check c.shape_type == ShapeType.CIRCLE;
 }

jaclang/langserve/tests/fixtures/circle_pure.test.jac

@@ -1,15 +1,15 @@
 glob expected_area = 78.53981633974483;
 
 test a1 {
-    check assertAlmostEqual(calculate_area(RAD), expected_area);
+    check almostEqual(calculate_area(RAD), expected_area);
 }
 
 test a2 {
     c = Circle(RAD);
-    check assertAlmostEqual(c.area(), expected_area);
+    check almostEqual(c.area(), expected_area);
 }
 
 test a3 {
     c = Circle(RAD);
-    check assertEqual(c.shape_type, ShapeType.CIRCLE);
+    check c.shape_type == ShapeType.CIRCLE;
 }

jaclang/langserve/tests/fixtures/import_include_statements.jac

@@ -1,6 +1,6 @@
 import:py os;
 import:py from math, sqrt as square_root;
 import:py datetime as dt;
-import:jac from base_module_structure, add_numbers as adsd, subtract,x,Colorenum as clr;
+import:jac from base_module_structure, add as add_numbers , subtract,x,Colorenum as clr;
 import:jac base_module_structure as base_module_structure;
 import:py from py_import,add1 as ss, sub1 as subtract1,apple,Orange1;

jaclang/langserve/tests/fixtures/rename.jac

@@ -0,0 +1,30 @@
+can foo;
+
+
+
+:can:foo{
+    print("foo");
+}
+
+
+obj out{
+    has cnt :int;
+    can bar;
+    can baz;
+}
+
+
+:obj:out:can:bar{
+    print("bar");
+}
+
+:obj:out:can:baz{
+    print("baz");
+}
+
+with entry{
+    foo();
+    new = out();
+    new.cnt;
+    out(1).bar();
+}