remove unnecessary CancelationToken

Author: d-biehl

robotcode/jsonrpc2/protocol.py

@@ -30,12 +30,7 @@
     runtime_checkable,
 )
 
-from ..utils.async_tools import (
-    CancelationToken,
-    async_event,
-    create_sub_future,
-    create_sub_task,
-)
+from ..utils.async_tools import async_event, create_sub_future, create_sub_task
 from ..utils.dataclasses import as_json, from_dict
 from ..utils.inspect import ensure_coroutine, iter_methods
 from ..utils.logging import LoggingDescriptor
@@ -332,7 +327,6 @@ class SendedRequestEntry(NamedTuple):
 class ReceivedRequestEntry(NamedTuple):
     future: asyncio.Future[Any]
     request: Optional[Any]
-    cancel_token: CancelationToken
     cancelable: bool
 
 
@@ -664,16 +658,13 @@ def handle_request(self, message: JsonRPCRequest) -> Optional[asyncio.Task[_T]]:
             return None
 
         params = self._convert_params(e.method, e.param_type, message.params)
-        cancel_token = CancelationToken()
 
         task = create_sub_task(
-            ensure_coroutine(e.method)(
-                *params[0], **({"cancel_token": cancel_token} if e.cancelable else {}), **params[1]
-            ),
+            ensure_coroutine(e.method)(*params[0], **params[1]),
             name=message.method,
         )
         with self._received_request_lock:
-            self._received_request[message.id] = ReceivedRequestEntry(task, message, cancel_token, e.cancelable)
+            self._received_request[message.id] = ReceivedRequestEntry(task, message, e.cancelable)
 
         def done(t: asyncio.Task[Any]) -> None:
             try:
@@ -702,15 +693,12 @@ def cancel_request(self, id: Union[int, str, None]) -> None:
 
         if entry is not None and entry.future is not None and not entry.future.cancelled():
             self._logger.debug(f"try to cancel request {entry.request}")
-            entry.cancel_token.cancel()
             entry.future.cancel()
 
     @_logger.call
     async def cancel_all_received_request(self) -> None:
         for entry in self._received_request.values():
             if entry is not None and entry.cancelable and entry.future is not None and not entry.future.cancelled():
-                if entry.cancel_token:
-                    entry.cancel_token.cancel()
                 entry.future.cancel()
 
     @_logger.call

robotcode/language_server/common/parts/diagnostics.py

