fix(robot): correct type-hint handling in semantic analyzer

strip variable type hints only in declaration contexts
preserve typed names in usage lookups
resolve nested typed variable declarations correctly
stop splitting type hints on additional colons in tokenizer
add regression tests for variables, VAR, assignments and arguments

Author: d-biehl

packages/robot/src/robotcode/robot/diagnostics/semantic_analyzer/analyzer.py

@@ -354,8 +354,7 @@ def _visit_Variable(self, node: Variable) -> None:  # noqa: N802
 
                 # Resolve nested variable references inside the variable name
                 # so that e.g. ${a} in ${INVALID VAR ${a}} gets hover/go-to-definition.
-                inner_token = Token(Token.ARGUMENT, matcher.base, name_token.lineno, name_token.col_offset + 2)
-                for var_token, var in self._iter_variables_from_occurrences(inner_token):
+                for var_token, var in self._iter_nested_variables_from_declaration_token(name_token):
                     self._handle_find_variable_result(var_token, var)
 
                 resolved = self._try_resolve_nested_variable_base(matcher.identifier, matcher.base, name_token)
@@ -542,8 +541,7 @@ def visit_Var(self, node: Var) -> None:  # noqa: N802
                             )
                             return
 
-                    inner_token = Token(Token.ARGUMENT, matcher.base, name_token.lineno, name_token.col_offset + 2)
-                    for var_token, var in self._iter_variables_from_occurrences(inner_token):
+                    for var_token, var in self._iter_nested_variables_from_declaration_token(name_token):
                         self._handle_find_variable_result(var_token, var)
 
                     resolved = self._try_resolve_nested_variable_base(matcher.identifier, matcher.base, name_token)
@@ -846,8 +844,14 @@ def visit(self, node: ast.AST) -> None:
         finally:
             self._node_stack.pop()
 
