robotcode-robot 0.94.0__py3-none-any.whl → 0.95.1__py3-none-any.whl

robotcode/robot/diagnostics/model_helper.py

@@ -21,9 +21,8 @@ from typing import (
 
 from robot.errors import VariableError
 from robot.parsing.lexer.tokens import Token
-from robot.utils.escaping import split_from_equals, unescape
+from robot.utils.escaping import unescape
 from robot.variables.finders import NOT_FOUND, NumberFinder
-from robot.variables.search import contains_variable, search_variable
 from robotcode.core.lsp.types import Position
 
 from ..utils import get_robot_version
@@ -35,6 +34,7 @@ from ..utils.ast import (
     whitespace_at_begin_of_token,
     whitespace_from_begin_of_token,
 )
+from ..utils.variables import contains_variable, search_variable, split_from_equals
 from .entities import (
     LibraryEntry,
     VariableDefinition,
@@ -210,10 +210,14 @@ class ModelHelper:
         position: Position,
         analyse_run_keywords: bool = True,
     ) -> Optional[Tuple[Optional[KeywordDoc], Token]]:
-        keyword_doc = namespace.find_keyword(keyword_name, raise_keyword_error=False)
+        finder = namespace.get_finder()
+        keyword_doc = finder.find_keyword(keyword_name, raise_keyword_error=False)
         if keyword_doc is None:
             return None
 
+        if finder.result_bdd_prefix:
+            keyword_token = ModelHelper.strip_bdd_prefix(namespace, keyword_token)
+
         if position.is_in_range(range_from_token(keyword_token)):
             return keyword_doc, keyword_token
 
@@ -661,12 +665,12 @@ class ModelHelper:
 
     @classmethod
     def get_keyword_definition_at_token(cls, library_doc: LibraryDoc, token: Token) -> Optional[KeywordDoc]:
-        return cls.get_keyword_definition_at_line(library_doc, token.value, token.lineno)
+        return cls.get_keyword_definition_at_line(library_doc, token.lineno)
 
     @classmethod
-    def get_keyword_definition_at_line(cls, library_doc: LibraryDoc, value: str, line: int) -> Optional[KeywordDoc]:
+    def get_keyword_definition_at_line(cls, library_doc: LibraryDoc, line: int) -> Optional[KeywordDoc]:
         return next(
-            (k for k in library_doc.keywords.iter_all(value) if k.line_no == line),
+            (k for k in library_doc.keywords.keywords if k.line_no == line),
             None,
         )
 

robotcode/robot/diagnostics/namespace.py

@@ -1,7 +1,6 @@
 import ast
 import enum
 import itertools
-import time
 import weakref
 from collections import OrderedDict, defaultdict
 from concurrent.futures import CancelledError
@@ -29,11 +28,6 @@ from robot.parsing.model.statements import ResourceImport as RobotResourceImport
 from robot.parsing.model.statements import (
     VariablesImport as RobotVariablesImport,
 )
-from robot.variables.search import (
-    is_scalar_assign,
-    is_variable,
-    search_variable,
-)
 from robotcode.core.concurrent import RLock
 from robotcode.core.event import event
 from robotcode.core.lsp.types import (
@@ -58,7 +52,12 @@ from ..utils.ast import (
     tokenize_variables,
 )
 from ..utils.stubs import Languages
-from ..utils.variables import BUILTIN_VARIABLES
+from ..utils.variables import (
+    BUILTIN_VARIABLES,
+    is_scalar_assign,
+    is_variable,
+    search_variable,
+)
 from ..utils.visitor import Visitor
 from .entities import (
     ArgumentDefinition,
@@ -894,6 +893,7 @@ class Namespace:
                 self._namespaces[KeywordMatcher(v.alias or v.name or v.import_name, is_namespace=True)].append(v)
             for v in (self.get_resources()).values():
                 self._namespaces[KeywordMatcher(v.alias or v.name or v.import_name, is_namespace=True)].append(v)
+
         return self._namespaces
 
     def get_resources(self) -> Dict[str, ResourceEntry]:
@@ -1794,38 +1794,27 @@ class Namespace:
 
         libdoc = self.get_library_doc()
 
-        for doc in itertools.chain(
+        yield from itertools.chain(
             self.get_imported_keywords(),
             libdoc.keywords if libdoc is not None else [],
-        ):
-            yield doc
+        )
 
     @_logger.call
     def get_keywords(self) -> List[KeywordDoc]:
         with self._keywords_lock:
             if self._keywords is None:
-                current_time = time.monotonic()
-                self._logger.debug("start collecting keywords")
-                try:
-                    i = 0
 
-                    self.ensure_initialized()
+                i = 0
 
-                    result: Dict[KeywordMatcher, KeywordDoc] = {}
+                self.ensure_initialized()
 
-                    for doc in self.iter_all_keywords():
-                        i += 1
-                        result[doc.matcher] = doc
+                result: Dict[KeywordMatcher, KeywordDoc] = {}
 
-                    self._keywords = list(result.values())
-                except BaseException:
-                    self._logger.debug("Canceled collecting keywords ")
-                    raise
-                else:
-                    self._logger.debug(
-                        lambda: f"end collecting {len(self._keywords) if self._keywords else 0}"
-                        f" keywords in {time.monotonic() - current_time}s analyze {i} keywords"
-                    )
+                for doc in self.iter_all_keywords():
+                    i += 1
+                    result[doc.matcher] = doc
+
+                self._keywords = list(result.values())
 
             return self._keywords
 

robotcode/robot/diagnostics/namespace_analyzer.py

@@ -8,7 +8,7 @@ from dataclasses import dataclass
 from io import StringIO
 from pathlib import Path
 from tokenize import TokenError, generate_tokens
-from typing import TYPE_CHECKING, Any, Dict, Iterator, List, Optional, Set, Tuple, Union, cast
+from typing import TYPE_CHECKING, Any, Callable, Dict, Iterator, List, Optional, Set, Tuple, Union, cast
 
 from robot.errors import VariableError
 from robot.parsing.lexer.tokens import Token
@@ -28,9 +28,8 @@ from robot.parsing.model.statements import (
     Variable,
     VariablesImport,
 )
-from robot.utils.escaping import split_from_equals, unescape
+from robot.utils.escaping import unescape
 from robot.variables.finders import NOT_FOUND, NumberFinder
-from robot.variables.search import contains_variable, is_scalar_assign, is_variable, search_variable
 from robotcode.core.concurrent import check_current_task_canceled
 from robotcode.core.lsp.types import (
     CodeDescription,
@@ -43,6 +42,7 @@ from robotcode.core.lsp.types import (
     Range,
 )
 from robotcode.core.uri import Uri
+from robotcode.core.utils.logging import LoggingDescriptor
 
 from ..utils import get_robot_version
 from ..utils.ast import (
@@ -53,11 +53,13 @@ from ..utils.ast import (
     strip_variable_token,
     tokenize_variables,
 )
+from ..utils.variables import contains_variable, is_scalar_assign, is_variable, search_variable, split_from_equals
 from ..utils.visitor import Visitor
 from .entities import (
     ArgumentDefinition,
     EnvironmentVariableDefinition,
     GlobalVariableDefinition,
+    InvalidVariableError,
     LibraryEntry,
     LocalVariableDefinition,
     TestVariableDefinition,
@@ -94,6 +96,9 @@ class AnalyzerResult:
 
 
 class NamespaceAnalyzer(Visitor):
+
+    _logger = LoggingDescriptor()
+
     def __init__(
         self,
         model: ast.AST,
@@ -126,8 +131,11 @@ class NamespaceAnalyzer(Visitor):
         self._overridden_variables: Dict[VariableDefinition, VariableDefinition] = {}
 
         self._in_setting = False
+        self._in_block_setting = False
 
         self._suite_variables = self._variables.copy()
+        self._block_variables: Optional[Dict[VariableMatcher, VariableDefinition]] = None
+        self._end_block_handlers: Optional[List[Callable[[], None]]] = None
 
     def run(self) -> AnalyzerResult:
         self._diagnostics = []
@@ -146,10 +154,11 @@ class NamespaceAnalyzer(Visitor):
         except BaseException as e:
             self._append_diagnostics(
                 range_from_node(self._model),
-                message=f"Fatal: can't analyze namespace '{e}')",
+                message=f"Fatal: can't analyze namespace '{e}'.",
                 severity=DiagnosticSeverity.ERROR,
                 code=type(e).__qualname__,
             )
+            self._logger.exception(e)
 
         return AnalyzerResult(
             self._diagnostics,
@@ -379,6 +388,15 @@ class NamespaceAnalyzer(Visitor):
         finally:
             self._in_setting = False
 
+    def _visit_block_settings_statement(
+        self, node: Statement, severity: DiagnosticSeverity = DiagnosticSeverity.ERROR
+    ) -> None:
+        self._in_block_setting = True
+        try:
+            self._visit_settings_statement(node, severity)
+        finally:
+            self._in_block_setting = False
+
     def _analyze_token_expression_variables(
         self, token: Token, severity: DiagnosticSeverity = DiagnosticSeverity.ERROR
     ) -> None:
@@ -476,7 +494,7 @@ class NamespaceAnalyzer(Visitor):
                         range=range_from_token(var_token),
                         message=f"Environment variable '{var.name}' not found.",
                         severity=severity,
-                        code=Error.ENVIROMMENT_VARIABLE_NOT_FOUND,
+                        code=Error.ENVIRONMENT_VARIABLE_NOT_FOUND,
                     )
 
             if var.type == VariableDefinitionType.ENVIRONMENT_VARIABLE:
@@ -531,6 +549,20 @@ class NamespaceAnalyzer(Visitor):
             )
         )
 
+    KEYWORDS_WITH_EXPRESSIONS = [
+        "BuiltIn.Evaluate",
+        "BuiltIn.Should Be True",
+        "BuiltIn.Should Not Be True",
+        "BuiltIn.Skip If",
+        "BuiltIn.Continue For Loop If",
+        "BuiltIn.Exit For Loop If",
+        "BuiltIn.Return From Keyword If",
+        "BuiltIn.Run Keyword And Return If",
+        "BuiltIn.Pass Execution If",
+        "BuiltIn.Run Keyword If",
+        "BuiltIn.Run Keyword Unless",
+    ]
+
     def _analyze_keyword_call(
         self,
         node: ast.AST,
@@ -552,13 +584,11 @@ class NamespaceAnalyzer(Visitor):
             if not allow_variables and not is_not_variable_token(keyword_token):
                 return None
 
-            result = self._finder.find_keyword(keyword, raise_keyword_error=False, handle_bdd_style=False)
+            result = self._finder.find_keyword(keyword, raise_keyword_error=False)
 
-            if result is None:
+            if result is not None and self._finder.result_bdd_prefix:
                 keyword_token = ModelHelper.strip_bdd_prefix(self._namespace, keyword_token)
 
-                result = self._finder.find_keyword(keyword, raise_keyword_error=False)
-
             kw_range = range_from_token(keyword_token)
 
             if keyword:
@@ -710,19 +740,7 @@ class NamespaceAnalyzer(Visitor):
             )
 
         if result is not None:
-            if result.longname in [
-                "BuiltIn.Evaluate",
-                "BuiltIn.Should Be True",
-                "BuiltIn.Should Not Be True",
-                "BuiltIn.Skip If",
-                "BuiltIn.Continue For Loop If",
-                "BuiltIn.Exit For Loop If",
-                "BuiltIn.Return From Keyword If",
-                "BuiltIn.Run Keyword And Return If",
-                "BuiltIn.Pass Execution If",
-                "BuiltIn.Run Keyword If",
-                "BuiltIn.Run Keyword Unless",
-            ]:
+            if result.longname in self.KEYWORDS_WITH_EXPRESSIONS:
                 tokens = argument_tokens
                 if tokens and (token := tokens[0]):
                     self._analyze_token_expression_variables(token)
@@ -896,7 +914,29 @@ class NamespaceAnalyzer(Visitor):
 
         if keyword_token is not None and keyword_token.value and keyword_token.value.upper() not in ("", "NONE"):
             self._analyze_token_variables(keyword_token)
-            self._analyze_statement_variables(node)
+            self._visit_block_settings_statement(node)
+
+            self._analyze_keyword_call(
+                node,
+                keyword_token,
+                [e for e in node.get_tokens(Token.ARGUMENT)],
+                allow_variables=True,
+                ignore_errors_if_contains_variables=True,
+            )
+
+    def visit_Teardown(self, node: Fixture) -> None:  # noqa: N802
+        keyword_token = node.get_token(Token.NAME)
+
+        # TODO: calculate possible variables in NAME
+
+        if keyword_token is not None and keyword_token.value and keyword_token.value.upper() not in ("", "NONE"):
+
+            def _handler() -> None:
+                self._analyze_token_variables(keyword_token)
+                self._analyze_statement_variables(node)
+
+            if self._end_block_handlers is not None:
+                self._end_block_handlers.append(_handler)
 
             self._analyze_keyword_call(
                 node,
@@ -984,9 +1024,15 @@ class NamespaceAnalyzer(Visitor):
         self._current_testcase_or_keyword_name = node.name
         old_variables = self._variables
         self._variables = self._variables.copy()
+        self._end_block_handlers = []
         try:
             self.generic_visit(node)
+
+            for handler in self._end_block_handlers:
+                handler()
+
         finally:
+            self._end_block_handlers = None
             self._variables = old_variables
             self._current_testcase_or_keyword_name = None
             self._template = None
@@ -1029,13 +1075,21 @@ class NamespaceAnalyzer(Visitor):
         self._current_testcase_or_keyword_name = node.name
         old_variables = self._variables
         self._variables = self._variables.copy()
+        self._end_block_handlers = []
         try:
             arguments = next((v for v in node.body if isinstance(v, Arguments)), None)
             if arguments is not None:
                 self._visit_Arguments(arguments)
+            self._block_variables = self._variables.copy()
 
             self.generic_visit(node)
+
+            for handler in self._end_block_handlers:
+                handler()
+
         finally:
+            self._end_block_handlers = None
+            self._block_variables = None
             self._variables = old_variables
             self._current_testcase_or_keyword_name = None
             self._current_keyword_doc = None
@@ -1132,7 +1186,7 @@ class NamespaceAnalyzer(Visitor):
                             )
                         )
 
-            except VariableError:
+            except (VariableError, InvalidVariableError):
                 pass
 
     def _analyze_assign_statement(self, node: Statement) -> None:
@@ -1172,7 +1226,7 @@ class NamespaceAnalyzer(Visitor):
                             )
                         )
 
-            except VariableError:
+            except (VariableError, InvalidVariableError):
                 pass
 
     def visit_InlineIfHeader(self, node: Statement) -> None:  # noqa: N802
@@ -1186,7 +1240,7 @@ class NamespaceAnalyzer(Visitor):
         variables = node.get_tokens(Token.VARIABLE)
         for variable in variables:
             variable_token = self._get_variable_token(variable)
-            if variable_token is not None:
+            if variable_token is not None and is_variable(variable_token.value):
                 existing_var = self._find_variable(variable_token.value)
 
                 if existing_var is None or existing_var.type not in [
@@ -1248,7 +1302,7 @@ class NamespaceAnalyzer(Visitor):
                             source=self._namespace.source,
                         )
 
-            except VariableError:
+            except (VariableError, InvalidVariableError):
                 pass
 
     def _format_template(self, template: str, arguments: Tuple[str, ...]) -> Tuple[str, Tuple[str, ...]]:
@@ -1351,7 +1405,7 @@ class NamespaceAnalyzer(Visitor):
         self._visit_settings_statement(node, DiagnosticSeverity.HINT)
 
     def visit_Timeout(self, node: Statement) -> None:  # noqa: N802
-        self._analyze_statement_variables(node, DiagnosticSeverity.HINT)
+        self._visit_block_settings_statement(node)
 
     def visit_SingleValue(self, node: Statement) -> None:  # noqa: N802
         self._visit_settings_statement(node, DiagnosticSeverity.HINT)
@@ -1399,19 +1453,35 @@ class NamespaceAnalyzer(Visitor):
                     code=Error.DEPRECATED_HEADER,
                 )
 
-    def visit_ReturnSetting(self, node: Statement) -> None:  # noqa: N802
-        self._analyze_statement_variables(node)
+    if get_robot_version() >= (7, 0):
 
-        if get_robot_version() >= (7, 0):
-            token = node.get_token(Token.RETURN_SETTING)
-            if token is not None and token.error:
-                self._append_diagnostics(
-                    range=range_from_node_or_token(node, token),
-                    message=token.error,
-                    severity=DiagnosticSeverity.WARNING,
-                    tags=[DiagnosticTag.DEPRECATED],
-                    code=Error.DEPRECATED_RETURN_SETTING,
-                )
+        def visit_ReturnSetting(self, node: Statement) -> None:  # noqa: N802
+
+            def _handler() -> None:
+                self._analyze_statement_variables(node)
+
+            if self._end_block_handlers is not None:
+                self._end_block_handlers.append(_handler)
+
+            if get_robot_version() >= (7, 0):
+                token = node.get_token(Token.RETURN_SETTING)
+                if token is not None and token.error:
+                    self._append_diagnostics(
+                        range=range_from_node_or_token(node, token),
+                        message=token.error,
+                        severity=DiagnosticSeverity.WARNING,
+                        tags=[DiagnosticTag.DEPRECATED],
+                        code=Error.DEPRECATED_RETURN_SETTING,
+                    )
+
+    else:
+
+        def visit_Return(self, node: Statement) -> None:  # noqa: N802
+            def _handler() -> None:
+                self._analyze_statement_variables(node)
+
+            if self._end_block_handlers is not None:
+                self._end_block_handlers.append(_handler)
 
     def _check_import_name(self, value: Optional[str], node: ast.AST, type: str) -> None:
         if not value:
@@ -1540,11 +1610,18 @@ class NamespaceAnalyzer(Visitor):
                 default_value=default_value or None,
             )
 