@@ -6,7 +6,6 @@
 from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, cast
 
 from ....utils.async_tools import (
-    CancelationToken,
     Lock,
     async_tasking_event_iterator,
     check_canceled,
@@ -36,7 +35,6 @@ def __init__(
         self,
         uri: Uri,
         version: Optional[int],
-        cancelation_token: CancelationToken,
         factory: Callable[..., asyncio.Future[Any]],
         done_callback: Callable[[PublishDiagnosticsEntry], Any],
     ) -> None:
@@ -49,7 +47,6 @@ def __init__(
 
         self._future: Optional[asyncio.Future[Any]] = None
 
-        self.cancel_token = cancelation_token
         self.done = False
 
         def _done(t: asyncio.Future[Any]) -> None:
@@ -86,9 +83,6 @@ async def cancel(self) -> None:
         if self.future is None:
             return
 
-        if not self.done:
-            self.cancel_token.cancel()
-
         self.done = True
 
         if not self.future.done() and not self.future.cancelled():
@@ -129,9 +123,7 @@ def __init__(self, protocol: LanguageServerProtocol) -> None:
         self.parent.documents.did_save.add(self.on_did_save)
 
     @async_tasking_event_iterator
-    async def collect(
-        sender, document: TextDocument, cancelation_token: CancelationToken  # NOSONAR
-    ) -> DiagnosticsResult:
+    async def collect(sender, document: TextDocument) -> DiagnosticsResult:  # NOSONAR
         ...
 
     @_logger.call
@@ -206,17 +198,15 @@ async def start_publish_diagnostics_task(self, document: TextDocument) -> None:
 
             await self._cancel_entry(entry)
 
-            cancelation_token = CancelationToken()
             self._running_diagnostics[document.uri] = PublishDiagnosticsEntry(
                 document.uri,
                 document.version,
-                cancelation_token,
-                lambda: run_coroutine_in_thread(self.publish_diagnostics, document.document_uri, cancelation_token),
+                lambda: run_coroutine_in_thread(self.publish_diagnostics, document.document_uri),
                 self._delete_entry,
             )
 
     @_logger.call
-    async def publish_diagnostics(self, document_uri: DocumentUri, cancelation_token: CancelationToken) -> None:
+    async def publish_diagnostics(self, document_uri: DocumentUri) -> None:
         document = await self.parent.documents.get(document_uri)
         if document is None:
             return
@@ -228,7 +218,6 @@ async def publish_diagnostics(self, document_uri: DocumentUri, cancelation_token
         async for result_any in self.collect(
             self,
             document,
-            cancelation_token,
             callback_filter=language_id_filter(document),
             return_exceptions=True,
         ):

robotcode/language_server/common/parts/hover.py

@@ -4,7 +4,7 @@
 from typing import TYPE_CHECKING, Any, List, Optional
 
 from ....jsonrpc2.protocol import rpc_method
-from ....utils.async_tools import CancelationToken, async_tasking_event
+from ....utils.async_tools import async_tasking_event
 from ....utils.logging import LoggingDescriptor
 from ..decorators import language_id_filter
 from ..has_extend_capabilities import HasExtendCapabilities
@@ -31,9 +31,7 @@ def __init__(self, parent: LanguageServerProtocol) -> None:
         super().__init__(parent)
 
     @async_tasking_event
-    async def collect(
-        sender, document: TextDocument, position: Position, cancel_token: Optional[CancelationToken] = None
-    ) -> Optional[Hover]:  # NOSONAR
+    async def collect(sender, document: TextDocument, position: Position) -> Optional[Hover]:  # NOSONAR
         ...
 
     def extend_capabilities(self, capabilities: ServerCapabilities) -> None:
@@ -45,7 +43,6 @@ async def _text_document_hover(
         self,
         text_document: TextDocumentIdentifier,
         position: Position,
-        cancel_token: Optional[CancelationToken] = None,
         *args: Any,
         **kwargs: Any,
     ) -> Optional[Hover]:
@@ -60,7 +57,6 @@ async def _text_document_hover(
             self,
             document,
             position,
-            cancel_token=cancel_token,
             callback_filter=language_id_filter(document),
         ):
             if isinstance(result, BaseException):

robotcode/language_server/robotframework/diagnostics/analyzer.py

@@ -5,7 +5,6 @@
 import re
 from typing import Any, List, Optional, Union, cast
 
-from ....utils.async_tools import CancelationToken
 from ....utils.uri import Uri
 from ...common.lsp_types import (
     CodeDescription,
@@ -33,12 +32,9 @@
 
 
 class Analyzer(AsyncVisitor):
-    async def get(
-        self, model: ast.AST, namespace: Namespace, cancelation_token: Optional[CancelationToken] = None
-    ) -> List[Diagnostic]:
+    async def get(self, model: ast.AST, namespace: Namespace) -> List[Diagnostic]:
         self._results: List[Diagnostic] = []
         self._namespace = namespace
-        self.cancelation_token = cancelation_token
         self.current_testcase_or_keyword_name: Optional[str] = None
         self.finder = KeywordFinder(self._namespace)
 
@@ -78,6 +74,7 @@ async def append_diagnostics(
         related_information: Optional[List[DiagnosticRelatedInformation]] = None,
         data: Optional[Any] = None,
     ) -> None:
+
         if await self.should_ignore(self._namespace.document, range):
             return
 

robotcode/language_server/robotframework/diagnostics/namespace.py

@@ -24,7 +24,7 @@
 )
 
 from ....utils.async_itertools import async_chain
-from ....utils.async_tools import CancelationToken, Lock
+from ....utils.async_tools import Lock
 from ....utils.logging import LoggingDescriptor
 from ....utils.uri import Uri
 from ...common.lsp_types import (
@@ -542,10 +542,10 @@ async def invalidate(self) -> None:
         self.invalidated_callback(self)
 
     @_logger.call
-    async def get_diagnostisc(self, cancelation_token: Optional[CancelationToken] = None) -> List[Diagnostic]:
+    async def get_diagnostisc(self) -> List[Diagnostic]:
         await self.ensure_initialized()
 
-        await self._analyze(cancelation_token)
+        await self._analyze()
 
         return self._diagnostics
 
@@ -1220,15 +1220,15 @@ async def append_diagnostics(
         )
 
     @_logger.call
-    async def _analyze(self, cancelation_token: Optional[CancelationToken] = None) -> None:
+    async def _analyze(self) -> None:
         from .analyzer import Analyzer
 
         if not self._analyzed:
             async with self._analyze_lock:
                 if not self._analyzed:
                     canceled = False
                     try:
-                        result = await Analyzer().get(self.model, self, cancelation_token)
+                        result = await Analyzer().get(self.model, self)
 
                         self._diagnostics += result
 

robotcode/language_server/robotframework/parts/diagnostics.py

@@ -4,7 +4,7 @@
 import asyncio
 from typing import TYPE_CHECKING, Any, List, Optional
 
-from ....utils.async_tools import CancelationToken, check_canceled, threaded
+from ....utils.async_tools import check_canceled, threaded
 from ....utils.logging import LoggingDescriptor
 from ...common.decorators import language_id
 from ...common.lsp_types import Diagnostic, DiagnosticSeverity, Position, Range
@@ -40,17 +40,13 @@ async def namespace_invalidated(self, sender: Any, document: TextDocument) -> No
 
     @language_id("robotframework")
     @threaded()
-    async def collect_namespace_diagnostics(
-        self, sender: Any, document: TextDocument, cancelation_token: CancelationToken
-    ) -> DiagnosticsResult:
+    async def collect_namespace_diagnostics(self, sender: Any, document: TextDocument) -> DiagnosticsResult:
         try:
             namespace = await self.parent.documents_cache.get_namespace(document)
             if namespace is None:
                 return DiagnosticsResult(self.collect_namespace_diagnostics, None)
 
-            return DiagnosticsResult(
-                self.collect_namespace_diagnostics, await namespace.get_diagnostisc(cancelation_token)
-            )
+            return DiagnosticsResult(self.collect_namespace_diagnostics, await namespace.get_diagnostisc())
         except (asyncio.CancelledError, SystemExit, KeyboardInterrupt):
             raise
         except BaseException as e:
@@ -96,9 +92,7 @@ def _create_error_from_token(self, token: Token, source: Optional[str] = None) -
 
     @language_id("robotframework")
     @_logger.call
-    async def collect_token_errors(
-        self, sender: Any, document: TextDocument, cancelation_token: CancelationToken
-    ) -> DiagnosticsResult:
+    async def collect_token_errors(self, sender: Any, document: TextDocument) -> DiagnosticsResult:
         from robot.errors import VariableError
         from robot.parsing.lexer.tokens import Token
 
@@ -164,9 +158,7 @@ async def collect_token_errors(
     @language_id("robotframework")
     @threaded()
     @_logger.call
-    async def collect_walk_model_errors(
-        self, sender: Any, document: TextDocument, cancelation_token: CancelationToken
-    ) -> DiagnosticsResult:
+    async def collect_walk_model_errors(self, sender: Any, document: TextDocument) -> DiagnosticsResult:
 
         from ..utils.ast import HasError, HasErrors
         from ..utils.async_ast import iter_nodes