perf(robotlangserver): refactor some unnecessary async/await methods

Author: d-biehl

robotcode/language_server/robotframework/diagnostics/analyzer.py

@@ -69,6 +69,7 @@ def __init__(self, model: ast.AST, namespace: Namespace) -> None:
         self._diagnostics: List[Diagnostic] = []
         self._keyword_references: Dict[KeywordDoc, Set[Location]] = defaultdict(set)
         self._variable_references: Dict[VariableDefinition, Set[Location]] = defaultdict(set)
+        self._ignored_lines: Optional[List[int]] = None
 
     async def run(self) -> AnalyzerResult:
         self._diagnostics = []
@@ -280,15 +281,28 @@ async def __get_ignored_lines(document: TextDocument) -> List[int]:
 
         return result
 
+    @classmethod
+    async def should_ignore(cls, document: Optional[TextDocument], range: Range) -> bool:
+        return cls.__should_ignore(await cls.get_ignored_lines(document) if document is not None else [], range)
+
+    async def _get_ignored_lines(self) -> List[int]:
+        if self._ignored_lines is None:
+            self._ignored_lines = (
+                await Analyzer.get_ignored_lines(self.namespace.document) if self.namespace.document is not None else []
+            )
+
+        return self._ignored_lines
+
+    async def _should_ignore(self, range: Range) -> bool:
+        return self.__should_ignore(await self._get_ignored_lines(), range)
+
     @staticmethod
-    async def should_ignore(document: Optional[TextDocument], range: Range) -> bool:
+    def __should_ignore(lines: List[int], range: Range) -> bool:
         import builtins
 
-        if document is not None:
-            lines = await Analyzer.get_ignored_lines(document)
-            for line_no in builtins.range(range.start.line, range.end.line + 1):
-                if line_no in lines:
-                    return True
+        for line_no in builtins.range(range.start.line, range.end.line + 1):
+            if line_no in lines:
+                return True
 
         return False
 
@@ -305,7 +319,7 @@ async def append_diagnostics(
         data: Optional[Any] = None,
     ) -> None:
 
-        if await self.should_ignore(self.namespace.document, range):
+        if await self._should_ignore(range):
             return
 
         self._diagnostics.append(
@@ -799,7 +813,7 @@ async def visit_Keyword(self, node: ast.AST) -> None:  # noqa: N802
 
         if keyword.name:
             name_token = cast(KeywordName, keyword.header).get_token(RobotToken.KEYWORD_NAME)
-            kw_doc = await self.get_keyword_definition_at_token(self.namespace, name_token)
+            kw_doc = self.get_keyword_definition_at_token(await self.namespace.get_library_doc(), name_token)
 
             if kw_doc is not None and kw_doc not in self._keyword_references:
                 self._keyword_references[kw_doc] = set()

robotcode/language_server/robotframework/diagnostics/namespace.py

@@ -50,7 +50,7 @@
     strip_variable_token,
     tokenize_variables,
 )
-from ..utils.async_ast import AsyncVisitor
+from ..utils.async_ast import Visitor
 from ..utils.match import eq
 from ..utils.variables import BUILTIN_VARIABLES
 from ..utils.version import get_robot_version
@@ -97,20 +97,20 @@ class NameSpaceError(Exception):
     pass
 
 
-class VariablesVisitor(AsyncVisitor):
-    async def get(self, source: str, model: ast.AST) -> List[VariableDefinition]:
+class VariablesVisitor(Visitor):
+    def get(self, source: str, model: ast.AST) -> List[VariableDefinition]:
         self._results: List[VariableDefinition] = []
         self.source = source
-        await self.visit(model)
+        self.visit(model)
         return self._results
 
-    async def visit_Section(self, node: ast.AST) -> None:  # noqa: N802
+    def visit_Section(self, node: ast.AST) -> None:  # noqa: N802
         from robot.parsing.model.blocks import VariableSection
 
         if isinstance(node, VariableSection):
-            await self.generic_visit(node)
+            self.generic_visit(node)
 
-    async def visit_Variable(self, node: ast.AST) -> None:  # noqa: N802
+    def visit_Variable(self, node: ast.AST) -> None:  # noqa: N802
         from robot.parsing.lexer.tokens import Token as RobotToken
         from robot.parsing.model.statements import Variable
         from robot.variables import search_variable
@@ -152,38 +152,38 @@ async def visit_Variable(self, node: ast.AST) -> None:  # noqa: N802
             )
 
 
