refactor: Replace *Generator with *Iterator

Author: d-biehl

robotcode/__version__.py

@@ -1 +1 @@
-__version__ = "0.25.2.dev22+gba3f589.d20230203"
+__version__ = "0.25.2"

robotcode/debugger/debugger.py

@@ -15,7 +15,7 @@
     ClassVar,
     Deque,
     Dict,
-    Generator,
+    Iterator,
     List,
     Literal,
     NamedTuple,
@@ -964,7 +964,7 @@ def source_from_entry(entry: StackFrameEntry) -> Optional[Source]:
             else:
                 return None
 
-        def yield_stack() -> Generator[StackFrame, None, None]:
+        def yield_stack() -> Iterator[StackFrame]:
             for i, v in enumerate(itertools.islice(self.stack_frames, start_frame, levels)):
                 if v.stack_frames:
                     yield StackFrame(

robotcode/language_server/robotframework/diagnostics/analyzer.py

@@ -6,7 +6,7 @@
 import os
 from collections import defaultdict
 from dataclasses import dataclass
-from typing import Any, Dict, Generator, List, Optional, Set, Tuple, Union, cast
+from typing import Any, Dict, Iterator, List, Optional, Set, Tuple, Union, cast
 
 from ....utils.uri import Uri
 from ...common.lsp_types import (
@@ -91,7 +91,7 @@ async def run(self) -> AnalyzerResult:
 
         return AnalyzerResult(self._diagnostics, self._keyword_references, self._variable_references)
 
-    def yield_argument_name_and_rest(self, node: ast.AST, token: Token) -> Generator[Token, None, None]:
+    def yield_argument_name_and_rest(self, node: ast.AST, token: Token) -> Iterator[Token]:
         from robot.parsing.lexer.tokens import Token as RobotToken
         from robot.parsing.model.statements import Arguments
 

robotcode/language_server/robotframework/diagnostics/namespace.py

@@ -14,10 +14,10 @@
 from pathlib import Path
 from typing import (
     Any,
-    AsyncGenerator,
+    AsyncIterator,
     Dict,
-    Generator,
     Iterable,
+    Iterator,
     List,
     NamedTuple,
     Optional,
@@ -920,7 +920,7 @@ async def yield_variables(
         nodes: Optional[List[ast.AST]] = None,
         position: Optional[Position] = None,
         skip_commandline_variables: bool = False,
-    ) -> AsyncGenerator[Tuple[VariableMatcher, VariableDefinition], None]:
+    ) -> AsyncIterator[Tuple[VariableMatcher, VariableDefinition]]:
         from robot.parsing.model.blocks import Keyword, TestCase
         from robot.parsing.model.statements import Arguments
 
@@ -1494,7 +1494,7 @@ async def get_imported_keywords(self) -> List[KeywordDoc]:
             return self._imported_keywords
 
     @_logger.call
-    async def iter_all_keywords(self) -> AsyncGenerator[KeywordDoc, None]:
+    async def iter_all_keywords(self) -> AsyncIterator[KeywordDoc]:
         import itertools
 
         libdoc = await self.get_library_doc()
@@ -1799,7 +1799,7 @@ def _get_keyword_from_self(self, name: str) -> Optional[KeywordDoc]:
                 )
                 raise CancelSearchError() from e
 
-    def _yield_owner_and_kw_names(self, full_name: str) -> Generator[Tuple[str, ...], None, None]:
+    def _yield_owner_and_kw_names(self, full_name: str) -> Iterator[Tuple[str, ...]]:
         tokens = full_name.split(".")
         for i in range(1, len(tokens)):
             yield ".".join(tokens[:i]), ".".join(tokens[i:])

robotcode/language_server/robotframework/parts/completion.py

@@ -8,7 +8,7 @@
 from typing import (
     TYPE_CHECKING,
     Any,
-    AsyncGenerator,
+    AsyncIterator,
     Awaitable,
     Callable,
     Dict,
@@ -242,7 +242,7 @@ def __init__(
         self.namespace = namespace
         self.config = config
 
-    async def _find_methods(self, cls: Type[Any]) -> AsyncGenerator[_CompleteMethod, None]:
+    async def _find_methods(self, cls: Type[Any]) -> AsyncIterator[_CompleteMethod]:
         if cls is ast.AST:
             return
 
@@ -266,7 +266,7 @@ async def collect(
 
         result_nodes.reverse()
 
-        async def iter_results() -> AsyncGenerator[List[CompletionItem], None]:
+        async def iter_results() -> AsyncIterator[List[CompletionItem]]:
             for result_node in result_nodes:
                 async for method in self._find_methods(type(result_node)):
                     r = await method(result_node, result_nodes, position, context)

robotcode/language_server/robotframework/parts/documents_cache.py

@@ -7,8 +7,8 @@
     TYPE_CHECKING,
     Any,
     Callable,
-    Generator,
     Iterable,
+    Iterator,
     List,
     Optional,
     Tuple,
@@ -292,7 +292,7 @@ def __get_model(self, document: TextDocument, tokens: Iterable[Any], document_ty
         from robot.parsing.lexer import Token
         from robot.parsing.parser.parser import _get_model
 
-        def get_tokens(source: str, data_only: bool = False, lang: Any = None) -> Generator[Token, None, None]:
+        def get_tokens(source: str, data_only: bool = False, lang: Any = None) -> Iterator[Token]:
             for t in tokens:
                 check_canceled_sync()
 

robotcode/language_server/robotframework/parts/inline_value.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import ast
-from typing import TYPE_CHECKING, Any, Generator, List, Optional, Tuple
+from typing import TYPE_CHECKING, Any, Iterator, List, Optional, Tuple
 
 from ....utils.async_itertools import async_dropwhile, async_takewhile
 from ....utils.logging import LoggingDescriptor
@@ -53,7 +53,7 @@ async def collect(
 
         nodes = await get_nodes_at_position(model, context.stopped_location.start)
 
-        def get_tokens() -> Generator[Tuple[Token, ast.AST], None, None]:
+        def get_tokens() -> Iterator[Tuple[Token, ast.AST]]:
             for n in iter_nodes(model):
                 r = range_from_node(n)
                 if (r.start in real_range or r.end in real_range) and isinstance(n, HasTokens):

robotcode/language_server/robotframework/parts/model_helper.py

@@ -7,9 +7,9 @@
 from tokenize import TokenError, generate_tokens
 from typing import (
     Any,
-    AsyncGenerator,
+    AsyncIterator,
     Dict,
-    Generator,
+    Iterator,
     List,
     Optional,
     Set,
@@ -242,7 +242,7 @@ async def iter_expression_variables_from_token(
         position: Optional[Position] = None,
         skip_commandline_variables: bool = False,
         return_not_found: bool = False,
-    ) -> AsyncGenerator[Tuple[Token, VariableDefinition], Any]:
+    ) -> AsyncIterator[Tuple[Token, VariableDefinition]]:
         from robot.api.parsing import Token as RobotToken
 
         variable_started = False
@@ -330,7 +330,7 @@ def _tokenize_variables(
         ignore_errors: bool = False,
         *,
         extra_types: Optional[Set[str]] = None,
-    ) -> Generator[Token, Any, Any]:
+    ) -> Iterator[Token]:
         from robot.api.parsing import Token as RobotToken
 
         for t in tokenize_variables(token, identifiers, ignore_errors, extra_types=extra_types):
@@ -352,7 +352,7 @@ async def iter_variables_from_token(
         position: Optional[Position] = None,
         skip_commandline_variables: bool = False,
         return_not_found: bool = False,
-    ) -> AsyncGenerator[Tuple[Token, VariableDefinition], Any]:
+    ) -> AsyncIterator[Tuple[Token, VariableDefinition]]:
         from robot.api.parsing import Token as RobotToken
         from robot.variables.search import contains_variable, search_variable
 
@@ -366,7 +366,7 @@ def is_number(name: str) -> bool:
 
         async def iter_token(
             to: Token, ignore_errors: bool = False
-        ) -> AsyncGenerator[Union[Token, Tuple[Token, VariableDefinition]], Any]:
+        ) -> AsyncIterator[Union[Token, Tuple[Token, VariableDefinition]]]:
             for sub_token in cls._tokenize_variables(to, ignore_errors=ignore_errors):
                 if sub_token.type == RobotToken.VARIABLE:
                     base = sub_token.value[2:-1]

robotcode/language_server/robotframework/parts/semantic_tokens.py

@@ -9,7 +9,7 @@
 from typing import (
     TYPE_CHECKING,
     Any,
-    AsyncGenerator,
+    AsyncIterator,
     Dict,
     FrozenSet,
     List,
@@ -263,7 +263,7 @@ async def generate_sem_sub_tokens(
         node: ast.AST,
         col_offset: Optional[int] = None,
         length: Optional[int] = None,
-    ) -> AsyncGenerator[SemTokenInfo, None]:
+    ) -> AsyncIterator[SemTokenInfo]:
         from robot.parsing.lexer.tokens import Token as RobotToken
         from robot.parsing.model.statements import (
             Arguments,
@@ -485,7 +485,7 @@ async def generate_sem_tokens(
         builtin_library_doc: Optional[LibraryDoc],
         libraries_matchers: Dict[KeywordMatcher, LibraryEntry],
         resources_matchers: Dict[KeywordMatcher, ResourceEntry],
-    ) -> AsyncGenerator[SemTokenInfo, None]:
+    ) -> AsyncIterator[SemTokenInfo]:
         from robot.parsing.lexer.tokens import Token as RobotToken
         from robot.parsing.model.statements import Variable
         from robot.utils.escaping import split_from_equals
@@ -533,11 +533,11 @@ async def generate_run_kw_tokens(
         kw_token: Token,
         arguments: List[Token],
         node: ast.AST,
-    ) -> AsyncGenerator[Tuple[Token, ast.AST], None]:
+    ) -> AsyncIterator[Tuple[Token, ast.AST]]:
         from robot.parsing.lexer import Token as RobotToken
         from robot.utils.escaping import unescape
 
-        async def skip_non_data_tokens() -> AsyncGenerator[Tuple[Token, ast.AST], None]:
+        async def skip_non_data_tokens() -> AsyncIterator[Tuple[Token, ast.AST]]:
             nonlocal arguments
             while arguments and arguments[0] and arguments[0].type in RobotToken.NON_DATA_TOKENS:
 
@@ -627,7 +627,7 @@ async def skip_non_data_tokens() -> AsyncGenerator[Tuple[Token, ast.AST], None]:
                         yield e
             elif kw_doc.is_run_keyword_if() and len(arguments) > 0:
 
-                async def generate_run_kw_if() -> AsyncGenerator[Tuple[Token, ast.AST], None]:
+                async def generate_run_kw_if() -> AsyncIterator[Tuple[Token, ast.AST]]:
                     nonlocal arguments
 
                     yield arguments[0], node,
@@ -711,7 +711,7 @@ async def generate_keyword_tokens(
         arguments: List[Token],
         node: ast.AST,
         kw_doc: Optional[KeywordDoc] = None,
-    ) -> AsyncGenerator[Tuple[Token, ast.AST], None]:
+    ) -> AsyncIterator[Tuple[Token, ast.AST]]:
         from robot.parsing.lexer import Token as RobotToken
         from robot.utils.escaping import split_from_equals
 
@@ -758,7 +758,7 @@ async def _collect_internal(
         last_line = 0
         last_col = 0
 
-        async def get_tokens() -> AsyncGenerator[Tuple[Token, ast.AST], None]:
+        async def get_tokens() -> AsyncIterator[Tuple[Token, ast.AST]]:
             async for node in async_ast.iter_nodes(model):
                 if isinstance(node, HasTokens):
                     if isinstance(node, LibraryImport):

robotcode/language_server/robotframework/utils/ast_utils.py

@@ -4,7 +4,6 @@
 from typing import (
     Any,
     AsyncIterator,
-    Generator,
     Iterator,
     List,
     Optional,
@@ -19,7 +18,7 @@
 from . import async_ast
 
 
-def iter_nodes(node: ast.AST) -> Generator[ast.AST, None, None]:
+def iter_nodes(node: ast.AST) -> Iterator[ast.AST]:
     for _field, value in ast.iter_fields(node):
         if isinstance(value, list):
             for item in value:
@@ -220,13 +219,13 @@ async def get_node_at_position(node: ast.AST, position: Position, include_end: b
     return result_nodes[-1]
 
 
-def _tokenize_no_variables(token: Token) -> Generator[Token, None, None]:
+def _tokenize_no_variables(token: Token) -> Iterator[Token]:
     yield token
 
 
 def tokenize_variables(
     token: Token, identifiers: str = "$@&%", ignore_errors: bool = False, *, extra_types: Optional[Set[str]] = None
-) -> Generator[Token, Any, Any]:
+) -> Iterator[Token]:
     from robot.api.parsing import Token as RobotToken
     from robot.variables import VariableIterator
 
@@ -246,7 +245,7 @@ def tokenize_variables(
     return _tokenize_variables(token, variables)
 
 
-def _tokenize_variables(token: Token, variables: Any) -> Generator[Token, Any, Any]:
+def _tokenize_variables(token: Token, variables: Any) -> Iterator[Token]:
     from robot.api.parsing import Token as RobotToken
 
     lineno = token.lineno