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

jaclang/langserve/engine.py

@@ -5,23 +5,26 @@ from __future__ import annotations
 import asyncio
 import logging
 from concurrent.futures import ThreadPoolExecutor
-from enum import IntEnum
-from typing import Optional
+from typing import Callable, Optional
 
 
 import jaclang.compiler.absyntree as ast
-from jaclang.compiler.compile import jac_ir_to_pass, jac_str_to_pass
+from jaclang.compiler.compile import jac_str_to_pass
 from jaclang.compiler.parser import JacParser
 from jaclang.compiler.passes import Pass
-from jaclang.compiler.passes.main.schedules import type_checker_sched
+from jaclang.compiler.passes.main.schedules import py_code_gen_typed
 from jaclang.compiler.passes.tool import FuseCommentsPass, JacFormatPass
-from jaclang.compiler.passes.transform import Alert
 from jaclang.langserve.utils import (
+    collect_all_symbols_in_scope,
     collect_symbols,
     create_range,
     find_deepest_symbol_node_at_pos,
+    gen_diagnostics,
     get_item_path,
     get_mod_path,
+    locate_affected_token,
+    parse_symbol_path,
+    resolve_completion_symbol_table,
 )
 from jaclang.vendor.pygls import uris
 from jaclang.vendor.pygls.server import LanguageServer
@@ -29,32 +32,17 @@ from jaclang.vendor.pygls.server import LanguageServer
 import lsprotocol.types as lspt
 
 
-class ALev(IntEnum):
-    """Analysis Level successfully completed."""
-
-    QUICK = 1
-    DEEP = 2
-    TYPE = 3
-
-
 class ModuleInfo:
     """Module IR and Stats."""
 
     def __init__(
         self,
         ir: ast.Module,
-        errors: list[Alert],
-        warnings: list[Alert],
-        alev: ALev,
-        parent: Optional[ModuleInfo] = None,
+        impl_parent: Optional[ModuleInfo] = None,
     ) -> None:
         """Initialize module info."""
         self.ir = ir
-        self.errors = errors
-        self.warnings = warnings
-        self.alev = alev
-        self.parent: Optional[ModuleInfo] = parent
-        self.diagnostics = self.gen_diagnostics()
+        self.impl_parent: Optional[ModuleInfo] = impl_parent
         self.sem_tokens: list[int] = self.gen_sem_tokens()
 
     @property
@@ -62,57 +50,6 @@ class ModuleInfo:
         """Return uri."""
         return uris.from_fs_path(self.ir.loc.mod_path)
 
-    def update_with(
-        self,
-        build: Pass,
-        alev: ALev,
-        refresh: bool = False,
-        mod_override: Optional[ast.Module] = None,
-    ) -> None:
-        """Update module info."""
-        target_mod = mod_override if mod_override else build.ir
-        if not isinstance(target_mod, ast.Module):
-            return
-        self.ir = target_mod  # if alev > ALev.QUICK else self.ir
-        if refresh:
-            self.errors = build.errors_had
-            self.warnings = build.warnings_had
-        else:
-            self.errors += [
-                i
-                for i in build.errors_had
-                if i not in self.errors
-                if i.loc.mod_path == target_mod.loc.mod_path
-            ]
-            self.warnings += [
-                i
-                for i in build.warnings_had
-                if i not in self.warnings
-                if i.loc.mod_path == target_mod.loc.mod_path
-            ]
-        self.alev = alev
-        self.diagnostics = self.gen_diagnostics()
-        if self.alev == ALev.TYPE:
-            self.sem_tokens = self.gen_sem_tokens()
-
-    def gen_diagnostics(self) -> list[lspt.Diagnostic]:
-        """Return diagnostics."""
-        return [
-            lspt.Diagnostic(
-                range=create_range(error.loc),
-                message=error.msg,
-                severity=lspt.DiagnosticSeverity.Error,
-            )
-            for error in self.errors
-        ] + [
-            lspt.Diagnostic(
-                range=create_range(warning.loc),
-                message=warning.msg,
-                severity=lspt.DiagnosticSeverity.Warning,
-            )
-            for warning in self.warnings
-        ]
-
     def gen_sem_tokens(self) -> list[int]:
         """Return semantic tokens."""
         tokens = []
@@ -134,6 +71,76 @@ class ModuleInfo:
                 prev_line, prev_col = line, col_start
         return tokens
 
