analysing, highlighting of "Wait Until Keyword Succeeds" and "Repeat Keyword"

Author: d-biehl

CHANGELOG.md

@@ -5,8 +5,11 @@ All notable changes to the "robotcode" extension will be documented in this file
 ## [Unreleased]
 
 ### added
-- for socket connections now a free port is used
 
+- for socket connections now a free port is used
+- collect variables and arguments to document symbols
+- analysing, highlighting of "Wait Until Keyword Succeeds" and "Repeat Keyword"
+  
 ##  0.4.0
 
 ### added

robotcode/language_server/robotframework/diagnostics/analyzer.py

@@ -171,13 +171,16 @@ async def _analyse_run_keyword(
             return argument_tokens[1:]
         elif (
             keyword_doc.is_run_keyword_with_condition()
-            and len(argument_tokens) > 1
-            and is_not_variable_token(argument_tokens[1])
+            and len(argument_tokens) > (cond_count := keyword_doc.run_keyword_condition_count())
+            and is_not_variable_token(argument_tokens[cond_count])
         ):
             await self._analyze_keyword_call(
-                unescape(argument_tokens[1].value), node, argument_tokens[1], argument_tokens[2:]
+                unescape(argument_tokens[cond_count].value),
+                node,
+                argument_tokens[cond_count],
+                argument_tokens[cond_count + 1 :],
             )
-            return argument_tokens[2:]
+            return argument_tokens[cond_count + 1 :]
         elif keyword_doc.is_run_keywords():
             has_and = False
             while argument_tokens:

robotcode/language_server/robotframework/diagnostics/library_doc.py

@@ -60,15 +60,27 @@
     "Run Keyword If Test Failed",
     "Run Keyword If Test Passed",
     "Run Keyword If Timeout Occurred",
+    "Run Keyword And Warn On Failure",
 ]
 
-RUN_KEYWORD_WITH_CONDITION_NAMES = ["Run Keyword And Expect Error", "Run Keyword And Return If", "Run Keyword Unless"]
+RUN_KEYWORD_WITH_CONDITION_NAMES: Dict[str, int] = {
+    "Run Keyword And Expect Error": 1,
+    "Run Keyword And Return If": 1,
+    "Run Keyword Unless": 1,
+    "Repeat Keyword": 1,
+    "Wait Until Keyword Succeeds": 2,
+}
 
 RUN_KEYWORD_IF_NAME = "Run Keyword If"
 
 RUN_KEYWORDS_NAME = "Run Keywords"
 
-ALL_RUN_KEYWORDS = [*RUN_KEYWORD_NAMES, *RUN_KEYWORD_WITH_CONDITION_NAMES, RUN_KEYWORDS_NAME, RUN_KEYWORD_IF_NAME]
+ALL_RUN_KEYWORDS = [
+    *RUN_KEYWORD_NAMES,
+    *RUN_KEYWORD_WITH_CONDITION_NAMES.keys(),
+    RUN_KEYWORDS_NAME,
+    RUN_KEYWORD_IF_NAME,
+]
 
 BUILTIN_LIBRARY_NAME = "BuiltIn"
 RESERVED_LIBRARY_NAME = "Reserved"
@@ -153,7 +165,7 @@ def __repr__(self) -> str:
         return f"{type(self).__name__}(name={repr(self.name)})"
 
 
-RUN_KEYWORD_WITH_CONDITION_MATCHERS = [KeywordMatcher(e) for e in RUN_KEYWORD_WITH_CONDITION_NAMES]
+RUN_KEYWORD_WITH_CONDITION_MATCHERS = [KeywordMatcher(e) for e in RUN_KEYWORD_WITH_CONDITION_NAMES.keys()]
 
 RUN_KEYWORD_IF_MATCHER = KeywordMatcher(RUN_KEYWORD_IF_NAME)
 
@@ -357,7 +369,14 @@ def is_run_keyword(self) -> bool:
         return self.libname == BUILTIN_LIBRARY_NAME and self.name in RUN_KEYWORD_NAMES
 
     def is_run_keyword_with_condition(self) -> bool:
-        return self.libname == BUILTIN_LIBRARY_NAME and self.name in RUN_KEYWORD_WITH_CONDITION_NAMES
+        return self.libname == BUILTIN_LIBRARY_NAME and self.name in RUN_KEYWORD_WITH_CONDITION_NAMES.keys()
+
+    def run_keyword_condition_count(self) -> int:
+        return (
+            RUN_KEYWORD_WITH_CONDITION_NAMES[self.name]
+            if self.libname == BUILTIN_LIBRARY_NAME and self.name in RUN_KEYWORD_WITH_CONDITION_NAMES.keys()
+            else 0
+        )
 
     def is_run_keyword_if(self) -> bool:
         return self.libname == BUILTIN_LIBRARY_NAME and self.name == RUN_KEYWORD_IF_NAME

robotcode/language_server/robotframework/parts/model_helper.py

@@ -29,14 +29,18 @@ async def get_run_keyword_keyworddoc_and_token_from_position(
             return result, argument_tokens[1:]
         elif (
             keyword_doc.is_run_keyword_with_condition()
-            and len(argument_tokens) > 1
+            and len(argument_tokens) > (cond_count := keyword_doc.run_keyword_condition_count())
             and is_not_variable_token(argument_tokens[1])
         ):
             result = await self.get_keyworddoc_and_token_from_position(
-                unescape(argument_tokens[1].value), argument_tokens[1], argument_tokens[2:], namespace, position
+                unescape(argument_tokens[cond_count].value),
+                argument_tokens[cond_count],
+                argument_tokens[cond_count + 1 :],
+                namespace,
+                position,
             )
 
-            return result, argument_tokens[2:]
+            return result, argument_tokens[cond_count + 1 :]
 
         elif keyword_doc.is_run_keywords():
             has_and = False

robotcode/language_server/robotframework/parts/references.py

@@ -421,9 +421,13 @@ async def get_keyword_references_from_any_run_keyword(
                 namespace, kw_doc, node, arguments[0], arguments[1:]
             ):
                 yield e
-        elif kw.is_run_keyword_with_condition() and len(arguments) > 1 and is_not_variable_token(arguments[1]):
+        elif (
+            kw.is_run_keyword_with_condition()
+            and len(arguments) > (cond_count := kw.run_keyword_condition_count())
+            and is_not_variable_token(arguments[1])
+        ):
             async for e in self.get_keyword_references_from_tokens(
-                namespace, kw_doc, node, arguments[1], arguments[2:], True
+                namespace, kw_doc, node, arguments[cond_count], arguments[cond_count + 1 :], True
             ):
                 yield e
         elif kw.is_run_keywords():

robotcode/language_server/robotframework/parts/semantic_tokens.py

@@ -384,11 +384,13 @@ async def skip_non_data_tokens() -> AsyncGenerator[Tuple[Token, ast.AST], None]:
                 ):
                     yield b
             elif kw_doc.is_run_keyword_with_condition() and len(arguments) > 0:
-                yield arguments[0], node,
-                arguments = arguments[1:]
+                cond_count = kw_doc.run_keyword_condition_count()
+                for _ in range(cond_count):
+                    yield arguments[0], node,
+                    arguments = arguments[1:]
 
-                async for b in skip_non_data_tokens():
-                    yield b
+                    async for b in skip_non_data_tokens():
+                        yield b
 
                 if len(arguments) > 0:
                     token = arguments[0]