rename async_events, generalize threading and async threading, some code cleanup and simplification

d-biehl · d-biehl · commit c4cac21606ea · 2021-11-28T13:42:11.000+01:00
diff --git a/robotcode/jsonrpc2/protocol.py b/robotcode/jsonrpc2/protocol.py
@@ -31,7 +31,7 @@
     runtime_checkable,
 )
 
-from ..utils.async_event import async_event
+from ..utils.async_tools import async_event
 from ..utils.dataclasses import as_json, from_dict
 from ..utils.inspect import ensure_coroutine, iter_methods
 from ..utils.logging import LoggingDescriptor
diff --git a/robotcode/language_server/common/parts/code_lens.py b/robotcode/language_server/common/parts/code_lens.py
@@ -4,7 +4,7 @@
 from typing import TYPE_CHECKING, Any, List, Optional
 
 from ....jsonrpc2.protocol import rpc_method
-from ....utils.async_event import async_tasking_event
+from ....utils.async_tools import async_tasking_event
 from ....utils.logging import LoggingDescriptor
 from ..has_extend_capabilities import HasExtendCapabilities
 from ..language import language_id_filter
diff --git a/robotcode/language_server/common/parts/completion.py b/robotcode/language_server/common/parts/completion.py
@@ -5,7 +5,7 @@
 from typing import TYPE_CHECKING, Any, List, Optional, Union, cast
 
 from ....jsonrpc2.protocol import rpc_method
-from ....utils.async_event import async_tasking_event
+from ....utils.async_tools import async_tasking_event
 from ....utils.logging import LoggingDescriptor
 from ..has_extend_capabilities import HasExtendCapabilities
 from ..language import HasAllCommitCharacters, HasTriggerCharacters, language_id_filter
diff --git a/robotcode/language_server/common/parts/declaration.py b/robotcode/language_server/common/parts/declaration.py
@@ -4,7 +4,7 @@
 from typing import TYPE_CHECKING, Any, List, Optional, Union
 
 from ....jsonrpc2.protocol import rpc_method
-from ....utils.async_event import async_tasking_event
+from ....utils.async_tools import async_tasking_event
 from ....utils.logging import LoggingDescriptor
 from ..has_extend_capabilities import HasExtendCapabilities
 from ..language import language_id_filter
diff --git a/robotcode/language_server/common/parts/definition.py b/robotcode/language_server/common/parts/definition.py
@@ -4,7 +4,7 @@
 from typing import TYPE_CHECKING, Any, List, Optional, Union
 
 from ....jsonrpc2.protocol import rpc_method
-from ....utils.async_event import async_tasking_event
+from ....utils.async_tools import async_tasking_event
 from ....utils.logging import LoggingDescriptor
 from ..has_extend_capabilities import HasExtendCapabilities
 from ..language import language_id_filter
diff --git a/robotcode/language_server/common/parts/diagnostics.py b/robotcode/language_server/common/parts/diagnostics.py
@@ -5,7 +5,7 @@
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, cast
 
-from ....utils.async_event import async_tasking_event_iterator
+from ....utils.async_tools import async_tasking_event_iterator
 from ....utils.logging import LoggingDescriptor
 from ....utils.uri import Uri
 from ..language import language_id, language_id_filter
diff --git a/robotcode/language_server/common/parts/document_symbols.py b/robotcode/language_server/common/parts/document_symbols.py
@@ -15,7 +15,7 @@
 )
 
 from ....jsonrpc2.protocol import rpc_method
-from ....utils.async_event import async_tasking_event
+from ....utils.async_tools import async_tasking_event
 from ....utils.logging import LoggingDescriptor
 from ..has_extend_capabilities import HasExtendCapabilities
 from ..language import language_id_filter
diff --git a/robotcode/language_server/common/parts/documents.py b/robotcode/language_server/common/parts/documents.py
@@ -5,7 +5,7 @@
 from typing import TYPE_CHECKING, Any, Dict, Iterator, List, Mapping, Optional
 
 from ....jsonrpc2.protocol import JsonRPCException, rpc_method