+    def update_sem_tokens(
+        self, content_changes: lspt.DidChangeTextDocumentParams
+    ) -> 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
+
+            line_delta = change.text.count("\n") - (change_end_line - change_start_line)
+            if line_delta == 0:
+                char_delta = len(change.text) - (change_end_char - change_start_char)
+            else:
+                last_newline_index = change.text.rfind("\n")
+                char_delta = (
+                    len(change.text)
+                    - last_newline_index
+                    - 1
+                    - change_end_char
+                    + change_start_char
+                )
+
+            changed_token_index = locate_affected_token(
+                self.sem_tokens,
+                change_start_line,
+                change_start_char,
+                change_end_line,
+                change_end_char,
+            )
+            if changed_token_index:
+                self.sem_tokens[changed_token_index + 2] = max(
+                    1, self.sem_tokens[changed_token_index + 2] + char_delta
+                )
+                if (
+                    len(self.sem_tokens) > changed_token_index + 5
+                    and self.sem_tokens[changed_token_index + 5] == 0
+                ):
+                    next_token_index = changed_token_index + 5
+                    self.sem_tokens[next_token_index + 1] = max(
+                        0, self.sem_tokens[next_token_index + 1] + char_delta
+                    )
+                    return self.sem_tokens
+
+            current_token_index = 0
+            line_offset = 0
+            while current_token_index < len(self.sem_tokens):
+                token_line_number = self.sem_tokens[current_token_index] + line_offset
+                token_start_pos = self.sem_tokens[current_token_index + 1]
+
+                if token_line_number > change_start_line or (
+                    token_line_number == change_start_line
+                    and token_start_pos >= change_start_char
+                ):
+                    self.sem_tokens[current_token_index] += line_delta
+                    if token_line_number == change_start_line:
+                        self.sem_tokens[current_token_index + 1] += char_delta
+                    if token_line_number > change_end_line or (
+                        token_line_number == change_end_line
+                        and token_start_pos >= change_end_char
+                    ):
+                        break
+                line_offset += self.sem_tokens[current_token_index]
+                current_token_index += 5
+        return self.sem_tokens
+
 
 class JacLangServer(LanguageServer):
     """Class for managing workspace."""
@@ -143,68 +150,26 @@ class JacLangServer(LanguageServer):
         super().__init__("jac-lsp", "v0.1")
         self.modules: dict[str, ModuleInfo] = {}
         self.executor = ThreadPoolExecutor()
-
-    async def push_diagnostics(self, file_path: str) -> None:
-        """Push diagnostics for a file."""
-        if file_path in self.modules:
-            self.publish_diagnostics(
-                file_path,
-                self.modules[file_path].diagnostics,
-            )
-
-    def unwind_to_parent(self, file_path: str) -> str:
-        """Unwind to parent."""
-        orig_file_path = file_path
-        if file_path in self.modules:
-            while cur := self.modules[file_path].parent:
-                file_path = cur.uri
-            if file_path == orig_file_path and (
-                discover := self.modules[file_path].ir.annexable_by
-            ):
-                file_path = uris.from_fs_path(discover)
-                self.quick_check(file_path)
-        return file_path
+        self.tasks: dict[str, asyncio.Task] = {}
 
     def update_modules(
-        self, file_path: str, build: Pass, alev: ALev, refresh: bool = False
+        self, file_path: str, build: Pass, refresh: bool = False
     ) -> None:
         """Update modules."""
         if not isinstance(build.ir, ast.Module):
             self.log_error("Error with module build.")
             return
-        if file_path in self.modules:
-            self.modules[file_path].update_with(build, alev, refresh=refresh)
-        else:
-            self.modules[file_path] = ModuleInfo(
-                ir=build.ir,
-                errors=[
-                    i
-                    for i in build.errors_had
-                    if i.loc.mod_path == uris.to_fs_path(file_path)
-                ],
-                warnings=[
-                    i
-                    for i in build.warnings_had
-                    if i.loc.mod_path == uris.to_fs_path(file_path)
-                ],
-                alev=alev,
-            )
+        keep_parent = (
+            self.modules[file_path].impl_parent if file_path in self.modules else None
+        )
+        self.modules[file_path] = ModuleInfo(ir=build.ir, impl_parent=keep_parent)
         for p in build.ir.mod_deps.keys():
             uri = uris.from_fs_path(p)
-            if not refresh and uri in self.modules:
-                self.modules[uri].update_with(
-                    build, alev, mod_override=build.ir.mod_deps[p], refresh=refresh
-                )
-            else:
+            if file_path != uri:
                 self.modules[uri] = ModuleInfo(
                     ir=build.ir.mod_deps[p],
-                    errors=[i for i in build.errors_had if i.loc.mod_path == p],
-                    warnings=[i for i in build.warnings_had if i.loc.mod_path == p],
-                    alev=alev,
+                    impl_parent=self.modules[file_path],
                 )
-            self.modules[uri].parent = (
-                self.modules[file_path] if file_path != uri else None
-            )
 
     def quick_check(self, file_path: str) -> bool:
         """Rebuild a file."""
@@ -213,72 +178,107 @@ class JacLangServer(LanguageServer):
             build = jac_str_to_pass(
                 jac_str=document.source, file_path=document.path, schedule=[]
             )
