find unused references for arguments and local variables

Author: d-biehl

robotcode/language_server/robotframework/diagnostics/analyzer.py

@@ -30,6 +30,7 @@
     range_from_node,
     range_from_node_or_token,
     range_from_token,
+    strip_variable_token,
     tokenize_variables,
 )
 from ..utils.async_ast import AsyncVisitor
@@ -100,6 +101,46 @@ async def yield_argument_name_and_rest(self, node: ast.AST, token: Token) -> Asy
         else:
             yield token
 
+    async 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
+
+        variable = cast(Variable, node)
+
+        name_token = variable.get_token(RobotToken.VARIABLE)
+        name = name_token.value
+
+        if name is not None:
+
+            match = search_variable(name, ignore_errors=True)
+            if not match.is_assign(allow_assign_mark=True):
+                return
+
+            if name.endswith("="):
+                name = name[:-1].rstrip()
+
+            r = range_from_token(
+                strip_variable_token(
+                    RobotToken(name_token.type, name, name_token.lineno, name_token.col_offset, name_token.error)
+                )
+            )
+
+            var_def = next(
+                (
+                    v
+                    for v in await self.namespace.get_own_variables()
+                    if v.name_token is not None and range_from_token(v.name_token) == r
+                ),
+                None,
+            )
+
+            if var_def is None:
+                return
+
+            if var_def not in self._variable_references:
+                self._variable_references[var_def] = set()
+
     async def visit(self, node: ast.AST) -> None:
         from robot.parsing.lexer.tokens import Token as RobotToken
         from robot.parsing.model.statements import (
@@ -155,6 +196,12 @@ async def visit(self, node: ast.AST) -> None:
                                         self._variable_references[var].add(
                                             Location(self.namespace.document.document_uri, var_range)
                                         )
+                                    elif var not in self._variable_references and token1.type in [
+                                        RobotToken.ASSIGN,
+                                        RobotToken.ARGUMENT,
+                                    ]:
+                                        self._variable_references[var] = set()
+
             if (
                 isinstance(node, Statement)
                 and isinstance(node, self.get_expression_statement_types())

robotcode/language_server/robotframework/diagnostics/entities.py

@@ -194,7 +194,7 @@ class LocalVariableDefinition(VariableDefinition):
     type: VariableDefinitionType = VariableDefinitionType.LOCAL_VARIABLE
 
     def __hash__(self) -> int:
-        return hash((type(self), self.name, self.type))
+        return hash((type(self), self.name, self.type, self.range, self.source))
 
 
 @dataclass
@@ -221,15 +221,15 @@ class ArgumentDefinition(VariableDefinition):
     keyword_doc: Optional["KeywordDoc"] = None
 
     def __hash__(self) -> int:
-        return hash((type(self), self.name, self.type))
+        return hash((type(self), self.name, self.type, self.range, self.source))
 
 
 @dataclass
 class ImportedVariableDefinition(VariableDefinition):
     type: VariableDefinitionType = VariableDefinitionType.IMPORTED_VARIABLE
 
     def __hash__(self) -> int:
-        return hash((type(self), self.name, self.type))
+        return hash((type(self), self.name, self.type, self.source))
 
 
 @dataclass

robotcode/language_server/robotframework/parts/diagnostics.py

@@ -18,6 +18,7 @@
 from ...common.text_document import TextDocument
 from ..configuration import AnalysisConfig
 from ..diagnostics.analyzer import Analyzer
+from ..diagnostics.entities import ArgumentDefinition
 from ..utils.ast_utils import (
     HeaderAndBodyBlock,
     Token,
@@ -278,13 +279,14 @@ async def _collect_unused_references(self, document: TextDocument, full: bool) -
                         )
                     )
 
-            for var in await namespace.get_own_variables():
+            for var in (await namespace.get_variable_references()).keys():
                 references = await self.parent.robot_references.find_variable_references(document, var, False)
                 if not references and not await Analyzer.should_ignore(document, var.name_range):
                     result.append(
                         Diagnostic(
                             range=var.name_range,
-                            message=f"Variable '{var.name}' is not used.",
+                            message=f"{'Argument' if isinstance(var, ArgumentDefinition) else 'Variable'}"
+                            f" '{var.name}' is not used.",
                             severity=DiagnosticSeverity.WARNING,
                             source=self.source_name,
                             code="VariableNotUsed",