refactor(diagnostics): unify number-literal detection helpers

Replace the direct `robot.variables.finders.NumberFinder` dependency and
the two duplicated `_try_resolve_number_literal` static methods with
shared `try_resolve_number_literal` / `is_number_literal` helpers in
`robot.utils.variables`, consumed from `model_helper`, `namespace_analyzer`
and the semantic `analyzer`.

Author: d-biehl

packages/robot/src/robotcode/robot/diagnostics/model_helper.py

@@ -21,7 +21,6 @@
 from robot.errors import VariableError
 from robot.parsing.lexer.tokens import Token
 from robot.utils.escaping import unescape
-from robot.variables.finders import NOT_FOUND, NumberFinder
 from robotcode.core.lsp.types import Position
 
 from ..utils import RF_VERSION
@@ -33,7 +32,7 @@
     whitespace_at_begin_of_token,
     whitespace_from_begin_of_token,
 )
-from ..utils.variables import contains_variable, search_variable, split_from_equals
+from ..utils.variables import contains_variable, is_number_literal, search_variable, split_from_equals
 from .entities import (
     LibraryEntry,
     VariableDefinition,
@@ -395,12 +394,6 @@ def iter_variables_from_token(
         skip_local_variables: bool = False,
         return_not_found: bool = False,
     ) -> Iterator[Tuple[Token, VariableDefinition]]:
-        def is_number(name: str) -> bool:
-            if name.startswith("$"):
-                finder = NumberFinder()
-                return bool(finder.find(name) != NOT_FOUND)
-            return False
-
         def iter_token(
             to: Token, ignore_errors: bool = False
         ) -> Iterator[Union[Token, Tuple[Token, VariableDefinition]]]:
@@ -483,7 +476,7 @@ def iter_token(
                     yield strip_variable_token(sub_token), var
                     continue
 
-                if is_number(sub_token.value):
+                if is_number_literal(sub_token.value):
                     continue
 
                 if (
@@ -511,7 +504,7 @@ def iter_token(
                         if var is not None:
                             yield strip_variable_token(sub_sub_token), var
                             continue
-                        if is_number(name):
+                        if is_number_literal(name):
                             continue
                         elif return_not_found:
                             if contains_variable(sub_token.value[2:-1]):

packages/robot/src/robotcode/robot/diagnostics/namespace_analyzer.py

@@ -28,7 +28,6 @@
     VariablesImport,
 )
 from robot.utils.escaping import unescape
-from robot.variables.finders import NOT_FOUND, NumberFinder
 from robotcode.core.concurrent import check_current_task_canceled
 from robotcode.core.lsp.types import (
     CodeDescription,
@@ -61,9 +60,11 @@
     InvalidVariableError,
     VariableMatcher,
     contains_variable,
+    is_number_literal,
     replace_curdir_in_variable_values,
     search_variable,
     split_from_equals,
+    try_resolve_number_literal,
 )
 from ..utils.visitor import Visitor
 from .analyzer_result import AnalyzerResult
@@ -1919,12 +1920,6 @@ def _find_variable(self, name: str) -> Optional[VariableDefinition]:
         except (VariableError, InvalidVariableError):
             return None
 
-    def _is_number(self, name: str) -> bool:
-        if name.startswith("$"):
-            finder = NumberFinder()
-            return bool(finder.find(name) != NOT_FOUND)
-        return False
-
     def _try_resolve_nested_variable_base(
         self, identifier: str, base: str, name_token: Token
     ) -> Union[str, Literal[False], tuple[None, str]]:
@@ -2004,7 +1999,7 @@ def _resolve_variable_to_string(self, var_ref: str, depth: int = 0) -> Union[str
         var_def = self._find_variable(var_ref)
         if var_def is None:
             # RF's NumberFinder: ${1}, ${3.14}, ${0xFF}, ${0b1010}, ${0o17}
-            number_str = self._try_resolve_number_literal(var_ref)
+            number_str = try_resolve_number_literal(var_ref)
             if number_str is not None:
                 return number_str
             # RF's ExtendedFinder: ${VAR.attr}, ${VAR[key]}, ${1-2}, etc.
@@ -2030,33 +2025,6 @@ def _resolve_variable_to_string(self, var_ref: str, depth: int = 0) -> Union[str
 
         return " ".join(resolved_items)
 
-    @staticmethod
-    def _try_resolve_number_literal(var_ref: str) -> Optional[str]:
-        """Detect RF number literals like ``${1}``, ``${3.14}``, ``${0xFF}``.
-
-        Mimics RF's ``NumberFinder``: strips spaces, lowercases, then tries
-        ``int()`` (with ``0b``/``0o``/``0x`` prefix support) and ``float()``.
-        Returns the string representation of the number, or ``None``.
-        """
-        inner = "".join(var_ref[2:-1].split()).casefold()
-        if not inner:
-            return None
-        bases = {"0b": 2, "0o": 8, "0x": 16}
-        for prefix, base in bases.items():
-            if inner.startswith(prefix):
-                try:
-                    return str(int(inner[2:], base))
-                except ValueError:
-                    return None
-        try:
-            return str(int(inner))
-        except ValueError:
-            pass
-        try:
-            return str(float(inner))
-        except ValueError:
-            return None
-
     def _is_extended_with_known_base(self, var_ref: str) -> bool:
         """Check if ``var_ref`` matches RF's extended variable syntax with a resolvable base.
 
@@ -2073,7 +2041,7 @@ def _is_extended_with_known_base(self, var_ref: str) -> bool:
         base_ref = f"${{{base_name}}}"
         if self._find_variable(base_ref) is not None:
             return True
-        if self._try_resolve_number_literal(base_ref) is not None:
+        if try_resolve_number_literal(base_ref) is not None:
             return True
         return False
 
@@ -2276,7 +2244,7 @@ def _iter_variables_from_token(self, token: Token) -> Iterator[Tuple[Token, Vari
                             )
                             continue
 
-                if self._is_number(var_token.value):
+                if is_number_literal(var_token.value):
                     continue
 
                 if (
@@ -2299,7 +2267,7 @@ def _iter_variables_from_token(self, token: Token) -> Iterator[Tuple[Token, Vari
                         if var is not None:
                             yield strip_variable_token(sub_sub_token), var
                             continue
-                        if self._is_number(name):
+                        if is_number_literal(name):
                             continue
                         else:
                             if contains_variable(var_token.value[2:-1], "$@&%"):

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

@@ -64,7 +64,6 @@
 from robot.parsing.model.statements import Error as RfError
 from robot.parsing.model.statements import ReturnStatement as RfReturnStatement
 from robot.utils.escaping import unescape
-from robot.variables.finders import NOT_FOUND, NumberFinder
 from robotcode.core.concurrent import check_current_task_canceled
 from robotcode.core.lsp.types import (
     CodeDescription,
@@ -97,9 +96,11 @@
     InvalidVariableError,
     VariableMatcher,
     contains_variable,
+    is_number_literal,
     replace_curdir_in_variable_values,
     search_variable,
     split_from_equals,
+    try_resolve_number_literal,
 )
 from ...utils.visitor import Visitor
 from ..analyzer_result import AnalyzerResult
@@ -3757,12 +3758,6 @@ def _find_variable(self, name: str) -> Optional[VariableDefinition]:
         except (VariableError, InvalidVariableError):
             return None
 
-    def _is_number(self, name: str) -> bool:
-        if name.startswith("$"):
-            finder = NumberFinder()
-            return bool(finder.find(name) != NOT_FOUND)
-        return False
-
     def _try_resolve_nested_variable_base(
         self, identifier: str, base: str, name_token: Token
     ) -> Union[str, Literal[False], tuple[None, str]]:
@@ -3842,7 +3837,7 @@ def _resolve_variable_to_string(self, var_ref: str, depth: int = 0) -> Union[str
         var_def = self._find_variable(var_ref)
         if var_def is None:
             # RF's NumberFinder: ${1}, ${3.14}, ${0xFF}, ${0b1010}, ${0o17}
-            number_str = self._try_resolve_number_literal(var_ref)
+            number_str = try_resolve_number_literal(var_ref)
             if number_str is not None:
                 return number_str
             # RF's ExtendedFinder: ${VAR.attr}, ${VAR[key]}, ${1-2}, etc.
@@ -3868,33 +3863,6 @@ def _resolve_variable_to_string(self, var_ref: str, depth: int = 0) -> Union[str
 
         return " ".join(resolved_items)
 
-    @staticmethod
-    def _try_resolve_number_literal(var_ref: str) -> Optional[str]:
-        """Detect RF number literals like ``${1}``, ``${3.14}``, ``${0xFF}``.
-
-        Mimics RF's ``NumberFinder``: strips spaces, lowercases, then tries
-        ``int()`` (with ``0b``/``0o``/``0x`` prefix support) and ``float()``.
-        Returns the string representation of the number, or ``None``.
-        """
-        inner = "".join(var_ref[2:-1].split()).casefold()
-        if not inner:
-            return None
-        bases = {"0b": 2, "0o": 8, "0x": 16}
-        for prefix, base in bases.items():
-            if inner.startswith(prefix):
-                try:
-                    return str(int(inner[2:], base))
-                except ValueError:
-                    return None
-        try:
-            return str(int(inner))
-        except ValueError:
-            pass
-        try:
-            return str(float(inner))
-        except ValueError:
-            return None
-
     def _is_extended_with_known_base(self, var_ref: str) -> bool:
         """Check if ``var_ref`` matches RF's extended variable syntax with a resolvable base.
 
@@ -3911,7 +3879,7 @@ def _is_extended_with_known_base(self, var_ref: str) -> bool:
         base_ref = f"${{{base_name}}}"
         if self._find_variable(base_ref) is not None:
             return True
-        if self._try_resolve_number_literal(base_ref) is not None:
+        if try_resolve_number_literal(base_ref) is not None:
             return True
         return False
 
@@ -4106,7 +4074,7 @@ def _resolve_variable_occurrence(
                 yield (reference_token, var)
             return
 
-        if self._is_number(occurrence.lookup_name):
+        if is_number_literal(occurrence.lookup_name):
             return
 
         if occurrence.strip_for_reference and occurrence.value.startswith(("${", "@{", "&{", "%{")):

packages/robot/src/robotcode/robot/utils/variables.py

@@ -228,6 +228,46 @@ def split_from_equals(string: str) -> Tuple[str, Optional[str]]:
     return cast(Tuple[str, Optional[str]], robot_split_from_equals(string))
 
 
+_NUMBER_LITERAL_BASES = {"0b": 2, "0o": 8, "0x": 16}
+
+
+@functools.lru_cache(maxsize=1024)
+def try_resolve_number_literal(var_ref: str) -> Optional[str]:
+    """Detect RF number literals like ``${1}``, ``${3.14}``, ``${0xFF}``.
+
+    Static reimplementation of RF's ``NumberFinder`` (which we avoid depending on
+    directly for compatibility): strips spaces, lowercases, then tries ``int()``
+    with ``0b`` / ``0o`` / ``0x`` prefix support, falling back to ``float()``.
+    Only ``${...}`` form is accepted; anything else returns ``None``.
+
+    Returns the canonical string representation of the number, or ``None``.
+    """
+    if not (var_ref.startswith("${") and var_ref.endswith("}")):
+        return None
+    inner = "".join(var_ref[2:-1].split()).casefold()
+    if not inner:
+        return None
+    for prefix, base in _NUMBER_LITERAL_BASES.items():
+        if inner.startswith(prefix):
+            try:
+                return str(int(inner[2:], base))
+            except ValueError:
+                return None
+    try:
+        return str(int(inner))
+    except ValueError:
+        pass
+    try:
+        return str(float(inner))
+    except ValueError:
+        return None
+
+
+def is_number_literal(name: str) -> bool:
+    """Check if ``name`` is an RF scalar number literal like ``${1}``, ``${3.14}``."""
+    return try_resolve_number_literal(name) is not None
+
+
 def replace_curdir_in_variable_values(values: Sequence[str], source: str) -> Tuple[str, ...]:
     """Replace ${CURDIR} in variable values with the escaped parent directory of source."""
     curdir = str(Path(source).parent).replace("\\", "\\\\")