-class BlockVariableVisitor(AsyncVisitor):
+class BlockVariableVisitor(Visitor):
     def __init__(
-        self, namespace: Namespace, source: str, position: Optional[Position] = None, in_args: bool = True
+        self, library_doc: LibraryDoc, source: str, position: Optional[Position] = None, in_args: bool = True
     ) -> None:
         super().__init__()
-        self.namespace = namespace
+        self.library_doc = library_doc
         self.source = source
         self.position = position
         self.in_args = in_args
 
         self._results: Dict[str, VariableDefinition] = {}
         self.current_kw_doc: Optional[KeywordDoc] = None
 
-    async def get(self, model: ast.AST) -> List[VariableDefinition]:
+    def get(self, model: ast.AST) -> List[VariableDefinition]:
 
         self._results = {}
 
-        await self.visit(model)
+        self.visit(model)
 
         return list(self._results.values())
 
-    async def visit(self, node: ast.AST) -> None:
+    def visit(self, node: ast.AST) -> None:
         if self.position is None or self.position >= range_from_node(node).start:
-            return await super().visit(node)
+            return super().visit(node)
 
-    async def visit_Keyword(self, node: ast.AST) -> None:  # noqa: N802
+    def visit_Keyword(self, node: ast.AST) -> None:  # noqa: N802
         try:
-            await self.generic_visit(node)
+            self.generic_visit(node)
         finally:
             self.current_kw_doc = None
 
-    async def visit_KeywordName(self, node: ast.AST) -> None:  # noqa: N802
+    def visit_KeywordName(self, node: ast.AST) -> None:  # noqa: N802
         from robot.parsing.lexer.tokens import Token as RobotToken
         from robot.parsing.model.statements import KeywordName
         from robot.variables.search import search_variable
@@ -194,7 +194,8 @@ async def visit_KeywordName(self, node: ast.AST) -> None:  # noqa: N802
         name_token = cast(Token, n.get_token(RobotToken.KEYWORD_NAME))
 
         if name_token is not None and name_token.value:
-            keyword = await ModelHelperMixin.get_keyword_definition_at_token(self.namespace, name_token)
+
+            keyword = ModelHelperMixin.get_keyword_definition_at_token(self.library_doc, name_token)
             self.current_kw_doc = keyword
 
             for variable_token in filter(
@@ -236,7 +237,7 @@ def get_variable_token(self, token: Token) -> Optional[Token]:
             None,
         )
 
-    async def visit_Arguments(self, node: ast.AST) -> None:  # noqa: N802
+    def visit_Arguments(self, node: ast.AST) -> None:  # noqa: N802
         from robot.errors import VariableError
         from robot.parsing.lexer.tokens import Token as RobotToken
         from robot.parsing.model.statements import Arguments
@@ -280,7 +281,7 @@ async def visit_Arguments(self, node: ast.AST) -> None:  # noqa: N802
         if self.current_kw_doc is not None:
             self.current_kw_doc.argument_definitions = argument_definitions
 
-    async def visit_ExceptHeader(self, node: ast.AST) -> None:  # noqa: N802
+    def visit_ExceptHeader(self, node: ast.AST) -> None:  # noqa: N802
         from robot.errors import VariableError
         from robot.parsing.lexer.tokens import Token as RobotToken
         from robot.parsing.model.statements import ExceptHeader
@@ -306,7 +307,7 @@ async def visit_ExceptHeader(self, node: ast.AST) -> None:  # noqa: N802
             except VariableError:
                 pass
 
-    async def visit_KeywordCall(self, node: ast.AST) -> None:  # noqa: N802
+    def visit_KeywordCall(self, node: ast.AST) -> None:  # noqa: N802
         from robot.errors import VariableError
         from robot.parsing.lexer.tokens import Token as RobotToken
         from robot.parsing.model.statements import KeywordCall
@@ -341,7 +342,7 @@ async def visit_KeywordCall(self, node: ast.AST) -> None:  # noqa: N802
             except VariableError:
                 pass
 
-    async def visit_InlineIfHeader(self, node: ast.AST) -> None:  # noqa: N802
+    def visit_InlineIfHeader(self, node: ast.AST) -> None:  # noqa: N802
         from robot.errors import VariableError
         from robot.parsing.lexer.tokens import Token as RobotToken
         from robot.parsing.model.statements import InlineIfHeader
@@ -374,7 +375,7 @@ async def visit_InlineIfHeader(self, node: ast.AST) -> None:  # noqa: N802
             except VariableError:
                 pass
 
-    async def visit_ForHeader(self, node: ast.AST) -> None:  # noqa: N802
+    def visit_ForHeader(self, node: ast.AST) -> None:  # noqa: N802
         from robot.parsing.lexer.tokens import Token as RobotToken
         from robot.parsing.model.statements import ForHeader
 