-from ....utils.async_event import async_event
+from ....utils.async_tools import async_event
 from ....utils.logging import LoggingDescriptor
 from ....utils.uri import Uri
 from ..language import language_id_filter
diff --git a/robotcode/language_server/common/parts/folding_range.py b/robotcode/language_server/common/parts/folding_range.py
@@ -4,7 +4,7 @@
 from typing import TYPE_CHECKING, Any, List, Optional
 
 from ....jsonrpc2.protocol import rpc_method
-from ....utils.async_event import async_tasking_event
+from ....utils.async_tools import async_tasking_event
 from ....utils.logging import LoggingDescriptor
 from ..has_extend_capabilities import HasExtendCapabilities
 from ..language import language_id_filter
diff --git a/robotcode/language_server/common/parts/formatting.py b/robotcode/language_server/common/parts/formatting.py
@@ -4,7 +4,7 @@
 from typing import TYPE_CHECKING, Any, List, Optional
 
 from ....jsonrpc2.protocol import rpc_method
-from ....utils.async_event import async_tasking_event
+from ....utils.async_tools import async_tasking_event
 from ....utils.logging import LoggingDescriptor
 from ..has_extend_capabilities import HasExtendCapabilities
 from ..language import language_id_filter
diff --git a/robotcode/language_server/common/parts/hover.py b/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_event import async_tasking_event
+from ....utils.async_tools import async_tasking_event
 from ....utils.logging import LoggingDescriptor
 from ..has_extend_capabilities import HasExtendCapabilities
 from ..language import language_id_filter
diff --git a/robotcode/language_server/common/parts/implementation.py b/robotcode/language_server/common/parts/implementation.py
@@ -4,7 +4,7 @@
 from typing import TYPE_CHECKING, Any, List, Optional, Union
 
 from ....jsonrpc2.protocol import rpc_method
-from ....utils.async_event import async_tasking_event
+from ....utils.async_tools import async_tasking_event
 from ....utils.logging import LoggingDescriptor
 from ..has_extend_capabilities import HasExtendCapabilities
 from ..language import language_id_filter
diff --git a/robotcode/language_server/common/parts/references.py b/robotcode/language_server/common/parts/references.py
@@ -4,7 +4,7 @@
 from typing import TYPE_CHECKING, Any, List, Optional
 
 from ....jsonrpc2.protocol import rpc_method
-from ....utils.async_event import async_tasking_event
+from ....utils.async_tools import async_tasking_event
 from ....utils.logging import LoggingDescriptor
 from ..has_extend_capabilities import HasExtendCapabilities
 from ..language import language_id_filter
diff --git a/robotcode/language_server/common/parts/semantic_tokens.py b/robotcode/language_server/common/parts/semantic_tokens.py
@@ -5,7 +5,7 @@
 from typing import TYPE_CHECKING, Any, List, Union
 
 from ....jsonrpc2.protocol import rpc_method
-from ....utils.async_event import async_tasking_event
+from ....utils.async_tools import async_tasking_event
 from ....utils.logging import LoggingDescriptor
 from ..has_extend_capabilities import HasExtendCapabilities
 from ..language import language_id_filter
diff --git a/robotcode/language_server/common/parts/signature_help.py b/robotcode/language_server/common/parts/signature_help.py
@@ -5,7 +5,7 @@
 from typing import TYPE_CHECKING, Any, List, Optional, cast
 
 from ....jsonrpc2.protocol import rpc_method
-from ....utils.async_event import async_tasking_event
+from ....utils.async_tools import async_tasking_event
 from ....utils.logging import LoggingDescriptor
 from ..has_extend_capabilities import HasExtendCapabilities
 from ..language import HasRetriggerCharacters, HasTriggerCharacters, language_id_filter
diff --git a/robotcode/language_server/common/parts/workspace.py b/robotcode/language_server/common/parts/workspace.py
@@ -24,7 +24,7 @@
 )
 
 from ....jsonrpc2.protocol import rpc_method
