enhance BDD handling for RF 5.1

Author: d-biehl

package.json

@@ -163,7 +163,11 @@
           ],
           "error": [
             "invalid.illegal.robotframework"
+          ],
+          "config": [
+            "comment.line.configuration.robotframework"
           ]
+
         }
       }
     ],

robotcode/language_server/common/parts/diagnostics.py

@@ -108,7 +108,7 @@ def extend_capabilities(self, capabilities: ServerCapabilities) -> None:
             )
 
     @async_tasking_event_iterator
-    async def collect(sender, document: TextDocument, full: bool) -> DiagnosticsResult:  # NOSONAR
+    async def collect(sender, document: TextDocument) -> DiagnosticsResult:  # NOSONAR
         ...
 
     @async_tasking_event
@@ -150,39 +150,15 @@ async def ensure_workspace_loaded(self) -> None:
                         await self.on_workspace_loaded(self)
 
     async def get_document_diagnostics(self, document: TextDocument) -> RelatedFullDocumentDiagnosticReport:
-        # if self.collect_full_diagnostics:
-        return await document.get_cache(self.__get_full_document_diagnostics)
-        # return await document.get_cache(self.__get_document_diagnostics)
+        return await document.get_cache(self.__get_document_diagnostics)
 
     async def __get_document_diagnostics(self, document: TextDocument) -> RelatedFullDocumentDiagnosticReport:
         await self.ensure_workspace_loaded()
 
         diagnostics: List[Diagnostic] = []
 
         async for result_any in self.collect(
-            self,
-            document,
-            full=False,
-            callback_filter=language_id_filter(document),
-            return_exceptions=True,
-        ):
-            result = cast(DiagnosticsResult, result_any)
-
-            if isinstance(result, BaseException):
-                if not isinstance(result, asyncio.CancelledError):
-                    self._logger.exception(result, exc_info=result)
-            else:
-                diagnostics.extend(result.diagnostics or [])
-
-        return RelatedFullDocumentDiagnosticReport(items=diagnostics, result_id=str(uuid.uuid4()))
-
-    async def __get_full_document_diagnostics(self, document: TextDocument) -> RelatedFullDocumentDiagnosticReport:
-        await self.ensure_workspace_loaded()
-
-        diagnostics: List[Diagnostic] = []
-
-        async for result_any in self.collect(
-            self, document, full=True, callback_filter=language_id_filter(document), return_exceptions=True
+            self, document, callback_filter=language_id_filter(document), return_exceptions=True
         ):
             result = cast(DiagnosticsResult, result_any)
 
@@ -289,6 +265,9 @@ async def _get_partial_diagnostics() -> WorkspaceDiagnosticReport:
             ) as progress:
 
                 async def _task(doc: TextDocument) -> None:
+                    if doc.opened_in_editor:
+                        return
+
                     if await self.get_analysis_progress_mode(doc.uri) == AnalysisProgressMode.DETAILED:
                         path = doc.uri.to_path()
                         folder = self.parent.workspace.get_workspace_folder(doc.uri)

robotcode/language_server/common/parts/workspace.py

@@ -24,7 +24,6 @@
 )
 
 from ....jsonrpc2.protocol import rpc_method