@@ -394,20 +395,20 @@ async def visit_ForHeader(self, node: ast.AST) -> None:  # noqa: N802
                 )
 
 
-class ImportVisitor(AsyncVisitor):
-    async def get(self, source: str, model: ast.AST) -> List[Import]:
+class ImportVisitor(Visitor):
+    def get(self, source: str, model: ast.AST) -> List[Import]:
         self._results: List[Import] = []
         self.source = source
-        await self.visit(model)
+        self.visit(model)
         return self._results
 
-    async def visit_Section(self, node: ast.AST) -> None:  # noqa: N802
+    def visit_Section(self, node: ast.AST) -> None:  # noqa: N802
         from robot.parsing.model.blocks import SettingSection
 
         if isinstance(node, SettingSection):
-            await self.generic_visit(node)
+            self.generic_visit(node)
 
-    async def visit_LibraryImport(self, node: ast.AST) -> None:  # noqa: N802
+    def visit_LibraryImport(self, node: ast.AST) -> None:  # noqa: N802
         from robot.parsing.lexer.tokens import Token as RobotToken
         from robot.parsing.model.statements import LibraryImport as RobotLibraryImport
 
@@ -440,7 +441,7 @@ async def visit_LibraryImport(self, node: ast.AST) -> None:  # noqa: N802
             )
         )
 
-    async def visit_ResourceImport(self, node: ast.AST) -> None:  # noqa: N802
+    def visit_ResourceImport(self, node: ast.AST) -> None:  # noqa: N802
         from robot.parsing.lexer.tokens import Token as RobotToken
         from robot.parsing.model.statements import ResourceImport as RobotResourceImport
 
@@ -470,7 +471,7 @@ async def visit_ResourceImport(self, node: ast.AST) -> None:  # noqa: N802
             )
         )
 