-    def _analyze_token_variables(self, token: Token, severity: DiagnosticSeverity = DiagnosticSeverity.ERROR) -> None:
-        for var_token, var in self._iter_variables_from_occurrences(token):
+    def _analyze_token_variables(
+        self,
+        token: Token,
+        severity: DiagnosticSeverity = DiagnosticSeverity.ERROR,
+        *,
+        parse_type: bool = False,
+    ) -> None:
+        for var_token, var in self._iter_variables_from_occurrences(token, parse_type=parse_type):
             self._handle_find_variable_result(var_token, var, severity)
 
     def _handle_find_variable_result(
@@ -1820,8 +1824,14 @@ def _analyze_assign_statement(self, node: Statement) -> None:
                         if empty_var in matcher.base:
                             return
 
-                    inner_token = Token(Token.ARGUMENT, matcher.base, assign_token.lineno, assign_token.col_offset + 2)
-                    for var_token, var in self._iter_variables_from_occurrences(inner_token):
+                    assign_name_token = Token(
+                        Token.VARIABLE,
+                        assign_token.value[:-1].rstrip() if assign_token.value.endswith("=") else assign_token.value,
+                        assign_token.lineno,
+                        assign_token.col_offset,
+                        assign_token.error,
+                    )
+                    for var_token, var in self._iter_nested_variables_from_declaration_token(assign_name_token):
                         self._handle_find_variable_result(var_token, var)
 
                     resolved = self._try_resolve_nested_variable_base(matcher.identifier, matcher.base, assign_token)
@@ -2721,11 +2731,16 @@ def _resolve_string_expression(self, raw_str: str, depth: int) -> Union[str, Lit
 
     # --- Variable token iteration ---
 
-    def _iter_variables_from_occurrences(self, token: Token) -> Iterator[Tuple[Token, VariableDefinition]]:
-        for occurrence in self._iter_variable_occurrences(token):
+    def _iter_variables_from_occurrences(
+        self,
+        token: Token,
+        *,
+        parse_type: bool = False,
+    ) -> Iterator[Tuple[Token, VariableDefinition]]:
+        for occurrence in self._iter_variable_occurrences(token, parse_type=parse_type):
             yield from self._resolve_variable_occurrence(occurrence)
 
-    def _iter_variable_occurrences(self, token: Token) -> Iterator[VariableOccurrence]:
+    def _iter_variable_occurrences(self, token: Token, *, parse_type: bool = False) -> Iterator[VariableOccurrence]:
         def exception_handler(e: BaseException, t: Token) -> None:
             self._append_diagnostics(
                 range_from_token(t),
@@ -2737,11 +2752,22 @@ def exception_handler(e: BaseException, t: Token) -> None:
         yield from iter_variable_occurrences_from_token(
             token,
             identifiers="$@&%",
+            parse_type=parse_type,
             ignore_errors=True,
             extra_types=None,
             exception_handler=exception_handler,
         )
 
+    def _iter_nested_variables_from_declaration_token(self, token: Token) -> Iterator[Tuple[Token, VariableDefinition]]:
+        skipped_root = False
+
+        for occurrence in self._iter_variable_occurrences(token, parse_type=True):
+            if not skipped_root:
+                skipped_root = True
+                continue
+
+            yield from self._resolve_variable_occurrence(occurrence)
+
     def _resolve_variable_occurrence(
         self,
         occurrence: VariableOccurrence,

packages/robot/src/robotcode/robot/diagnostics/semantic_analyzer/variable_tokenizer.py

@@ -50,15 +50,17 @@ class VariableOccurrence:
     strip_for_reference: bool = True
 
 
-def build_variable_occurrence(value: str, line: int, col_offset: int) -> VariableOccurrence:
+def build_variable_occurrence(
+    value: str, line: int, col_offset: int, *, parse_type: bool = False
+) -> VariableOccurrence:
     """Parse a single variable expression once and return shared occurrence data."""
     sub_tokens = build_variable_sub_tokens(value, line, col_offset)
     return VariableOccurrence(
         value=value,
         line=line,
         col_offset=col_offset,
         length=len(value),
-        lookup_name=normalize_variable_lookup_name(value),
+        lookup_name=normalize_variable_lookup_name(value, parse_type=parse_type),
         semantic_sub_tokens=sub_tokens if sub_tokens else None,
     )
 
@@ -157,6 +159,7 @@ def iter_variable_occurrences_from_token(
     token: Token,
     identifiers: str = "$@&%",
     *,
+    parse_type: bool = False,
     ignore_errors: bool = False,
     extra_types: Optional[Set[str]] = None,
     exception_handler: Optional[Callable[[Exception, Token], None]] = None,
@@ -168,7 +171,7 @@ def iter_variable_occurrences_from_token(
     """
     parsed_token = token
     if token.type == Token.VARIABLE and token.value.endswith("="):
-        match = search_variable(token.value, ignore_errors=True)
+        match = search_variable(token.value, ignore_errors=True, parse_type=parse_type)
         if not match.is_assign(allow_assign_mark=True):
             return
 
@@ -190,18 +193,24 @@ def iter_variable_occurrences_from_token(
         if sub_token.type != Token.VARIABLE:
             continue
 
-        occurrence = build_variable_occurrence(sub_token.value, sub_token.lineno, sub_token.col_offset)
+        occurrence = build_variable_occurrence(
+            sub_token.value,
+            sub_token.lineno,
+            sub_token.col_offset,
+            parse_type=parse_type,
+        )
         yield from iter_related_occurrences(occurrence)
 
 
-def normalize_variable_lookup_name(value: str) -> Optional[str]:
+def normalize_variable_lookup_name(value: str, *, parse_type: bool = False) -> Optional[str]:
     """Normalize a variable expression to a lookup name for static resolution.
 
     Examples:
     - `${obj.attr}` -> `${obj}`
     - `${var}[0][x]` -> `${var}`
     - `%{HOME=default}` -> `%{HOME}`
     - `${{expr}}` -> None
+    - `${age: int}` -> `${age}` only when ``parse_type=True`` (declaration context)
     """
     if not value or len(value) < 3:
         return None
@@ -238,28 +247,41 @@ def normalize_variable_lookup_name(value: str) -> Optional[str]:
     if not inner:
         return None
 
-    # Try extended syntax first: extract the base variable name before any
-    # operator/expression.  This must happen *before* the nested-variable
-    # guard because the tail may contain nested variables (e.g.
-    # ``${A + '${B}'}``) while the base name ``A`` is perfectly resolvable.
-    # Skip when the extension starts with a variable identifier (``${``,
-    # ``@{`` etc.) — that indicates a **nested variable name** like
-    # ``${cfg_${env}}``, not an expression.
-    extended_match = _MATCH_EXTENDED.match(inner)
-    if extended_match:
-        ext_part = extended_match.group(2)
-        if not ext_part.startswith(("${", "@{", "&{", "%{")):
-            inner = extended_match.group(1)
+    # Type hint check must precede extended-syntax matching: `: ` in `${age: int}` would
+    # otherwise be consumed by _MATCH_EXTENDED (which accepts any [^\s\w] operator) and
+    # silently strip the type even in reference contexts.  RF itself only strips the type
+    # hint when search_variable() is called with parse_type=True — i.e. in declaration
+    # contexts (Variables section, [Arguments], VAR, FOR, Assignment).
+    if prefix == "$" and ": " in inner:
+        if parse_type:
+            inner = inner.split(": ", 1)[0]
+        # else: keep inner with type hint intact; the full `${age: int}` is the lookup name.
+    else:
+        # Try extended syntax first: extract the base variable name before any
+        # operator/expression.  This must happen *before* the nested-variable
+        # guard because the tail may contain nested variables (e.g.
+        # ``${A + '${B}'}``) while the base name ``A`` is perfectly resolvable.
+        # Skip when the extension starts with a variable identifier (``${``,
+        # ``@{`` etc.) — that indicates a **nested variable name** like
+        # ``${cfg_${env}}``, not an expression.
+        extended_match = _MATCH_EXTENDED.match(inner)
+        if extended_match:
+            ext_part = extended_match.group(2)
+            if not ext_part.startswith(("${", "@{", "&{", "%{")):
+                inner = extended_match.group(1)
 
     if "${" in inner or "@{" in inner or "&{" in inner or "%{" in inner:
         return None
 
     if prefix == "%" and "=" in inner:
         inner = inner.split("=", 1)[0]
-    elif prefix == "$" and ": " in inner:
-        inner = inner.split(": ", 1)[0]
-    elif prefix == "$" and ":" in inner:
-        inner = inner.split(":", 1)[0]
+    elif prefix == "$" and ":" in inner and ": " not in inner:
+        # Bare colon: embedded argument pattern ${arg:\d+}.
+        # Type hints (`: ` with space) are handled above, gated by parse_type.
+        # Preserve builtin ${:}; only treat ':' as pattern separator when both sides exist.
+        head, _, tail = inner.partition(":")
+        if head and tail:
+            inner = head
 
     inner = inner.strip()
     if not inner:
@@ -491,7 +513,9 @@ def _decompose_variable_inner(
     if "${" in inner or "@{" in inner or "&{" in inner or "%{" in inner:
         return _decompose_nested_variable(inner, line, col_offset)
 
-    # Check for type hint: ${age: int} or ${name: str:\w+}
+    # Check for type hint: ${age: int}
+    # RF uses ': ' (colon + space) as the type separator.
+    # Everything after ': ' is the type hint — no further splitting.
     if ": " in inner and prefix_char == "$":
         colon_pos = inner.index(": ")
         base = inner[:colon_pos]
@@ -516,48 +540,15 @@ def _decompose_variable_inner(
             )
         )
 
-        # Check for pattern after type: ${name: str:\w+}
-        if ":" in rest:
-            pattern_sep = rest.index(":")
-            type_hint = rest[:pattern_sep]
-            pattern = rest[pattern_sep + 1 :]
-            tokens.append(
-                SemanticToken(
-                    kind=TokenKind.VARIABLE_TYPE_HINT,
-                    value=type_hint,
-                    line=line,
-                    col_offset=col_offset + colon_pos + 2,
-                    length=len(type_hint),
-                )
-            )
-            tokens.append(
-                SemanticToken(
-                    kind=TokenKind.VARIABLE_PATTERN_SEPARATOR,
-                    value=":",
-                    line=line,
-                    col_offset=col_offset + colon_pos + 2 + len(type_hint),
-                    length=1,
-                )
-            )
-            tokens.append(
-                SemanticToken(
-                    kind=TokenKind.VARIABLE_PATTERN,
-                    value=pattern,
-                    line=line,
-                    col_offset=col_offset + colon_pos + 2 + len(type_hint) + 1,
-                    length=len(pattern),
-                )
-            )
-        else:
-            tokens.append(
-                SemanticToken(
-                    kind=TokenKind.VARIABLE_TYPE_HINT,
-                    value=rest,
-                    line=line,
-                    col_offset=col_offset + colon_pos + 2,
-                    length=len(rest),
-                )
+        tokens.append(
+            SemanticToken(
+                kind=TokenKind.VARIABLE_TYPE_HINT,
+                value=rest,
+                line=line,
+                col_offset=col_offset + colon_pos + 2,
+                length=len(rest),
             )
+        )
         return tokens
 
     # Check for embedded pattern without type: ${arg:\d+}
@@ -855,7 +846,7 @@ def _iter_related_occurrences_from_token(
             line=token.line,
             col_offset=token.col_offset,
             length=token.length,
-            lookup_name=normalize_variable_lookup_name(token.value),
+            lookup_name=normalize_variable_lookup_name(token.value, parse_type=False),
             semantic_sub_tokens=token.sub_tokens if token.sub_tokens else None,
         )
         yield nested

tests/robotcode/robot/diagnostics/test_semantic_analyzer/test_analyzer.py

@@ -13,6 +13,7 @@
 from typing import List
 from unittest.mock import MagicMock
 
+import pytest
 from robot.api import get_model
 
 from robotcode.robot.diagnostics.analyzer_result import AnalyzerResult
@@ -32,6 +33,7 @@
     WhileStatement,
 )
 from robotcode.robot.diagnostics.variable_scope import VariableScope
+from robotcode.robot.utils import RF_VERSION
 
 
 def _parse(text: str) -> AST:
@@ -648,6 +650,82 @@ def test_statement_count_reasonable(self) -> None:
         assert len(result.semantic_model.statements) >= 4
 
 
+@pytest.mark.skipif(RF_VERSION < (7, 3), reason="Argument type hints require RF >= 7.3")
+class TestArgumentTypeHints:
+    def test_typed_arguments_define_untyped_lookup_variable(self) -> None:
+        result = _run_analyzer(
+            """\
+*** Keywords ***
+K
+    [Arguments]    ${a: int}
+    Log    ${a}
+
+*** Test Cases ***
+T
+    K    1
+"""
+        )
+
+        var_names = {v.name for v in result.variable_references}
+        assert "${a}" in var_names
+
+        variable_not_found = [d for d in result.diagnostics if str(d.code) == "VariableNotFound"]
+        assert len(variable_not_found) == 0
+
+    def test_typed_argument_reference_is_not_normalized_in_usage(self) -> None:
+        result = _run_analyzer(
+            """\
+*** Keywords ***
+K
+    [Arguments]    ${a: int}
+    Log    ${a: int}
+
+*** Test Cases ***
+T
+    K    1
+"""
+        )
+
+        assert any(str(d.code) == "VariableNotFound" and "${a: int}" in d.message for d in result.diagnostics)
+
+    def test_complex_typed_arguments_define_untyped_lookup_variable(self) -> None:
+        result = _run_analyzer(
+            """\
+*** Keywords ***
+K
+    [Arguments]    ${a: Literal["abc", ":", ";"] | List[Literal[1,2,3]]}
+    Log    ${a}
+
+*** Test Cases ***
+T
+    K    abc
+"""
+        )
+
+        var_names = {v.name for v in result.variable_references}
+        assert "${a}" in var_names
+        assert not any(str(d.code) == "VariableNotFound" and "${a}" in d.message for d in result.diagnostics)
+
+    def test_complex_typed_argument_reference_is_not_normalized_in_usage(self) -> None:
+        result = _run_analyzer(
+            """\
+*** Keywords ***
+K
+    [Arguments]    ${a: Literal["abc", ":", ";"] | List[Literal[1,2,3]]}
+    Log    ${a: Literal["abc", ":", ";"] | List[Literal[1,2,3]]}
+
+*** Test Cases ***
+T
+    K    abc
+"""
+        )
+
+        assert any(
+            str(d.code) == "VariableNotFound" and '${a: Literal["abc", ":", ";"] | List[Literal[1,2,3]]}' in d.message
+            for d in result.diagnostics
+        )
+
+
 # --- Structural statement visitors (END, BREAK, CONTINUE, TRY, ELSE, FINALLY) ---