jaclang 0.8.9__py3-none-any.whl → 0.8.10__py3-none-any.whl

jaclang/compiler/passes/main/tests/test_binder_pass.py

@@ -1,111 +0,0 @@
-"""Test Binder pass."""
-
-from jaclang.compiler.program import JacProgram
-from jaclang.utils.symtable_test_helpers import SymTableTestMixin
-
-
-class BinderPassTests( SymTableTestMixin):
-    """Test pass module."""
-
-    def setUp(self) -> None:
-        """Set up test."""
-        return super().setUp()
-
-    def test_glob_sym_build(self) -> None:
-        """Test symbol table construction for symbol_binding_test.jac fixture."""
-        mod_targ = JacProgram().bind(self.fixture_abs_path("sym_binder.jac"))
-        sym_table = mod_targ.sym_tab
-
-        #currenlty 'aa' is not in the main table, need fix #TODO
-            # defns=[(9, 6), (16, 5), (27, 9), (32, 5)],
-            # uses=[(33, 11), (37, 11)]
-        # Test global variable 'aa'
-        self.assert_symbol_complete(
-            sym_table, "aa", "variable",
-            decl=(9, 6),
-            defns=[(9, 6), (16, 5), ],
-            uses=[ (37, 11)]
-        )
-
-        # Test global variable 'n'
-        self.assert_symbol_complete(
-            sym_table, "n", "variable",
-            decl=(14, 5),
-            defns=[(14, 5)]
-        )
-
-        # Test imported module 'M1'
-        self.assert_symbol_complete(
-            sym_table, "M1", "module",
-            decl=(1, 8),
-            defns=[(1, 8)]
-        )
-
-        # Test global variable 'z'
-        self.assert_symbol_complete(
-            sym_table, "z", "variable",
-            decl=(15, 5),
-            defns=[(15, 5)]
-        )
-
-        # Test global variable 'Y'
-        self.assert_symbol_complete(
-            sym_table, "Y", "variable",
-            decl=(11, 5),
-            defns=[(11, 5), (12, 5), (19, 5)],
-            uses=[(15, 9)]
-        )
-
-        # Test ability 'ccc'
-        self.assert_symbol_complete(
-            sym_table, "ccc", "ability",
-            decl=(22, 5),
-            defns=[(22, 5)],
-            uses=[(36, 5)]
-        )
-
-        #TODO: Fix the following test, 'bb' is not in the main table
-        # # Test global variable 'bb'
-        # self.assert_symbol_complete(
-        #     sym_table, "bb", "variable",
-        #     decl=(26, 17),
-        #     defns=[(26, 17), (28, 9)]
-        # )
-
-        # Test sub-table for ability 'ccc'
-        ccc_table = self.assert_sub_table_exists(sym_table, "ccc",'ability')
-
-        # Test sub-table for if statement inside 'ccc'
-        if_table = self.assert_sub_table_exists(ccc_table, "IfStmt",'variable')
-
-        # Test local variable 'p' inside if statement
-        self.assert_symbol_complete(
-            if_table, "p", "variable",
-            decl=(29, 9),
-            defns=[(29, 9)]
-        )
-
-    def test_symbol_table_structure(self) -> None:
-        """Test the overall structure of the symbol table."""
-        mod_targ = JacProgram().build(self.fixture_abs_path("sym_binder.jac"))
-        sym_table = mod_targ.sym_tab
-
-        # Verify main module table exists
-        self.assertIn("sym_binder", str(sym_table))
-
-        # Verify expected number of symbols in main table
-        main_symbols = ["aa", "n", "M1", "z", "Y", "ccc"]
-        # 'bb' is not here:need fix #TODO
-        for symbol_name in main_symbols:
-            self.assert_symbol_exists(sym_table, symbol_name)
-
-        # Verify sub-tables exist
-        sub_tables = sym_table.kid_scope
-        self.assertTrue(len(sub_tables) > 0, "No sub-tables found")
-
-        # Verify ability sub-table has nested if-statement table
-        ccc_table = self.assert_sub_table_exists(sym_table, "ccc", 'ability')
-        if_table = self.assert_sub_table_exists(ccc_table, "IfStmt", 'variable')
-
-        # Verify if-statement table contains local variable
-        self.assert_symbol_exists(if_table, "p")

jaclang/langserve/tests/session.jac

@@ -1,294 +0,0 @@
-"""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_dev_server.py

@@ -1,80 +0,0 @@
-from jaclang.utils.test import TestCase
-from jaclang.vendor.pygls import uris
-from jaclang.vendor.pygls.workspace import Workspace
-
-import lsprotocol.types as lspt
-from jaclang.langserve.engine import JacLangServer
-
-
-class TestJacLangServer(TestCase):
-
-    def test_type_annotation_assignment_server(self) -> None:
-        """Test that the server doesn't run if there is a syntax error."""
-        lsp = JacLangServer()
-        workspace_path = self.fixture_abs_path("")
-        workspace = Workspace(workspace_path, lsp)
-        lsp.lsp._workspace = workspace
-        circle_file = uris.from_fs_path(
-            self.fixture_abs_path(
-                "../../../../jaclang/compiler/passes/main/tests/fixtures/type_annotation_assignment.jac"
-            )
-        )
-        lsp.deep_check(circle_file)
-        self.assertIn(
-            "(public variable) should_fail1: int",
-            lsp.get_hover_info(circle_file, lspt.Position(1, 15)).contents.value,
-        )
-        self.assertIn(
-            "(public variable) should_pass2: str",
-            lsp.get_hover_info(circle_file, lspt.Position(2, 15)).contents.value,
-        )
-        self.assertIn(
-            "(public variable) should_fail2: str",
-            lsp.get_hover_info(circle_file, lspt.Position(3, 15)).contents.value,
-        )
-        diagnostics_list = list(lsp.diagnostics.values())[0]
-        self.assertEqual(len(diagnostics_list), 2)
-        self.assertIn(
-            "Cannot assign",
-            diagnostics_list[0].message,
-        )
-        self.assertEqual(
-            "1:5-1:30",
-            str(diagnostics_list[0].range),
-        )
-        self.assertEqual(
-            "3:5-3:27",
-            str(diagnostics_list[1].range),
-        )
-
-
-    def test_member_access_type_inferred_server(self) -> None:
-        """Test that the server doesn't run if there is a syntax error."""
-        lsp = JacLangServer()
-        workspace_path = self.fixture_abs_path("")
-        workspace = Workspace(workspace_path, lsp)
-        lsp.lsp._workspace = workspace
-        circle_file = uris.from_fs_path(
-            self.fixture_abs_path(
-                "../../../../jaclang/compiler/passes/main/tests/fixtures/member_access_type_inferred.jac"
-            )
-        )
-        lsp.deep_check(circle_file)
-        self.assertIn(
-            "(public variable) i: int",
-            lsp.get_hover_info(circle_file, lspt.Position(10, 2)).contents.value,
-        )
-        self.assertIn(
-            "(public variable) s: str",
-            lsp.get_hover_info(circle_file, lspt.Position(11, 2)).contents.value,
-        )
-        diagnostics_list = list(lsp.diagnostics.values())[0]
-        self.assertEqual(len(diagnostics_list), 1)
-        self.assertIn(
-            "Cannot assign",
-            diagnostics_list[0].message,
-        )
-        self.assertEqual(
-            "11:2-11:12",
-            str(diagnostics_list[0].range),
-        )