-    async def visit_VariablesImport(self, node: ast.AST) -> None:  # noqa: N802
+    def visit_VariablesImport(self, node: ast.AST) -> None:  # noqa: N802
         from robot.parsing.lexer.tokens import Token as RobotToken
         from robot.parsing.model.statements import (
             VariablesImport as RobotVariablesImport,
@@ -864,15 +865,15 @@ def initialized(self) -> bool:
     @_logger.call
     async def get_imports(self) -> List[Import]:
         if self._imports is None:
-            self._imports = await ImportVisitor().get(self.source, self.model)
+            self._imports = ImportVisitor().get(self.source, self.model)
 
         return self._imports
 
     @_logger.call
     async def get_own_variables(self) -> List[VariableDefinition]:
         async with self._own_variables_lock:
             if self._own_variables is None:
-                self._own_variables = await VariablesVisitor().get(self.source, self.model)
+                self._own_variables = VariablesVisitor().get(self.source, self.model)
 
             return self._own_variables
 
@@ -927,8 +928,8 @@ async def yield_variables(
         for var in chain(
             *[
                 (
-                    await BlockVariableVisitor(
-                        self,
+                    BlockVariableVisitor(
+                        await self.get_library_doc(),
                         self.source,
                         position,
                         isinstance(test_or_keyword_nodes[-1], Arguments) if nodes else False,

robotcode/language_server/robotframework/parts/codelens.py

@@ -110,7 +110,7 @@ async def resolve(self, sender: Any, code_lens: CodeLens) -> Optional[CodeLens]:
         line = code_lens.data["line"]
 
         if self.parent.diagnostics.workspace_loaded_event.is_set():
-            kw_doc = await self.get_keyword_definition_at_line(namespace, name, line)
+            kw_doc = self.get_keyword_definition_at_line(await namespace.get_library_doc(), name, line)
 
             if kw_doc is not None and not kw_doc.is_error_handler:
                 if not await self.parent.robot_references.has_cached_keyword_references(

robotcode/language_server/robotframework/parts/goto.py

@@ -251,7 +251,7 @@ async def definition_KeywordName(  # noqa: N802
         if not name_token:
             return None
 
-        result = await self.get_keyword_definition_at_token(namespace, name_token)
+        result = self.get_keyword_definition_at_token(await namespace.get_library_doc(), name_token)
 
         if result is not None and not result.is_error_handler and result.source:
             token_range = range_from_token(name_token)

robotcode/language_server/robotframework/parts/hover.py

@@ -557,7 +557,7 @@ async def hover_KeywordName(  # noqa: N802
         if not name_token:
             return None
 
-        result = await self.get_keyword_definition_at_token(namespace, name_token)
+        result = self.get_keyword_definition_at_token(await namespace.get_library_doc(), name_token)
 
         if result is not None and not result.is_error_handler:
             return Hover(

robotcode/language_server/robotframework/parts/model_helper.py

@@ -19,7 +19,7 @@
 
 from ...common.lsp_types import Position
 from ..diagnostics.entities import VariableDefinition, VariableNotFoundDefinition
-from ..diagnostics.library_doc import KeywordDoc
+from ..diagnostics.library_doc import KeywordDoc, LibraryDoc
 from ..diagnostics.namespace import DEFAULT_BDD_PREFIXES, LibraryEntry, Namespace
 from ..utils.ast_utils import (
     Token,
@@ -580,12 +580,12 @@ def is_bdd_token(cls, namespace: Namespace, token: Token) -> bool:
             return False
 
     @classmethod
-    async def get_keyword_definition_at_token(cls, namespace: Namespace, token: Token) -> Optional[KeywordDoc]:
-        return await cls.get_keyword_definition_at_line(namespace, token.value, token.lineno)
+    def get_keyword_definition_at_token(cls, library_doc: LibraryDoc, token: Token) -> Optional[KeywordDoc]:
+        return cls.get_keyword_definition_at_line(library_doc, token.value, token.lineno)
 
     @classmethod
-    async def get_keyword_definition_at_line(cls, namespace: Namespace, value: str, line: int) -> Optional[KeywordDoc]:
+    def get_keyword_definition_at_line(cls, library_doc: LibraryDoc, value: str, line: int) -> Optional[KeywordDoc]:
         return next(
-            (k for k in (await namespace.get_library_doc()).keywords.get_all(value) if k.line_no == line),
+            (k for k in library_doc.keywords.get_all(value) if k.line_no == line),
             None,
         )

robotcode/language_server/robotframework/utils/async_ast.py

@@ -1,10 +1,10 @@
 import ast
-from typing import Any, AsyncGenerator, Callable, Optional, Type, cast
+from typing import Any, AsyncGenerator, Callable, Generator, Optional, Type, cast
 
 __all__ = ["iter_fields", "iter_child_nodes", "AsyncVisitor", "walk"]
 
 
-async def iter_fields(node: ast.AST) -> AsyncGenerator[Any, None]:
+def iter_fields(node: ast.AST) -> Generator[Any, None, None]:
     """
     Yield a tuple of ``(fieldname, value)`` for each field in ``node._fields``
     that is present on *node*.
@@ -16,12 +16,12 @@ async def iter_fields(node: ast.AST) -> AsyncGenerator[Any, None]:
             pass
 
 
-async def iter_child_nodes(node: ast.AST) -> AsyncGenerator[ast.AST, None]:
+def iter_child_nodes(node: ast.AST) -> Generator[ast.AST, None, None]:
     """
     Yield all direct child nodes of *node*, that is, all fields that are nodes
     and all items of fields that are lists of nodes.
     """
-    async for _name, field in iter_fields(node):
+    for _name, field in iter_fields(node):
         if isinstance(field, ast.AST):
             yield field
         elif isinstance(field, list):
@@ -36,12 +36,12 @@ async def walk(node: ast.AST) -> AsyncGenerator[ast.AST, None]:
     todo = deque([node])
     while todo:
         node = todo.popleft()
-        todo.extend([e async for e in iter_child_nodes(node)])
+        todo.extend([e for e in iter_child_nodes(node)])
         yield node
 
 
 async def iter_nodes(node: ast.AST) -> AsyncGenerator[ast.AST, None]:
-    async for _name, value in iter_fields(node):
+    for _name, value in iter_fields(node):
         if isinstance(value, list):
             for item in value:
                 if isinstance(item, ast.AST):
@@ -79,10 +79,26 @@ async def visit(self, node: ast.AST) -> None:
 
     async def generic_visit(self, node: ast.AST) -> None:
         """Called if no explicit visitor function exists for a node."""
-        async for field, value in iter_fields(node):
+        for _, value in iter_fields(node):
             if isinstance(value, list):
                 for item in value:
                     if isinstance(item, ast.AST):
                         await self.visit(item)
             elif isinstance(value, ast.AST):
                 await self.visit(value)
+
+
+class Visitor(VisitorFinder):
+    def visit(self, node: ast.AST) -> None:
+        visitor = self._find_visitor(type(node)) or self.generic_visit
+        visitor(node)
+
+    def generic_visit(self, node: ast.AST) -> None:
+        """Called if no explicit visitor function exists for a node."""
+        for field, value in iter_fields(node):
+            if isinstance(value, list):
+                for item in value:
+                    if isinstance(item, ast.AST):
+                        self.visit(item)
+            elif isinstance(value, ast.AST):
+                self.visit(value)