fix(repl): keep keyword completion working after a return-value assignment

Starting a line with a return-value assignment — `${result}=    Some Keyword`, or several targets like `${a}    ${b}=    …` — no longer turns off keyword completion in the keyword cell. Completion and Tab now skip the assignment targets and complete the keyword (and then its arguments) just as they would without an assignment.

Author: d-biehl

packages/repl/src/robotcode/repl/_pt/completion.py

@@ -158,6 +158,11 @@ def current_keyword_and_arg_index(buffer: str, cursor: int) -> Optional[Tuple[st
 
 _VALID_SIGILS = "$@&%"
 
+# A return-value assignment target: `${x}` / `@{x}` / `&{x}` (no `%{env}`), with
+# an optional trailing `=` (Robot attaches it to the last target). Used to skip
+# the assignment prefix before the keyword cell, e.g. `${r}=    Some Keyword`.
+_ASSIGN_CELL = re.compile(r"^[$@&]\{[^{}]*\}\s*=?$")
+
 
 @dataclass(frozen=True)
 class CompletionContext:
@@ -209,7 +214,21 @@ def tokenize(buffer: str, cursor: int, *, setting_import_aliases: bool = False)
     if not prior_cells:
         return CompletionContext("keyword", current_cell, cell_start)
 
-    first_cell = prior_cells[0].strip()
+    # Return-value assignment: skip block-body indentation (leading empty cells)
+    # and any leading assignment targets (`${x}` / `@{x}` / `&{x}`, the last
+    # optionally ending with `=`) so the keyword cell still gets keyword
+    # completion and what follows is classified against the real keyword.
+    lead = 0
+    while lead < len(prior_cells) and not prior_cells[lead].strip():
+        lead += 1
+    assign_end = lead
+    while assign_end < len(prior_cells) and _ASSIGN_CELL.match(prior_cells[assign_end].strip()):
+        assign_end += 1
+    if assign_end == len(prior_cells):
+        # nothing but indentation and assignment targets so far → keyword cell
+        return CompletionContext("keyword", current_cell, cell_start)
+
+    first_cell = prior_cells[assign_end].strip()
     folded = first_cell.casefold()
     if folded == "import library" or (setting_import_aliases and folded == "library"):
         return CompletionContext("library", current_cell, cell_start)

tests/robotcode/repl/test_completion.py

@@ -129,6 +129,31 @@ def test_tokenize_setting_aliases_not_routed_without_optin() -> None:
     assert tokenize("Library    Coll", cursor=15).kind == "argument"
 
 
+def test_tokenize_return_assignment_keeps_keyword_completion() -> None:
+    # A leading return-value assignment must not steal keyword completion from
+    # the keyword cell. The `=` is optional and may sit on the last of several
+    # targets; `${}`/`@{}`/`&{}` all count.
+    for buf in (
+        "${result}=    Log To Con",
+        "${result}    Log To Con",
+        "${a}    ${b}=    Some Key",
+        "@{items}=    Create Lis",
+        "&{opts}=    Create Dic",
+    ):
+        assert tokenize(buf, len(buf)).kind == "keyword", buf
+
+
+def test_tokenize_return_assignment_then_keyword_args_route_normally() -> None:
+    # After the assignment, the keyword and its args classify against the real
+    # keyword — import routing and plain argument cells still work.
+    lib = "${x}=    Import Library    Coll"
+    assert tokenize(lib, len(lib)).kind == "library"
+    alias = "${x}=    Library    Coll"
+    assert tokenize(alias, len(alias), setting_import_aliases=True).kind == "library"
+    arg = "${x}=    Log    msg"
+    assert tokenize(arg, len(arg)).kind == "argument"
+
+
 @pytest.mark.parametrize("sigil", ["$", "@", "&", "%"])
 def test_tokenize_variable_opener_anywhere_in_cell(sigil: str) -> None:
     line = f"Log    Hello {sigil}{{world"