-from ....utils.async_cache import AsyncSimpleLRUCache
 from ....utils.async_tools import (
     Lock,
     async_event,
@@ -162,7 +161,6 @@ def __init__(
         self._file_watchers_lock = Lock()
 
         self.parent.on_shutdown.add(self._on_shutdown)
-        self._config_cache = AsyncSimpleLRUCache(max_items=1000)
 
     @property
     def workspace_folders(self) -> List[WorkspaceFolder]:
@@ -239,7 +237,6 @@ async def did_change_configuration(sender, settings: Dict[str, Any]) -> None:  #
     @rpc_method(name="workspace/didChangeConfiguration", param_type=DidChangeConfigurationParams)
     @_logger.call
     async def _workspace_did_change_configuration(self, settings: Dict[str, Any], *args: Any, **kwargs: Any) -> None:
-        await self._config_cache.clear()
         self.settings = settings
         await self.did_change_configuration(self, settings)
 
@@ -315,10 +312,6 @@ async def _workspace_did_delete_files(self, files: List[FileDelete], *args: Any,
         await self.did_delete_files(self, list(f.uri for f in files))
 
     async def get_configuration(self, section: Type[_TConfig], scope_uri: Union[str, Uri, None] = None) -> _TConfig:
-        return await self._config_cache.get(self._get_configuration, section, scope_uri)
-
-    async def _get_configuration(self, section: Type[_TConfig], scope_uri: Union[str, Uri, None] = None) -> _TConfig:
-
         config = await self.get_configuration_raw(
             section=cast(HasConfigSection, section).__config_section__, scope_uri=scope_uri
         )
@@ -328,6 +321,7 @@ async def _get_configuration(self, section: Type[_TConfig], scope_uri: Union[str
     async def get_configuration_raw(
         self, section: Optional[str], scope_uri: Union[str, Uri, None] = None
     ) -> Optional[Any]:
+
         if (
             self.parent.client_capabilities
             and self.parent.client_capabilities.workspace

robotcode/language_server/robotframework/diagnostics/analyzer.py

@@ -306,7 +306,7 @@ async def _analyze_keyword_call(
             if not allow_variables and not is_not_variable_token(keyword_token):
                 return None
 
-            keyword_token = self.strip_bdd_prefix(keyword_token)
+            keyword_token = self.strip_bdd_prefix(self.namespace, keyword_token)
             kw_range = range_from_token(keyword_token)
 
             if keyword is not None:

robotcode/language_server/robotframework/diagnostics/library_doc.py

@@ -245,8 +245,6 @@ class ArgumentSpec:
     defaults: Any
     types: Any
 
-    __robot_arguments: Optional[Any] = field(default=None, compare=False)
-
     @staticmethod
     def from_robot_argument_spec(spec: Any) -> ArgumentSpec:
         return ArgumentSpec(
@@ -274,7 +272,7 @@ def resolve(
             ArgumentSpec as RobotArgumentSpec,
         )
 
-        if self.__robot_arguments is None:
+        if not hasattr(self, "__robot_arguments"):
             self.__robot_arguments = RobotArgumentSpec(
                 self.name,
                 self.type,
@@ -317,7 +315,9 @@ class KeywordDoc(SourceEntity):
     args_to_process: Optional[int] = field(default=None, compare=False)
     deprecated: bool = field(default=False, compare=False)
     arguments: Optional[ArgumentSpec] = field(default=None, compare=False)
-    argument_definitions: Optional[List[ArgumentDefinition]] = field(default=None, compare=False)
+    argument_definitions: Optional[List[ArgumentDefinition]] = field(
+        default=None, compare=False, repr=False, hash=False
+    )
 
     def __str__(self) -> str:
         return f"{self.name}({', '.join(str(arg) for arg in self.args)})"
@@ -476,11 +476,9 @@ class KeywordStore:
     source_type: Optional[str] = None
     keywords: List[KeywordDoc] = field(default_factory=list)
 
-    __matchers: Optional[Dict[KeywordMatcher, KeywordDoc]] = None
-
     @property
     def _matchers(self) -> Dict[KeywordMatcher, KeywordDoc]:
-        if self.__matchers is None:
+        if not hasattr(self, "__matchers"):
             self.__matchers = {KeywordMatcher(v.name): v for v in self.keywords}
         return self.__matchers
 

robotcode/language_server/robotframework/diagnostics/namespace.py

@@ -41,6 +41,7 @@
     Range,
 )
 from ...common.text_document import TextDocument
+from ..languages import Languages
 from ..utils.ast_utils import (
     Token,
     range_from_node,
@@ -51,6 +52,7 @@
 from ..utils.async_ast import AsyncVisitor
 from ..utils.match import eq
 from ..utils.variables import BUILTIN_VARIABLES
+from ..utils.version import get_robot_version
 from .entities import (
     ArgumentDefinition,
     BuiltInVariableDefinition,
@@ -547,6 +549,7 @@ def __init__(
         invalidated_callback: Callable[[Namespace], None],
         document: Optional[TextDocument] = None,
         document_type: Optional[DocumentType] = None,
+        languages: Optional[Languages] = None,
     ) -> None:
         super().__init__()
 
@@ -557,6 +560,7 @@ def __init__(
         self.invalidated_callback = invalidated_callback
         self._document = weakref.ref(document) if document is not None else None
         self.document_type: Optional[DocumentType] = document_type
+        self.languages = languages
 
         self._libraries: OrderedDict[str, LibraryEntry] = OrderedDict()
         self._libraries_matchers: Optional[Dict[KeywordMatcher, LibraryEntry]] = None
@@ -1769,9 +1773,22 @@ def _create_custom_and_standard_keyword_conflict_warning_message(
         )
 
     async def _get_bdd_style_keyword(self, name: str) -> Optional[KeywordDoc]:
-        lower = name.lower()
-        for prefix in ["given ", "when ", "then ", "and ", "but "]:
-            if lower.startswith(prefix):
-                return await self._find_keyword(name[len(prefix) :])  # noqa: E203
+        if get_robot_version() < (5, 1):
+            lower = name.lower()
+            for prefix in ["given ", "when ", "then ", "and ", "but "]:
+                if lower.startswith(prefix):
+                    return await self._find_keyword(name[len(prefix) :])  # noqa: E203
+            return None
 
-        return None
+        else:
+            parts = name.split(maxsplit=1)
+            if len(parts) < 2:
+                return None
+            prefix, keyword = parts
+            if prefix.title() in (
+                self.namespace.languages.bdd_prefixes
+                if self.namespace.languages is not None
+                else {"Given ", "When ", "Then ", "And ", "But "}
+            ):
+                return await self._find_keyword(keyword)
+            return None

robotcode/language_server/robotframework/languages.py

@@ -0,0 +1,15 @@
+from typing import Any, Dict, Iterator, List, Protocol, Set, runtime_checkable
+
+
+@runtime_checkable
+class Languages(Protocol):
+    languages: List[Any]
+    headers: Dict[str, str]
+    settings: Dict[str, str]
+    bdd_prefixes: Set[str]
+
+    def add_language(self, name: str) -> None:
+        ...
+
+    def __iter__(self) -> Iterator[Any]:
+        ...

robotcode/language_server/robotframework/parts/completion.py

@@ -915,7 +915,7 @@ async def _complete_TestCase_or_Keyword(  # noqa: N802
             if len(statement_node.tokens) > index:
                 token = statement_node.tokens[index]
 
-                token = self.strip_bdd_prefix(token)
+                token = self.strip_bdd_prefix(self.namespace, token)
 
                 r = range_from_token(token)
                 if position.is_in_range(r):
@@ -930,7 +930,11 @@ async def _complete_TestCase_or_Keyword(  # noqa: N802
                     r.end.character += 1
                     if position.is_in_range(r):
                         return await create_items(
-                            in_assign, in_template, r, None if self.is_bdd_token(token) else token, position
+                            in_assign,
+                            in_template,
+                            r,
+                            None if self.is_bdd_token(self.namespace, token) else token,
+                            position,
                         )
 
         return None
@@ -1052,12 +1056,12 @@ async def _complete_SuiteSetup_or_SuiteTeardown_or_TestTemplate(  # noqa: N802
         if len(statement_node.tokens) > 2:
             token = cast(Token, statement_node.tokens[2])
 
-            token = self.strip_bdd_prefix(token)
+            token = self.strip_bdd_prefix(self.namespace, token)
 
             r = range_from_token(token)
             if position.is_in_range(r):
                 return await self.create_keyword_completion_items(
-                    None if self.is_bdd_token(token) else token,
+                    None if self.is_bdd_token(self.namespace, token) else token,
                     position,
                     add_reserverd=False,
                     add_none=True,
@@ -1073,7 +1077,7 @@ async def _complete_SuiteSetup_or_SuiteTeardown_or_TestTemplate(  # noqa: N802
             r.end.character += 1
             if position.is_in_range(r):
                 return await self.create_keyword_completion_items(
-                    None if self.is_bdd_token(token) else token,
+                    None if self.is_bdd_token(self.namespace, token) else token,
                     position,
                     add_reserverd=False,
                     add_none=True,
@@ -1183,7 +1187,7 @@ async def complete_Setup_or_Teardown_or_Template(  # noqa: N802
         if len(statement_node.tokens) > 3:
             token = cast(Token, statement_node.tokens[3])
 
-            token = self.strip_bdd_prefix(token)
+            token = self.strip_bdd_prefix(self.namespace, token)
 
             r = range_from_token(token)
             if position.is_in_range(r):
@@ -1200,7 +1204,7 @@ async def complete_Setup_or_Teardown_or_Template(  # noqa: N802
             r.end.character += 1
             if position.is_in_range(r):
                 return await self.create_keyword_completion_items(
-                    None if self.is_bdd_token(token) else token,
+                    None if self.is_bdd_token(self.namespace, token) else token,
                     position,
                     add_reserverd=False,
                     add_none=True,

robotcode/language_server/robotframework/parts/diagnostics.py

@@ -57,10 +57,7 @@ async def namespace_invalidated(self, sender: Any, document: TextDocument) -> No
     @language_id("robotframework")
     @threaded()
     @_logger.call
-    async def collect_namespace_diagnostics(self, sender: Any, document: TextDocument, full: bool) -> DiagnosticsResult:
-        return await document.get_cache(self._collect_namespace_diagnostics, full)
-
-    async def _collect_namespace_diagnostics(self, document: TextDocument, full: bool) -> 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:
@@ -126,10 +123,7 @@ def _create_error_from_token(self, token: Token, source: Optional[str] = None) -
     @language_id("robotframework")
     @threaded()
     @_logger.call
-    async def collect_token_errors(self, sender: Any, document: TextDocument, full: bool) -> DiagnosticsResult:
-        return await document.get_cache(self._collect_token_errors, full)
-
-    async def _collect_token_errors(self, document: TextDocument, full: bool) -> DiagnosticsResult:
+    async def collect_token_errors(self, sender: Any, document: TextDocument) -> DiagnosticsResult:
         from robot.errors import VariableError
         from robot.parsing.lexer.tokens import Token
 
@@ -195,11 +189,7 @@ async def _collect_token_errors(self, document: TextDocument, full: bool) -> Dia
     @language_id("robotframework")
     @threaded()
     @_logger.call
-    async def collect_model_errors(self, sender: Any, document: TextDocument, full: bool) -> DiagnosticsResult:
-        return await document.get_cache(self._collect_model_errors, full)
-
-    async def _collect_model_errors(self, document: TextDocument, full: bool) -> DiagnosticsResult:
-
+    async def collect_model_errors(self, sender: Any, document: TextDocument) -> DiagnosticsResult:
         from ..utils.ast_utils import HasError, HasErrors
         from ..utils.async_ast import iter_nodes
 
@@ -247,18 +237,15 @@ async def _collect_model_errors(self, document: TextDocument, full: bool) -> Dia
     @language_id("robotframework")
     @threaded()
     @_logger.call
-    async def collect_unused_references(self, sender: Any, document: TextDocument, full: bool) -> DiagnosticsResult:
+    async def collect_unused_references(self, sender: Any, document: TextDocument) -> DiagnosticsResult:
         config = await self.parent.workspace.get_configuration(AnalysisConfig, document.uri)
 
-        if not full or not config.find_unused_references:
+        if not config.find_unused_references:
             return DiagnosticsResult(self.collect_unused_references, [])
 
-        return await document.get_cache(self._collect_unused_references, full)
-
-    async def _collect_unused_references(self, document: TextDocument, full: bool) -> DiagnosticsResult:
-        if not full:
-            return DiagnosticsResult(self.collect_unused_references, [])
+        return await self._collect_unused_references(document)
 
+    async def _collect_unused_references(self, document: TextDocument) -> DiagnosticsResult:
         try:
             namespace = await self.parent.documents_cache.get_namespace(document)
             if namespace is None:

robotcode/language_server/robotframework/parts/discovering.py

@@ -294,7 +294,7 @@ def generate(suite: TestSuite) -> TestItem:
             try:
                 config = await self.get_config(workspace_folder)
                 rpa_mode = config.get_rpa_mode() if config is not None else None
-                languages = config.languages if config is not None else None
+                languages = await self.parent.documents_cache.get_workspace_languages(workspace_folder)
 
                 if paths is None and config is not None:
                     paths = config.paths