+            self.publish_diagnostics(
+                file_path,
+                gen_diagnostics(file_path, build.errors_had, build.warnings_had),
+            )
+            return len(build.errors_had) == 0
         except Exception as e:
             self.log_error(f"Error during syntax check: {e}")
             return False
-        self.update_modules(file_path, build, ALev.QUICK, refresh=True)
-        return len(self.modules[file_path].errors) == 0
 
-    def deep_check(self, file_path: str) -> bool:
+    def deep_check(self, file_path: str, annex_view: Optional[str] = None) -> bool:
         """Rebuild a file and its dependencies."""
-        if file_path not in self.modules:
-            self.quick_check(file_path)
         try:
-            file_path = self.unwind_to_parent(file_path)
-            build = jac_ir_to_pass(ir=self.modules[file_path].ir)
-        except Exception as e:
-            self.log_error(f"Error during syntax check: {e}")
-            return False
-        self.update_modules(file_path, build, ALev.DEEP)
-        return len(self.modules[file_path].errors) == 0
+            document = self.workspace.get_text_document(file_path)
+            if file_path in self.modules and (
+                parent := self.modules[file_path].impl_parent
+            ):
+                return self.deep_check(
+                    uris.from_fs_path(parent.ir.loc.mod_path), annex_view=file_path
+                )
+            build = jac_str_to_pass(
+                jac_str=document.source,
+                file_path=document.path,
+                schedule=py_code_gen_typed,
+            )
+            self.update_modules(file_path, build)
+            if discover := self.modules[file_path].ir.annexable_by:
+                return self.deep_check(
+                    uris.from_fs_path(discover), annex_view=file_path
+                )
 
-    def type_check(self, file_path: str) -> bool:
-        """Rebuild a file and its dependencies."""
-        if file_path not in self.modules:
-            self.deep_check(file_path)
-        try:
-            file_path = self.unwind_to_parent(file_path)
-            build = jac_ir_to_pass(
-                ir=self.modules[file_path].ir, schedule=type_checker_sched
+            self.publish_diagnostics(
+                file_path,
+                gen_diagnostics(
+                    annex_view if annex_view else file_path,
+                    build.errors_had,
+                    build.warnings_had,
+                ),
             )
+            return len(build.errors_had) == 0
         except Exception as e:
-            self.log_error(f"Error during type check: {e}")
+            self.log_error(f"Error during deep check: {e}")
             return False
-        self.update_modules(file_path, build, ALev.TYPE)
-        return len(self.modules[file_path].errors) == 0
 
-    async def analyze_and_publish(self, uri: str, level: int = 2) -> None:
+    async def launch_quick_check(self, uri: str) -> None:
         """Analyze and publish diagnostics."""
-        self.log_py(f"Analyzing {uri}...")
-        success = await asyncio.get_event_loop().run_in_executor(
+        await asyncio.get_event_loop().run_in_executor(
             self.executor, self.quick_check, uri
         )
-        await self.push_diagnostics(uri)
-        if success and level > 0:
-            success = await asyncio.get_event_loop().run_in_executor(
-                self.executor, self.deep_check, uri
-            )
-            await self.push_diagnostics(uri)
-            if level > 1:
-                await asyncio.get_event_loop().run_in_executor(
-                    self.executor, self.type_check, uri
-                )
-                await self.push_diagnostics(uri)
+
+    async def launch_deep_check(self, uri: str) -> None:
+        """Analyze and publish diagnostics."""
+
+        async def run_in_executor(
+            func: Callable[[str, Optional[str]], bool],
+            file_path: str,
+            annex_view: Optional[str] = None,
+        ) -> None:
+            loop = asyncio.get_event_loop()
+            await loop.run_in_executor(self.executor, func, file_path, annex_view)
+
+        if uri in self.tasks and not self.tasks[uri].done():
+            self.log_py(f"Canceling {uri} deep check...")
+            self.tasks[uri].cancel()
+            del self.tasks[uri]
+        self.log_py(f"Analyzing {uri}...")
+        task = asyncio.create_task(run_in_executor(self.deep_check, uri))
+        self.tasks[uri] = task
+        await task
 
     def get_completion(
-        self, file_path: str, position: lspt.Position
+        self, file_path: str, position: lspt.Position, completion_trigger: Optional[str]
     ) -> lspt.CompletionList:
         """Return completion for a file."""
-        items = []
+        completion_items = []
         document = self.workspace.get_text_document(file_path)
-        current_line = document.lines[position.line].strip()
-        if current_line.endswith("hello."):
+        current_line = document.lines[position.line]
+        current_pos = position.character
+        current_symbol_path = parse_symbol_path(current_line, current_pos)
+        node_selected = find_deepest_symbol_node_at_pos(
+            self.modules[file_path].ir,
+            position.line,
+            position.character - 2,
+        )
 
-            items = [
-                lspt.CompletionItem(label="world"),
-                lspt.CompletionItem(label="friend"),
-            ]
-        return lspt.CompletionList(is_incomplete=False, items=items)
+        mod_tab = (
+            self.modules[file_path].ir.sym_tab
+            if not node_selected
+            else node_selected.sym_tab
+        )
+        current_tab = self.modules[file_path].ir._sym_tab
+        current_symbol_table = mod_tab
+        if completion_trigger == ".":
+            completion_items = resolve_completion_symbol_table(
+                mod_tab, current_symbol_path, current_tab
+            )
+        else:
+            try:  # noqa SIM105
+                completion_items = collect_all_symbols_in_scope(current_symbol_table)
+            except AttributeError:
+                pass
+        return lspt.CompletionList(is_incomplete=False, items=completion_items)
 
     def rename_module(self, old_path: str, new_path: str) -> None:
         """Rename module."""
@@ -325,6 +325,8 @@ class JacLangServer(LanguageServer):
         self, file_path: str, position: lspt.Position
     ) -> Optional[lspt.Hover]:
         """Return hover information for a file."""
+        if file_path not in self.modules:
+            return None
         node_selected = find_deepest_symbol_node_at_pos(
             self.modules[file_path].ir, position.line, position.character
         )
@@ -371,6 +373,8 @@ class JacLangServer(LanguageServer):
         self, file_path: str, position: lspt.Position
     ) -> Optional[lspt.Location]:
         """Return definition location for a file."""