-from ....utils.async_event import async_event
+from ....utils.async_tools import async_event
 from ....utils.dataclasses import from_dict
 from ....utils.logging import LoggingDescriptor
 from ....utils.path import path_is_relative_to
diff --git a/robotcode/language_server/common/protocol.py b/robotcode/language_server/common/protocol.py
@@ -12,7 +12,7 @@
     rpc_method,
 )
 from ...jsonrpc2.server import JsonRPCServer
-from ...utils.async_event import async_event
+from ...utils.async_tools import async_event
 from ...utils.logging import LoggingDescriptor
 from .has_extend_capabilities import HasExtendCapabilities
 from .lsp_types import (
diff --git a/robotcode/language_server/robotframework/diagnostics/imports_manager.py b/robotcode/language_server/robotframework/diagnostics/imports_manager.py
@@ -9,7 +9,7 @@
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Callable, Coroutine, List, Optional, Tuple, cast
 
-from ....utils.async_event import async_tasking_event
+from ....utils.async_tools import async_tasking_event
 from ....utils.logging import LoggingDescriptor
 from ....utils.path import path_is_relative_to
 from ....utils.uri import Uri
diff --git a/robotcode/language_server/robotframework/diagnostics/namespace.py b/robotcode/language_server/robotframework/diagnostics/namespace.py
@@ -23,6 +23,7 @@
 )
 
 from ....utils.async_itertools import async_chain
