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

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,12 +2,12 @@
 
 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 typing import Tuple
 
+SemTokManager = _.py_jac_import("..sem_manager", __file__, items={"SemTokManager": None})[0]
 
 class TestUpdateSemTokens(TestCase):
     """Test update semantic tokens"""
@@ -23,7 +23,7 @@ class TestUpdateSemTokens(TestCase):
 
         self.document_lines = [
             "",
-            "import:py math;",
+            "import math;",
             "",
             '"""Function to calculate the area of a circle."""',
             "can calculate_area(radius: float) -> float {",
@@ -264,7 +264,7 @@ class TestUpdateSemTokens(TestCase):
         )
         self.document_lines = [
             "",
-            "import:py math;",
+            "import math;",
             "",
             '"""Function to calculate the area of a circle."""',
             "can calculate_area(radius::= a + a // 2) > 5 {",

jaclang/langserve/tests/test_server.py

@@ -1,11 +1,17 @@
 from jaclang.utils.test import TestCase
 from jaclang.vendor.pygls import uris
 from jaclang.vendor.pygls.workspace import Workspace
-from jaclang.langserve.engine import JacLangServer
-from .session import LspSession
 
 import lsprotocol.types as lspt
+import pytest
+from jaclang import JacMachineInterface as _
 
+JacLangServer = _.py_jac_import(
+    "...langserve.engine", __file__, items={"JacLangServer": None}
+)[0]
+LspSession = _.py_jac_import(
+    "session", __file__, items={"LspSession": None}
+)[0]
 
 class TestJacLangServer(TestCase):
 
@@ -59,8 +65,9 @@ class TestJacLangServer(TestCase):
         lsp.deep_check(circle_impl_file)
         pos = lspt.Position(8, 11)
         self.assertIn(
-            "ability) calculate_area: float",
-            lsp.get_hover_info(circle_impl_file, pos).contents.value,
+            # "ability) calculate_area: float",
+            "ability) calculate_area\n( radius : float ) -> float",
+            lsp.get_hover_info(circle_impl_file, pos).contents.value.replace("'", ""),
         )
 
     def test_impl_auto_discover(self) -> None:
@@ -76,10 +83,12 @@ class TestJacLangServer(TestCase):
         lsp.deep_check(circle_impl_file)
         pos = lspt.Position(8, 11)
         self.assertIn(
-            "ability) calculate_area: float",
-            lsp.get_hover_info(circle_impl_file, pos).contents.value,
+            # "ability) calculate_area: float",
+            "(public ability) calculate_area\n( radius : float ) -> float",
+            lsp.get_hover_info(circle_impl_file, pos).contents.value.replace("'", ""),
         )
 
+    @pytest.mark.xfail(reason="TODO: Fix when we have the type checker")
     def test_show_type_impl(self) -> None:
         """Test that the server doesn't run if there is a syntax error."""
         lsp = JacLangServer()
@@ -114,7 +123,7 @@ class TestJacLangServer(TestCase):
         circle_file = uris.from_fs_path(self.fixture_abs_path("circle_pure.jac"))
         lsp.deep_check(circle_file)
         self.assertIn(
-            "fixtures/circle_pure.impl.jac:8:0-8:19",
+            "fixtures/circle_pure.impl.jac:8:5-8:19",
             str(lsp.get_definition(circle_file, lspt.Position(9, 16))),
         )
         self.assertIn(
@@ -129,12 +138,12 @@ class TestJacLangServer(TestCase):
         workspace = Workspace(workspace_path, lsp)
         lsp.lsp._workspace = workspace
         guess_game_file = uris.from_fs_path(
-            self.examples_abs_path("guess_game/guess_game4.jac")
+            self.examples_abs_path("guess_game/guess_game4.impl.jac")
         )
         lsp.deep_check(guess_game_file)
         self.assertIn(
-            "guess_game4.jac:27:8-27:21",
-            str(lsp.get_definition(guess_game_file, lspt.Position(46, 45))),
+            "guess_game4.jac:16:8-16:21",
+            str(lsp.get_definition(guess_game_file, lspt.Position(14, 45))),
         )
 
     def test_go_to_definition_method_manual_impl(self) -> None:
@@ -144,23 +153,22 @@ class TestJacLangServer(TestCase):
         workspace = Workspace(workspace_path, lsp)
         lsp.lsp._workspace = workspace
         decldef_file = uris.from_fs_path(
-            self.examples_abs_path("micro/decl_defs_impl.jac")
+            self.examples_abs_path("micro/decl_defs_main.impl.jac")
         )
         lsp.deep_check(decldef_file)
-        self.assertNotIn(
-            "decl_defs_main.jac:8:8-8:17",
-            str(lsp.get_definition(decldef_file, lspt.Position(2, 24))),
-        )
         decldef_main_file = uris.from_fs_path(
             self.examples_abs_path("micro/decl_defs_main.jac")
         )
         lsp.deep_check(decldef_main_file)
         lsp.deep_check(decldef_file)
         self.assertIn(
-            "decl_defs_main.jac:8:8-8:17",
-            str(lsp.get_definition(decldef_file, lspt.Position(2, 24))),
+            "decl_defs_main.jac:7:8-7:17",
+            str(lsp.get_definition(decldef_file, lspt.Position(2, 20))),
         )
 
+    @pytest.mark.xfail(
+        reason="TODO: Fix the go to definition for imports[ abs_path is not set]"
+    )
     def test_test_annex(self) -> None:
         """Test that the server doesn't run if there is a syntax error."""
         lsp = JacLangServer()
@@ -176,6 +184,9 @@ class TestJacLangServer(TestCase):
             lsp.get_hover_info(circle_file, pos).contents.value,
         )
 
+    @pytest.mark.xfail(
+        reason="TODO: Fix the go to definition for imports[ abs_path is not set]"
+    )
     def test_go_to_defintion_import(self) -> None:
         """Test that the go to definition is correct."""
         lsp = JacLangServer()
@@ -205,6 +216,9 @@ class TestJacLangServer(TestCase):
                     str(lsp.get_definition(import_file, lspt.Position(line, char))),
                 )
 