-        vars = self._suite_variables if self._in_setting else self._variables
+        vars = (
+            self._block_variables
+            if self._block_variables and self._in_block_setting
+            else self._suite_variables if self._in_setting else self._variables
+        )
 
-        matcher = VariableMatcher(name)
+        try:
+            matcher = VariableMatcher(name)
 
-        return vars.get(matcher, None)
+            return vars.get(matcher, None)
+        except (VariableError, InvalidVariableError):
+            return None
 
     def _is_number(self, name: str) -> bool:
         if name.startswith("$"):

robotcode/robot/utils/ast.py

@@ -38,13 +38,6 @@ def cached_isinstance(obj: Any, *expected_types: Type[_T]) -> TypeGuard[Union[_T
         return False
 
 
-# def cached_isinstance(obj: Any, *expected_types: type) -> bool:
-#     try:
-#         return isinstance(obj, expected_types)
-#     except TypeError:
-#         return False
-
-
 def iter_nodes(node: ast.AST, descendants: bool = True) -> Iterator[ast.AST]:
     for _field, value in ast.iter_fields(node):
         if cached_isinstance(value, list):

robotcode/robot/utils/match.py

@@ -3,13 +3,13 @@ from functools import lru_cache
 _transform_table = str.maketrans("", "", "_ ")
 
 
-@lru_cache(maxsize=5000)
+@lru_cache(maxsize=None)
 def normalize(text: str) -> str:
     # return text.lower().replace("_", "").replace(" ", "")
     return text.casefold().translate(_transform_table)
 
 
-@lru_cache(maxsize=5000)
+@lru_cache(maxsize=None)
 def normalize_namespace(text: str) -> str:
     return text.lower().replace(" ", "")
 

robotcode/robot/utils/robot_path.py

@@ -1,22 +1,12 @@
-from __future__ import annotations
-
 import sys
 from os import PathLike
 from pathlib import Path
 from typing import Optional, Union
 
 
-def find_file(
-    path: Union[Path, PathLike[str], str],
-    basedir: Union[Path, PathLike[str], str] = ".",
-    file_type: Optional[str] = None,
-) -> str:
-    return find_file_ex(path, basedir, file_type)
-
-
 def find_file_ex(
-    path: Union[Path, PathLike[str], str],
-    basedir: Union[Path, PathLike[str], str] = ".",
+    path: Union[Path, "PathLike[str]", str],
+    basedir: Union[Path, "PathLike[str]", str] = ".",
     file_type: Optional[str] = None,
 ) -> str:
     from robot.errors import DataError
@@ -25,6 +15,7 @@ def find_file_ex(
     ret = _find_absolute_path(path) if path.is_absolute() else _find_relative_path(path, basedir)
     if ret:
         return str(ret)
+
     default = file_type or "File"
 
     file_type = (
@@ -40,15 +31,23 @@ def find_file_ex(
     raise DataError("%s '%s' does not exist." % (file_type, path))
 
 
-def _find_absolute_path(path: Union[Path, PathLike[str], str]) -> Optional[str]:
+def find_file(
+    path: Union[Path, "PathLike[str]", str],
+    basedir: Union[Path, "PathLike[str]", str] = ".",
+    file_type: Optional[str] = None,
+) -> str:
+    return find_file_ex(path, basedir, file_type)
+
+
+def _find_absolute_path(path: Union[Path, "PathLike[str]", str]) -> Optional[str]:
     if _is_valid_file(path):
         return str(path)
     return None
 
 
 def _find_relative_path(
-    path: Union[Path, PathLike[str], str],
-    basedir: Union[Path, PathLike[str], str],
+    path: Union[Path, "PathLike[str]", str],
+    basedir: Union[Path, "PathLike[str]", str],
 ) -> Optional[str]:
     for base in [basedir, *sys.path]:
         if not base:
@@ -65,6 +64,6 @@ def _find_relative_path(
     return None
 
 
-def _is_valid_file(path: Union[Path, PathLike[str], str]) -> bool:
+def _is_valid_file(path: Union[Path, "PathLike[str]", str]) -> bool:
     path = Path(path)
     return path.is_file() or (path.is_dir() and Path(path, "__init__.py").is_fifo())

robotcode/robot/utils/stubs.py

@@ -1,22 +1,4 @@
-from __future__ import annotations
-
-from typing import Any, Dict, Iterator, List, Optional, Protocol, Set, runtime_checkable
-
-
-@runtime_checkable
-class HasError(Protocol):
-    error: Optional[str]
-
-
-@runtime_checkable
-class HasErrors(Protocol):
-    errors: Optional[List[str]]
-
-
-@runtime_checkable
-class HeaderAndBodyBlock(Protocol):
-    header: Any
-    body: List[Any]
+from typing import Any, Dict, Iterator, List, Protocol, Set, runtime_checkable
 
 
 @runtime_checkable

robotcode/robot/utils/variables.py

@@ -1,3 +1,13 @@
+import functools
+from typing import Optional, Tuple, cast
+
+from robot.utils.escaping import split_from_equals as robot_split_from_equals
+from robot.variables.search import VariableMatch as RobotVariableMatch
+from robot.variables.search import contains_variable as robot_contains_variable
+from robot.variables.search import is_scalar_assign as robot_is_scalar_assign
+from robot.variables.search import is_variable as robot_is_variable
+from robot.variables.search import search_variable as robot_search_variable
+
 BUILTIN_VARIABLES = [
     "${CURDIR}",
     "${EMPTY}",
@@ -35,3 +45,28 @@ BUILTIN_VARIABLES = [
     "${DEBUG_FILE}",
     "${OUTPUT_DIR}",
 ]
+
+
+@functools.lru_cache(maxsize=512)
+def contains_variable(string: str, identifiers: str = "$@&") -> bool:
+    return cast(bool, robot_contains_variable(string, identifiers))
+
+
+@functools.lru_cache(maxsize=512)
+def is_scalar_assign(string: str, allow_assign_mark: bool = False) -> bool:
+    return cast(bool, robot_is_scalar_assign(string, allow_assign_mark))
+
+
+@functools.lru_cache(maxsize=512)
+def is_variable(string: str, identifiers: str = "$@&") -> bool:
+    return cast(bool, robot_is_variable(string, identifiers))
+
+
+@functools.lru_cache(maxsize=512)
+def search_variable(string: str, identifiers: str = "$@&%*", ignore_errors: bool = False) -> RobotVariableMatch:
+    return robot_search_variable(string, identifiers, ignore_errors)
+
+
+@functools.lru_cache(maxsize=512)
+def split_from_equals(string: str) -> Tuple[str, Optional[str]]:
+    return cast(Tuple[str, Optional[str]], robot_split_from_equals(string))

robotcode/robot/utils/visitor.py

@@ -2,7 +2,6 @@ import ast
 from abc import ABC
 from typing import (
     Any,
-    AsyncIterator,
     Callable,
     Dict,
     Iterator,
@@ -37,32 +36,6 @@ def iter_field_values(node: ast.AST) -> Iterator[Any]:
             pass
 
 
-def iter_child_nodes(node: ast.AST) -> Iterator[ast.AST]:
-    for _name, field in iter_fields(node):
-        if isinstance(field, ast.AST):
-            yield field
-        elif isinstance(field, list):
-            for item in field:
-                if isinstance(item, ast.AST):
-                    yield item
-
-
-async def iter_nodes(node: ast.AST) -> AsyncIterator[ast.AST]:
-    for _name, value in iter_fields(node):
-        if isinstance(value, list):
-            for item in value:
-                if isinstance(item, ast.AST):
-                    yield item
-                    async for n in iter_nodes(item):
-                        yield n
-
-        elif isinstance(value, ast.AST):
-            yield value
-
-            async for n in iter_nodes(value):
-                yield n
-
-
 class VisitorFinder(ABC):
     __cls_finder_cache__: Dict[Type[Any], Optional[Callable[..., Any]]]