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

jaclang/langserve/tests/server_test/test_lang_serve.py

@@ -1,4 +1,5 @@
 """Test for Jac language server[VSCE] features"""
+
 import os
 import pytest
 
@@ -12,24 +13,22 @@ 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,
     get_jac_file_path,
+    get_simple_code,
     create_ls_with_workspace,  # new helper
 )
 from jaclang.vendor.pygls.uris import from_fs_path
 from jaclang.vendor.pygls.workspace import Workspace
+from jaclang import JacMachineInterface as _
+from jaclang.langserve.engine import JacLangServer
+from jaclang.langserve.server import did_open, did_save, did_change, formatting
 
 JAC_FILE = get_jac_file_path()
 
+
 class TestLangServe:
     """Test class for Jac language server features."""
 
@@ -96,7 +95,7 @@ class TestLangServe:
         temp_file_path = create_temp_jac_file(code)
         uri = from_fs_path(temp_file_path)
         ls.lsp._workspace = Workspace(os.path.dirname(temp_file_path), ls)
-    
+
         params = DidOpenTextDocumentParams(
             text_document=TextDocumentItem(
                 uri=uri,
@@ -131,7 +130,9 @@ class TestLangServe:
         ls.shutdown()
         assert hasattr(sem_tokens, "data")
         assert isinstance(sem_tokens.data, list)
-        assert len(sem_tokens.data) == 0 # TODO: we should retain the sem tokens, will be fixed in next PR 
+        assert (
+            len(sem_tokens.data) == 0
+        )  # TODO: we should retain the sem tokens, will be fixed in next PR
 
         os.remove(temp_file_path)
 
@@ -142,14 +143,17 @@ class TestLangServe:
         temp_file_path = create_temp_jac_file(code)
         uri, ls = create_ls_with_workspace(temp_file_path)
 
-        await did_open(ls, DidOpenTextDocumentParams(
-            text_document=TextDocumentItem(
-                uri=uri,
-                language_id="jac",
-                version=1,
-                text=code,
-            )
-        ))
+        await did_open(
+            ls,
+            DidOpenTextDocumentParams(
+                text_document=TextDocumentItem(
+                    uri=uri,
+                    language_id="jac",
+                    version=1,
+                    text=code,
+                )
+            ),
+        )
 
         params = DidSaveTextDocumentParams(
             text_document=TextDocumentItem(
@@ -167,12 +171,14 @@ class TestLangServe:
 
         # Now simulate a syntax error by updating the workspace and saving
         broken_code = get_code("error")
-        ls.workspace.put_text_document(TextDocumentItem(
-            uri=uri,
-            language_id="jac",
-            version=3,
-            text=broken_code,
-        ))
+        ls.workspace.put_text_document(
+            TextDocumentItem(
+                uri=uri,
+                language_id="jac",
+                version=3,
+                text=broken_code,
+            )
+        )
         params = DidSaveTextDocumentParams(
             text_document=TextDocumentItem(
                 uri=uri,
@@ -182,6 +188,9 @@ class TestLangServe:
             )
         )
         await did_save(ls, params)
+        sem_tokens = ls.get_semantic_tokens(uri)
+        # semantic tokens should still be present even if there is a syntax error
+        assert len(sem_tokens.data) == 300
         diagnostics = ls.diagnostics.get(uri, [])
         assert isinstance(diagnostics, list)
         assert len(diagnostics) == 1
@@ -197,26 +206,31 @@ class TestLangServe:
         temp_file_path = create_temp_jac_file(code)
         uri, ls = create_ls_with_workspace(temp_file_path)
 
-        await did_open(ls, DidOpenTextDocumentParams(
-            text_document=TextDocumentItem(
-                uri=uri,
-                language_id="jac",
-                version=1,
-                text=code,
-            )
-        ))
+        await did_open(
+            ls,
+            DidOpenTextDocumentParams(
+                text_document=TextDocumentItem(
+                    uri=uri,
+                    language_id="jac",
+                    version=1,
+                    text=code,
+                )
+            ),
+        )
 
         # No error, should be no diagnostics
         params = DidChangeTextDocumentParams(
             text_document=VersionedTextDocumentIdentifier(uri=uri, version=2),
-            content_changes=[{"text": "\n" + code}]
+            content_changes=[{"text": "\n" + code}],
+        )
+        ls.workspace.put_text_document(
+            TextDocumentItem(
+                uri=uri,
+                language_id="jac",
+                version=2,
+                text="\n" + code,
+            )
         )
-        ls.workspace.put_text_document(TextDocumentItem(
-            uri=uri,
-            language_id="jac",
-            version=2,
-            text="\n" + code,
-        ))
         await did_change(ls, params)
         diagnostics = ls.diagnostics.get(uri, [])
         assert isinstance(diagnostics, list)
@@ -227,15 +241,20 @@ class TestLangServe:
         error_code = "\nerror"
         params = DidChangeTextDocumentParams(
             text_document=VersionedTextDocumentIdentifier(uri=uri, version=3),
-            content_changes=[{"text": error_code + code}]
+            content_changes=[{"text": error_code + code}],
+        )
+        ls.workspace.put_text_document(
+            TextDocumentItem(
+                uri=uri,
+                language_id="jac",
+                version=3,
+                text=error_code + code,
+            )
         )
-        ls.workspace.put_text_document(TextDocumentItem(
-            uri=uri,
-            language_id="jac",
-            version=3,
-            text=error_code + code,
-        ))
         await did_change(ls, params)
+        sem_tokens = ls.get_semantic_tokens(uri)
+        # semantic tokens should still be present even if there is a syntax error
+        assert len(sem_tokens.data) == 300
         diagnostics = ls.diagnostics.get(uri, [])
         assert isinstance(diagnostics, list)
         assert len(diagnostics) == 1
@@ -251,12 +270,84 @@ class TestLangServe:
         uri, ls = create_ls_with_workspace(temp_file_path)
         params = DocumentFormattingParams(
             text_document=TextDocumentIdentifier(uri=uri),
-            options={"tabSize": 4, "insertSpaces": True}
+            options={"tabSize": 4, "insertSpaces": True},
         )
         edits = formatting(ls, params)
         assert isinstance(edits, list)
         assert isinstance(edits[0], TextEdit)
-        assert len(edits[0].new_text) > 100  # it is a random number to check if the text is changed
+        assert (
+            len(edits[0].new_text) > 100
+        )  # it is a random number to check if the text is changed
         print(edits[0].new_text)
         ls.shutdown()
-        os.remove(temp_file_path)
+        os.remove(temp_file_path)
+
+    @pytest.mark.asyncio
+    async def test_multifile_workspace(self):
+        """Test opening multiple Jac files in a workspace."""
+        code1 = get_simple_code("")
+        code2 = get_simple_code("error")
+        temp_file_path1 = create_temp_jac_file(code1)
+        temp_file_path2 = create_temp_jac_file(code2)
+
+        uri1, ls = create_ls_with_workspace(temp_file_path1)
+        uri2 = from_fs_path(temp_file_path2)
+
+        await did_open(
+            ls,
+            DidOpenTextDocumentParams(
+                text_document=TextDocumentItem(
+                    uri=uri1,
+                    language_id="jac",
+                    version=1,
+                    text=code1,
+                )
+            ),
+        )
+        await did_open(
+            ls,
+            DidOpenTextDocumentParams(
+                text_document=TextDocumentItem(
+                    uri=uri2,
+                    language_id="jac",
+                    version=1,
+                    text=code2,
+                )
+            ),
+        )
+
+        diagnostics1 = ls.diagnostics.get(uri1, [])
+        diagnostics2 = ls.diagnostics.get(uri2, [])
+        assert len(diagnostics1) == 0
+        assert len(diagnostics2) == 1
+        assert diagnostics2[0].message == "Syntax Error"
+
+        before_sem_tokens_1 = ls.get_semantic_tokens(uri1)
+        before_sem_tokens_2 = ls.get_semantic_tokens(uri2)
+        assert len(before_sem_tokens_1.data) == 15
+        assert len(before_sem_tokens_2.data) == 0
+
+        changed_code = get_simple_code("glob x = 90;")
+        ls.workspace.put_text_document(
+            TextDocumentItem(
+                uri=uri1,
+                language_id="jac",
+                version=2,
+                text=changed_code,
+            )
+        )
+        params = DidChangeTextDocumentParams(
+            text_document=VersionedTextDocumentIdentifier(uri=uri1, version=2),
+            content_changes=[{"text": changed_code}],
+        )
+        await did_change(ls, params)
+
+        after_sem_tokens_1 = ls.get_semantic_tokens(uri1)
+        after_sem_tokens_2 = ls.get_semantic_tokens(uri2)
+
+        assert len(after_sem_tokens_1.data) == 20
+        assert len(after_sem_tokens_2.data) == 0
+
+        ls.shutdown()
+        os.remove(temp_file_path1)
+        os.remove(temp_file_path2)

jaclang/langserve/tests/server_test/utils.py

@@ -1,29 +1,37 @@
 """Unit test utilities for JacLangServer."""
+
 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
 
+
 def get_jac_file_path():
     """Return the absolute path to the sample Jac file used for testing."""
     return os.path.abspath(
-        os.path.join(os.path.dirname(__file__), "../../../../examples/manual_code/circle.jac")
+        os.path.join(
+            os.path.dirname(__file__), "../../../../examples/manual_code/circle.jac"
+        )
     )
 
+
 def create_temp_jac_file(initial_content: str = "") -> str:
     """Create a temporary Jac file with optional initial content and return its path."""
-    temp = tempfile.NamedTemporaryFile(delete=False, suffix=".jac", mode="w", encoding="utf-8")
+    temp = tempfile.NamedTemporaryFile(
+        delete=False, suffix=".jac", mode="w", encoding="utf-8"
+    )
     temp.write(initial_content)
     temp.close()
     return temp.name
 
+
 def get_code(code: str) -> str:
     """Generate a sample Jac code snippet with optional test code injected."""
-    jac_code = dedent(f'''
+    jac_code = dedent(
+        f'''
     """
     This module demonstrates a simple circle class and a function to calculate
     the area of a circle in all of Jac's glory.
@@ -104,12 +112,33 @@ def get_code(code: str) -> str:
         c = Circle(RAD);
         check c.shape_type == ShapeType.CIRCLE;
     }}
-''')
+'''
+    )
     return jac_code
 
+
+def get_simple_code(code: str) -> str:
+    """Generate a sample Jac code snippet with optional test code injected."""
+    jac_code = dedent(
+        f"""
+    
+    # Unit Tests!
+    glob expected_area0 = 78.53981633974483;
+    glob expected_area1 = 78.53981633974483;
+    {code}
+    glob expected_area2 = 78.53981633974483;
+
+
+"""
+    )
+    return jac_code
+
+
 def create_ls_with_workspace(file_path: str):
     """Create JacLangServer and workspace for a given file path, return (uri, ls)."""
+    from jaclang.langserve.engine import JacLangServer
+
     ls = JacLangServer()
     uri = from_fs_path(file_path)
     ls.lsp._workspace = Workspace(os.path.dirname(file_path), ls)
-    return uri, ls
+    return uri, ls

jaclang/langserve/tests/session.jac

@@ -0,0 +1,294 @@
+"""Provides LSP session helpers for testing."""
+
+import os;
+import subprocess;
+import sys;
+import from concurrent.futures { Future, ThreadPoolExecutor } 
+import from threading { Event } 
+
+import from pylsp_jsonrpc.dispatchers { MethodDispatcher } 
+import from pylsp_jsonrpc.endpoint { Endpoint } 
+import from pylsp_jsonrpc.streams { JsonRpcStreamReader, JsonRpcStreamWriter } 
+
+import defaults;
+
+
+with entry {
+    LSP_EXIT_TIMEOUT = 5000;
+    PUBLISH_DIAGNOSTICS = 'textDocument/publishDiagnostics';
+    WINDOW_LOG_MESSAGE = 'window/logMessage';
+    WINDOW_SHOW_MESSAGE = 'window/showMessage';
+}
+
+
+"""Send and Receive messages over LSP as a test LS Client."""
+class LspSession (MethodDispatcher) {
+    def init(self: LspSession, cwd: Any = None) {
+        self.cwd = cwd if cwd else os.getcwd() ;
+        self._thread_pool = ThreadPoolExecutor();
+        self._sub = None;
+        self._writer = None;
+        self._reader = None;
+        self._endpoint = None;
+        self._notification_callbacks = {};
+    }
+    
+    """Context manager entrypoint.\n\n        shell=True needed for pytest-cov to work in subprocess.\n        """
+    def __enter__(self: LspSession) {
+        self._sub = subprocess.Popen(
+            ["jac", "run",
+            os.path.join(os.path.dirname(os.path.dirname(__file__)), 'server.jac')],
+            stdout=subprocess.PIPE,
+            stdin=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+            bufsize=0,
+            cwd=self.cwd,
+            env=os.environ,
+            shell=('WITH_COVERAGE' in os.environ)
+        );
+        self._writer = JsonRpcStreamWriter(os.fdopen(self._sub.stdin.fileno(), 'wb'));
+        self._reader = JsonRpcStreamReader(os.fdopen(self._sub.stdout.fileno(), 'rb'));
+        dispatcher = 
+        {PUBLISH_DIAGNOSTICS : self._publish_diagnostics , WINDOW_SHOW_MESSAGE : self._window_show_message , WINDOW_LOG_MESSAGE : self._window_log_message };
+        self._endpoint = Endpoint(dispatcher, self._writer.write);
+        self._thread_pool.submit(self._reader.listen, self._endpoint.consume);
+        return self;
+    }
+    
+    def __exit__(self: LspSession, typ: Any, value: Any, _tb: Any) {
+        self.shutdown(True);
+        try {
+            self._sub.terminate();
+        } except Exception as e {
+            
+        }
+        
+        self._endpoint.shutdown();
+        self._thread_pool.shutdown();
+    }
+    
+    """Sends the initialize request to LSP server."""
+    def initialize(
+        self: LspSession,
+        initialize_params: Any = None,
+        process_server_capabilities: Any = None
+    ) {
+        server_initialized = Event();
+        def _after_initialize(fut: Any) {
+            if process_server_capabilities {
+                process_server_capabilities(fut.result());
+            }
+            self.initialized();
+            server_initialized.set();
+        }
+        self._send_request(
+            'initialize',
+            params=initialize_params
+            if (initialize_params is not None)
+            else defaults.VSCODE_DEFAULT_INITIALIZE
+            ,
+            handle_response=_after_initialize
+        );
+        server_initialized.wait();
+    }
+    
+    """Sends the initialized notification to LSP server."""
+    def initialized(self: LspSession, initialized_params: Any = None) {
+        if (initialized_params is None) {
+            initialized_params = {};
+        }
+        self._endpoint.notify('initialized', initialized_params);
+    }
+    
+    """Sends the shutdown request to LSP server."""
+    def shutdown(
+        self: LspSession,
+        should_exit: Any,
+        exit_timeout: Any = LSP_EXIT_TIMEOUT
+    ) {
+        def _after_shutdown(_: Any) {
+            if should_exit {
+                self.exit_lsp(exit_timeout);
+            }
+        }
+        self._send_request('shutdown', handle_response=_after_shutdown);
+    }
+    
+    """Handles LSP server process exit."""
+    def exit_lsp(self: LspSession, exit_timeout: Any = LSP_EXIT_TIMEOUT) {
+        self._endpoint.notify('exit');
+        assert (self._sub.wait(exit_timeout) == 0) ;
+    }
+    
+    """Sends text document completion request to LSP server."""
+    def text_document_completion(self: LspSession, completion_params: Any) {
+        fut = self._send_request('textDocument/completion', params=completion_params);
+        return fut.result();
+    }
+    
+    """Sends text document rename request to LSP server."""
+    def text_document_rename(self: LspSession, rename_params: Any) {
+        fut = self._send_request('textDocument/rename', params=rename_params);
+        return fut.result();
+    }
+    
+    """Sends text document code action request to LSP server."""
+    def text_document_code_action(self: LspSession, code_action_params: Any) {
+        fut = self._send_request('textDocument/codeAction', params=code_action_params);
+        return fut.result();
+    }
+    
+    """Sends text document hover request to LSP server."""
+    def text_document_hover(self: LspSession, hover_params: Any) {
+        fut = self._send_request('textDocument/hover', params=hover_params);
+        return fut.result();
+    }
+    
+    """Sends text document formatting request to LSP server."""
+    def text_document_formatting(self: LspSession, formatting_params: Any) {
+        fut = self._send_request('textDocument/formatting', params=formatting_params);
+        return fut.result();
+    }
+    
+    """Sends text document hover request to LSP server."""
+    def text_document_signature_help(self: LspSession, signature_help_params: Any) {
+        fut = self._send_request(
+            'textDocument/signatureHelp',
+            params=signature_help_params
+        );
+        return fut.result();
+    }
+    
+    """Sends text document declaration request to LSP server."""
+    def text_document_declaration(self: LspSession, declaration_params: Any) {
+        fut = self._send_request('textDocument/declaration', params=declaration_params);
+        return fut.result();
+    }
+    
+    """Sends text document definition request to LSP server."""
+    def text_document_definition(self: LspSession, definition_params: Any) {
+        fut = self._send_request('textDocument/definition', params=definition_params);
+        return fut.result();
+    }
+    
+    """Sends text document symbol request to LSP server."""
+    def text_document_symbol(self: LspSession, document_symbol_params: Any) {
+        fut = self._send_request(
+            'textDocument/documentSymbol',
+            params=document_symbol_params
+        );
+        return fut.result();
+    }
+    
+    """Sends text document highlight request to LSP server."""
+    def text_document_highlight(self: LspSession, document_highlight_params: Any) {
+        fut = self._send_request(
+            'textDocument/documentHighlight',
+            params=document_highlight_params
+        );
+        return fut.result();
+    }
+    
+    """Sends text document references request to LSP server."""
+    def text_document_references(self: LspSession, references_params: Any) {
+        fut = self._send_request('textDocument/references', params=references_params);
+        return fut.result();
+    }
+    
+    """Sends workspace symbol request to LSP server."""
+    def workspace_symbol(self: LspSession, workspace_symbol_params: Any) {
+        fut = self._send_request('workspace/symbol', params=workspace_symbol_params);
+        return fut.result();
+    }
+    
+    """Sends completion item resolve request to LSP server."""
+    def completion_item_resolve(self: LspSession, resolve_params: Any) {
+        fut = self._send_request('completionItem/resolve', params=resolve_params);
+        return fut.result();
+    }
+    
+    """Sends did change notification to LSP Server."""
+    def notify_did_change(self: LspSession, did_change_params: Any) {
+        self._send_notification('textDocument/didChange', params=did_change_params);
+    }
+    
+    """Sends did save notification to LSP Server."""
+    def notify_did_save(self: LspSession, did_save_params: Any) {
+        self._send_notification('textDocument/didSave', params=did_save_params);
+    }
+    
+    """Sends did open notification to LSP Server."""
+    def notify_did_open(self: LspSession, did_open_params: Any) {
+        self._send_notification('textDocument/didOpen', params=did_open_params);
+    }
+    
+    """Set custom LS notification handler."""
+    def set_notification_callback(
+        self: LspSession,
+        notification_name: Any,
+        callback: Any
+    ) {
+        self._notification_callbacks[notification_name] = callback;
+    }
+    
+    """Gets callback if set or default callback for a given LS notification."""
+    def get_notification_callback(self: LspSession, notification_name: Any) {
+        try {
+            return self._notification_callbacks[notification_name];
+        } except KeyError {
+            def _default_handler(_params: Any) -> None {}
+            return _default_handler;
+        }
+        
+    }
+    
+    """Internal handler for text document publish diagnostics."""
+    def _publish_diagnostics(self: LspSession, publish_diagnostics_params: Any) {
+        return self._handle_notification(
+            PUBLISH_DIAGNOSTICS,
+            publish_diagnostics_params
+        );
+    }
+    
+    """Internal handler for window log message."""
+    def _window_log_message(self: LspSession, window_log_message_params: Any) {
+        return self._handle_notification(WINDOW_LOG_MESSAGE, window_log_message_params);
+    }
+    
+    """Internal handler for window show message."""
+    def _window_show_message(self: LspSession, window_show_message_params: Any) {
+        return self._handle_notification(
+            WINDOW_SHOW_MESSAGE,
+            window_show_message_params
+        );
+    }
+    
+    """Internal handler for notifications."""
+    def _handle_notification(self: LspSession, notification_name: Any, params: Any) {
+        fut = Future();
+        def _handler() {
+            callback = self.get_notification_callback(notification_name);
+            callback(params);
+            fut.set_result(None);
+        }
+        self._thread_pool.submit(_handler);
+        return fut;
+    }
+    
+    """Sends {name} request to the LSP server."""
+    def _send_request(
+        self: LspSession,
+        name: Any,
+        params: Any = None,
+        handle_response: Any = lambda  f: Any: f.done()
+    ) {
+        fut = self._endpoint.request(name, params);
+        fut.add_done_callback(handle_response);
+        return fut;
+    }
+    
+    """Sends {name} notification to the LSP server."""
+    def _send_notification(self: LspSession, name: Any, params: Any = None) {
+        self._endpoint.notify(name, params);
+    }
+}

jaclang/langserve/tests/test_sem_tokens.py

@@ -2,9 +2,9 @@
 
 import copy
 import lsprotocol.types as lspt
-
-from jaclang.langserve.sem_manager import SemTokManager
+from jaclang import JacMachineInterface as _
 from jaclang.utils.test import TestCase
+from jaclang.langserve.sem_manager import SemTokManager
 
 from typing import Tuple