+    @pytest.mark.xfail(
+        reason="TODO: Fix the go to definition for imports[ abs_path is not set]"
+    )
     def test_go_to_definition_foolme(self) -> None:
         """Test that the go to definition is correct."""
         lsp = JacLangServer()
@@ -237,6 +251,7 @@ class TestJacLangServer(TestCase):
                     str(lsp.get_definition(import_file, lspt.Position(line, char))),
                 )
 
+    @pytest.mark.xfail(reason="TODO: Fix the go to definition")
     def test_go_to_definition_index_expr(self) -> None:
         """Test that the go to definition is correct."""
         lsp = JacLangServer()
@@ -261,6 +276,7 @@ class TestJacLangServer(TestCase):
                     str(lsp.get_definition(import_file, lspt.Position(line, char))),
                 )
 
+    @pytest.mark.xfail(reason="TODO: Fix when we have the type checker")
     def test_sem_tokens(self) -> None:
         """Test that the Semantic Tokens are generated correctly."""
         lsp = JacLangServer()
@@ -295,6 +311,7 @@ class TestJacLangServer(TestCase):
         for token_type, expected_count in expected_counts:
             self.assertEqual(str(sem_list).count(token_type), expected_count)
 
+    @pytest.mark.xfail(reason="TODO: Fix when we have the type checker")
     def test_completion(self) -> None:
         """Test that the completions are correct."""
         lsp = JacLangServer()
@@ -369,7 +386,7 @@ class TestJacLangServer(TestCase):
             (
                 lspt.Position(37, 12),
                 ["self", "add", "subtract", "x", "Colorenum", "Colour1", "red", "r"],
-                160,
+                153,
                 None,
             ),
         ]
@@ -411,6 +428,7 @@ class TestJacLangServer(TestCase):
             for expected in expected_refs:
                 self.assertIn(expected, references)
 
+    @pytest.mark.xfail(reason="TODO: Fix when we have the type checker")
     def test_py_type__definition(self) -> None:
         """Test that the go to definition is correct for pythoon imports."""
         lsp = JacLangServer()
@@ -429,9 +447,10 @@ class TestJacLangServer(TestCase):
             (20, 45, "pygame_mock/color.py:0:0-2:4"),
             (19, 77, "mock/constants.py:4:3-4:15"),
             (26, 28, "mock/display.py:0:0-1:7"),
-            (24, 22, "/argparse.pyi:124:0-249:13"),
+            (24, 22, "vendor/mypy/typeshed/stdlib/argparse.pyi:125:0-256:13"),
             (19, 74, "pygame_mock/constants.py:4:3-4:15"),