+from ....utils.async_tools import awaitable_to_thread
 from ....utils.logging import LoggingDescriptor
 from ....utils.uri import Uri
 from ...common.lsp_types import (
@@ -589,21 +590,18 @@ async def get_libraries(self) -> OrderedDict[str, LibraryEntry]:
 
         return self._libraries
 
-    @_logger.call
     async def get_libraries_matchers(self) -> Dict[KeywordMatcher, LibraryEntry]:
         if self._libraries_matchers is None:
             self._libraries_matchers = {
                 KeywordMatcher(v.alias or v.name or v.import_name): v for v in (await self.get_libraries()).values()
             }
         return self._libraries_matchers
 
-    @_logger.call
     async def get_resources(self) -> OrderedDict[str, ResourceEntry]:
         await self.ensure_initialized()
 
         return self._resources
 
-    @_logger.call
     async def get_resources_matchers(self) -> Dict[KeywordMatcher, ResourceEntry]:
         if self._resources_matchers is None:
             self._resources_matchers = {
@@ -1097,10 +1095,7 @@ async def _analyze(self) -> None:
             async with self._analyze_lock:
                 if not self._analyzed:
                     try:
-                        self._diagnostics += await asyncio.get_running_loop().run_in_executor(
-                            None, asyncio.run, Analyzer().get(self.model, self)
-                        )
-                        # self._diagnostics += await Analyzer().get(self.model, self)
+                        self._diagnostics += await awaitable_to_thread(Analyzer().get(self.model, self))
 
                         lib_doc = await self.get_library_doc()
 
@@ -1127,7 +1122,7 @@ async def _analyze(self) -> None:
                     finally:
                         self._analyzed = True
 
-    @_logger.call
+    @_logger.call(condition=lambda self, name: self._finder is not None and name not in self._finder._cache)
     async def find_keyword(self, name: Optional[str]) -> Optional[KeywordDoc]:
         if self._finder is None:
             await self.ensure_initialized()
diff --git a/robotcode/language_server/robotframework/parts/diagnostics.py b/robotcode/language_server/robotframework/parts/diagnostics.py
@@ -3,6 +3,7 @@
 import ast
 from typing import TYPE_CHECKING, Any, List, Optional
 
+from ....utils.async_tools import awaitable_to_thread
 from ....utils.logging import LoggingDescriptor
 from ...common.language import language_id
 from ...common.lsp_types import Diagnostic, DiagnosticSeverity, Position, Range
@@ -25,7 +26,6 @@ def __init__(self, parent: RobotLanguageServerProtocol) -> None:
         self.source_name = "robotcode.diagnostics"
 
         parent.diagnostics.collect.add(self.collect_token_errors)
-        # parent.diagnostics.collect.add(self.collect_model_errors)
         parent.diagnostics.collect.add(self.collect_walk_model_errors)
 
         parent.diagnostics.collect.add(self.collect_namespace_diagnostics)
@@ -61,41 +61,39 @@ 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) -> DiagnosticsResult:
-        from robot.errors import VariableError
-        from robot.parsing.lexer.tokens import Token
-
-        result: List[Diagnostic] = []
-        try:
-            for token in await self.parent.documents_cache.get_tokens(document):
-                if token.type in [Token.ERROR, Token.FATAL_ERROR]:
-                    result.append(self._create_error_from_token(token))
-
-                try:
-                    for variable_token in token.tokenize_variables():
-                        if variable_token == token:
-                            break
-
-                        if variable_token.type in [Token.ERROR, Token.FATAL_ERROR]:
-                            result.append(self._create_error_from_token(variable_token))
-
-                except VariableError as e:
-                    result.append(
-                        Diagnostic(
-                            range=range_from_token(token),
-                            message=str(e),
-                            severity=DiagnosticSeverity.ERROR,
-                            source=self.source_name,
-                            code=type(e).__qualname__,
+        async def collect_async(tokens: List[Token]) -> List[Diagnostic]:
+            from robot.errors import VariableError
+            from robot.parsing.lexer.tokens import Token
+
+            result: List[Diagnostic] = []
+            try:
+                for token in tokens:
+                    if token.type in [Token.ERROR, Token.FATAL_ERROR]:
+                        result.append(self._create_error_from_token(token))
+
+                    try:
+                        for variable_token in token.tokenize_variables():
+                            if variable_token == token:
+                                break
+
+                            if variable_token.type in [Token.ERROR, Token.FATAL_ERROR]:
+                                result.append(self._create_error_from_token(variable_token))
+
+                    except VariableError as e:
+                        result.append(
+                            Diagnostic(
+                                range=range_from_token(token),
+                                message=str(e),
+                                severity=DiagnosticSeverity.ERROR,
+                                source=self.source_name,
+                                code=type(e).__qualname__,
+                            )
                         )
-                    )
 
-            return DiagnosticsResult(self.collect_token_errors, result)
-        except (SystemExit, KeyboardInterrupt):
-            raise
-        except BaseException as e:
-            return DiagnosticsResult(
-                self.collect_token_errors,
-                [
+            except (SystemExit, KeyboardInterrupt):
+                raise
+            except BaseException as e:
+                return [
                     Diagnostic(
                         range=Range(
                             start=Position(
@@ -112,62 +110,38 @@ async def collect_token_errors(self, sender: Any, document: TextDocument) -> Dia
                         source=self.source_name,
                         code=type(e).__qualname__,
                     )
-                ],
-            )
+                ]
+
+            return result
+
+        return DiagnosticsResult(
+            self.collect_token_errors,
+            await awaitable_to_thread(collect_async(await self.parent.documents_cache.get_tokens(document))),
+        )
 
     @language_id("robotframework")
     @_logger.call
-    async def collect_model_errors(self, sender: Any, document: TextDocument) -> DiagnosticsResult:
-        from ..utils.ast import HasError, HasErrors
-        from ..utils.async_ast import AsyncVisitor
-
-        class Visitor(AsyncVisitor):
-            def __init__(self, parent: RobotDiagnosticsProtocolPart) -> None:
-                super().__init__()
-                self.parent = parent
-                self.errors: List[Diagnostic] = []
-
-            @classmethod
-            async def find_from(cls, model: ast.AST, parent: RobotDiagnosticsProtocolPart) -> List[Diagnostic]:
-                finder = cls(parent)
-                await finder.visit(model)
-                return finder.errors
-
-            async def generic_visit(self, node: ast.AST) -> None:
+    async def collect_walk_model_errors(self, sender: Any, document: TextDocument) -> DiagnosticsResult:
+        async def collect_async(model: ast.AST) -> List[Diagnostic]:
+            from ..utils.ast import HasError, HasErrors
+            from ..utils.async_ast import iter_nodes
+
+            result: List[Diagnostic] = []
+            async for node in iter_nodes(model):
                 error = node.error if isinstance(node, HasError) else None
                 if error is not None:
-                    self.errors.append(self.parent._create_error_from_node(node, error))
+                    result.append(self._create_error_from_node(node, error))
                 errors = node.errors if isinstance(node, HasErrors) else None
-
                 if errors is not None:
                     for e in errors:
-                        self.errors.append(self.parent._create_error_from_node(node, e))
-                await super().generic_visit(node)
+                        result.append(self._create_error_from_node(node, e))
+            return result
 
         return DiagnosticsResult(
-            self.collect_model_errors,
-            await Visitor.find_from(await self.parent.documents_cache.get_model(document), self),
+            self.collect_walk_model_errors,
+            await awaitable_to_thread(collect_async(await self.parent.documents_cache.get_model(document))),
         )
 
-    @language_id("robotframework")
-    @_logger.call
-    async def collect_walk_model_errors(self, sender: Any, document: TextDocument) -> DiagnosticsResult:
-        from ..utils.ast import HasError, HasErrors
-        from ..utils.async_ast import walk
-
-        result: List[Diagnostic] = []
-
-        async for node in walk(await self.parent.documents_cache.get_model(document)):
-            error = node.error if isinstance(node, HasError) else None
-            if error is not None:
-                result.append(self._create_error_from_node(node, error))
-            errors = node.errors if isinstance(node, HasErrors) else None
-            if errors is not None:
-                for e in errors:
-                    result.append(self._create_error_from_node(node, e))
-
-        return DiagnosticsResult(self.collect_walk_model_errors, result)
-
     @language_id("robotframework")
     @_logger.call
     async def collect_namespace_diagnostics(self, sender: Any, document: TextDocument) -> DiagnosticsResult:
diff --git a/robotcode/language_server/robotframework/parts/discovering.py b/robotcode/language_server/robotframework/parts/discovering.py
diff --git a/robotcode/language_server/robotframework/parts/documents_cache.py b/robotcode/language_server/robotframework/parts/documents_cache.py
diff --git a/robotcode/language_server/robotframework/parts/references.py b/robotcode/language_server/robotframework/parts/references.py
diff --git a/robotcode/language_server/robotframework/parts/robocop_diagnostics.py b/robotcode/language_server/robotframework/parts/robocop_diagnostics.py
diff --git a/robotcode/language_server/robotframework/parts/semantic_tokens.py b/robotcode/language_server/robotframework/parts/semantic_tokens.py
diff --git a/robotcode/utils/async_itertools.py b/robotcode/utils/async_itertools.py
diff --git a/robotcode/utils/async_tools.py b/robotcode/utils/async_tools.py
diff --git a/robotcode/utils/dataclasses.py b/robotcode/utils/dataclasses.py
diff --git a/robotcode/utils/logging.py b/robotcode/utils/logging.py

Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@`
`31`	`31`	`runtime_checkable,`
`32`	`32`	`)`
`33`	`33`
`34`		`-from ..utils.async_event import async_event`
	`34`	`+from ..utils.async_tools import async_event`
`35`	`35`	`from ..utils.dataclasses import as_json, from_dict`
`36`	`36`	`from ..utils.inspect import ensure_coroutine, iter_methods`
`37`	`37`	`from ..utils.logging import LoggingDescriptor`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@`
`15`	`15`	`)`
`16`	`16`
`17`	`17`	`from ....jsonrpc2.protocol import rpc_method`
`18`		`-from ....utils.async_event import async_tasking_event`
	`18`	`+from ....utils.async_tools import async_tasking_event`
`19`	`19`	`from ....utils.logging import LoggingDescriptor`
`20`	`20`	`from ..has_extend_capabilities import HasExtendCapabilities`
`21`	`21`	`from ..language import language_id_filter`