+        if file_path not in self.modules:
+            return None
         node_selected: Optional[ast.AstSymbolNode] = find_deepest_symbol_node_at_pos(
             self.modules[file_path].ir, position.line, position.character
         )

jaclang/langserve/server.py

@@ -9,7 +9,6 @@ from jaclang.compiler.constant import (
     JacSemTokenType as SemTokType,
 )
 from jaclang.langserve.engine import JacLangServer
-from jaclang.langserve.utils import debounce
 
 import lsprotocol.types as lspt
 
@@ -20,18 +19,19 @@ server = JacLangServer()
 @server.feature(lspt.TEXT_DOCUMENT_DID_SAVE)
 async def did_open(ls: JacLangServer, params: lspt.DidOpenTextDocumentParams) -> None:
     """Check syntax on change."""
-    await ls.analyze_and_publish(params.text_document.uri)
+    await ls.launch_deep_check(params.text_document.uri)
     ls.lsp.send_request(lspt.WORKSPACE_SEMANTIC_TOKENS_REFRESH)
 
 
 @server.feature(lspt.TEXT_DOCUMENT_DID_CHANGE)
-@debounce(0.3)
 async def did_change(
     ls: JacLangServer, params: lspt.DidChangeTextDocumentParams
 ) -> None:
     """Check syntax on change."""
-    await ls.analyze_and_publish(params.text_document.uri, level=1)
-    ls.lsp.send_request(lspt.WORKSPACE_SEMANTIC_TOKENS_REFRESH)
+    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)
+        ls.lsp.send_request(lspt.WORKSPACE_SEMANTIC_TOKENS_REFRESH)
 
 
 @server.feature(lspt.TEXT_DOCUMENT_FORMATTING)
@@ -86,11 +86,15 @@ def did_delete_files(ls: JacLangServer, params: lspt.DeleteFilesParams) -> None:
 
 @server.feature(
     lspt.TEXT_DOCUMENT_COMPLETION,
-    lspt.CompletionOptions(trigger_characters=[".", ":", ""]),
+    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)
+    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))
@@ -134,6 +138,14 @@ 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)
 
 

jaclang/langserve/tests/fixtures/base_module_structure.jac

@@ -21,8 +21,34 @@ with entry:__main__ {
 
 glob x: int = 10;
 
-enum Color {
+enum Colorenum {
     RED,
     GREEN,
     BLUE
-}
+}
+
+obj Colour1 {
+    has color1: Colorenum,
+        point1: int;
+
+    can get_color1 -> Colorenum;
+}
+
+:obj:Colour1:can:get_color1 -> Colorenum {
+    return self.color;
+}
+
+obj red :Colour1: {
+    has base_colorred: Colorenum = Color.RED,
+        pointred: int = 10;
+    obj color2 {
+        has color22: Color = Colorenum.BLUE,
+            point22: int = 20;
+    }
+}
+
+with entry:__main__ {
+    r = red(color1=Color.GREEN, point1=20);
+    print(r.get_color1());
+    print(r.color2.color22);
+}

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 as adsd, subtract,x,Color as clr;
+import:jac from base_module_structure, add_numbers as adsd, 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;