-            (27, 17, "/stdlib/os/__init__.pyi:50:0-50:3"),
+            # TODO: Need to properly support this
+            # (27, 17, "/stdlib/os/__init__.pyi:50:0-50:3"),
         ]
 
         for line, char, expected in positions:
@@ -439,8 +458,10 @@ class TestJacLangServer(TestCase):
                 self.assertIn(
                     expected,
                     str(lsp.get_definition(import_file, lspt.Position(line, char))),
+                    msg=positions.index((line, char, expected)) + 1,
                 )
 
+    @pytest.mark.xfail(reason="TODO: Fix when we have the type checker")
     def test_py_type__references(self) -> None:
         """Test that the go to definition is correct for pythoon imports."""
         lsp = JacLangServer()
@@ -491,8 +512,8 @@ class TestJacLangServer(TestCase):
                 [
                     "24:42-24:56",
                     "24:16-24:30",
-                    "argparse.pyi:334:21-334:35",
-                    "argparse.pyi:163:29-163:43",
+                    "argparse.pyi:358:21-358:35",
+                    "argparse.pyi:164:29-164:43",
                     "argparse.pyi:32:52-32:66",
                 ],
             ),
@@ -502,6 +523,7 @@ class TestJacLangServer(TestCase):
             for expected in expected_refs:
                 self.assertIn(expected, references)
 
+    @pytest.mark.xfail(reason="TODO: Fix when we have the type checker")
     def test_rename_symbol(self) -> None:
         """Test that the rename is correct."""
         lsp = JacLangServer()
@@ -533,6 +555,7 @@ class TestJacLangServer(TestCase):
             for expected in expected_refs:
                 self.assertIn(expected, references)
 
+    @pytest.mark.xfail(reason="TODO: Fix when we have the type checker")
     def test_rename_uses(self) -> None:
         """Test that the rename is correct."""
         lsp = JacLangServer()
@@ -545,19 +568,19 @@ class TestJacLangServer(TestCase):
         # fmt: off
         test_cases = [
             (0, 7, "func", "25:4-25:7", "0:4-0:7", "4:5-4:8",),
-            (4, 6, "func", "25:4-25:7", "0:4-0:7", "4:5-4:8",),
-            (25, 7, "func", "25:4-25:7", "0:4-0:7", "4:5-4:8",),
+            (4, 8, "func", "25:4-25:7", "0:4-0:7", "4:5-4:8",),
+            (25, 6, "func", "25:4-25:7", "0:4-0:7", "4:5-4:8",),
             (10, 10, "canBar", "27:8-27:11", "10:8-10:11"),
             (27, 9, "canBar", "27:8-27:11", "10:8-10:11"),
             (9, 6, "canBar", "26:10-26:13", "28:4-28:7", "16:5-16:8", "9:4-9:7"),
             (26, 11, "canBar", "26:10-26:13", "28:4-28:7", "16:5-16:8", "9:4-9:7"),
-            (16, 7, "canBar", "26:10-26:13", "28:4-28:7", "16:5-16:8", "9:4-9:7"),
+            (16, 8, "canBar", "26:10-26:13", "28:4-28:7", "16:5-16:8", "9:4-9:7"),
             (28, 6, "canBar", "26:10-26:13", "28:4-28:7", "16:5-16:8", "9:4-9:7"),
-            (11, 10, "canBar", "11:8-11:11", "16:13-16:16", "28:11-28:14"),
-            (16, 14, "canBar", "11:8-11:11", "16:13-16:16", "28:11-28:14"),
-            (28, 13, "canBar", "11:8-11:11", "16:13-16:16", "28:11-28:14"),
-            (12, 10, "canBaz", "12:8-12:11", "20:13-20:16"),
-            (20, 14, "canBaz", "12:8-12:11", "20:13-20:16"),
+            (11, 10, "canBar", "11:8-11:11", "16:9-16:12", "28:11-28:14"),
+            (16, 12, "canBar", "11:8-11:11", "16:9-16:12", "28:11-28:14"),
+            (28, 13, "canBar", "11:8-11:11", "16:9-16:12", "28:11-28:14"),
+            (12, 10, "canBaz", "12:8-12:11", "20:9-20:12"),
+            (20, 12, "canBaz", "12:8-12:11", "20:9-20:12"),
             (26, 6, "count", "27:4-27:7", "26:4-26:7"),
             (27, 5, "count", "27:4-27:7", "26:4-26:7"),
         ]