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

robotcode/robot/diagnostics/namespace.py

@@ -5,7 +5,6 @@ import time
 import weakref
 from collections import OrderedDict, defaultdict
 from concurrent.futures import CancelledError
-from itertools import chain
 from pathlib import Path
 from typing import (
     Any,
@@ -15,7 +14,6 @@ from typing import (
     List,
     NamedTuple,
     Optional,
-    Sequence,
     Set,
     Tuple,
     Union,
@@ -23,7 +21,6 @@ from typing import (
 )
 
 from robot.errors import VariableError
-from robot.libraries import STDLIBS
 from robot.parsing.lexer.tokens import Token
 from robot.parsing.model.blocks import Keyword, SettingSection, TestCase, VariableSection
 from robot.parsing.model.statements import Arguments, Setup, Statement, Timeout
@@ -54,21 +51,18 @@ from robotcode.core.text_document import TextDocument
 from robotcode.core.uri import Uri
 from robotcode.core.utils.logging import LoggingDescriptor
 
-from ..utils import get_robot_version
 from ..utils.ast import (
     range_from_node,
     range_from_token,
     strip_variable_token,
     tokenize_variables,
 )
-from ..utils.match import eq_namespace
 from ..utils.stubs import Languages
 from ..utils.variables import BUILTIN_VARIABLES
 from ..utils.visitor import Visitor
 from .entities import (
     ArgumentDefinition,
     BuiltInVariableDefinition,
-    CommandLineVariableDefinition,
     EnvironmentVariableDefinition,
     GlobalVariableDefinition,
     Import,
@@ -86,15 +80,16 @@ from .entities import (
 )
 from .errors import DIAGNOSTICS_SOURCE_NAME, Error
 from .imports_manager import ImportsManager
+from .keyword_finder import KeywordFinder
 from .library_doc import (
     BUILTIN_LIBRARY_NAME,
     DEFAULT_LIBRARIES,
     KeywordDoc,
-    KeywordError,
     KeywordMatcher,
     LibraryDoc,
     resolve_robot_variables,
 )
+from .namespace_analyzer import NamespaceAnalyzer
 
 
 class DiagnosticsError(Exception):
@@ -174,12 +169,14 @@ class VariablesVisitor(Visitor):
 
 
 class VariableVisitorBase(Visitor):
+
     def __init__(
         self,
         namespace: "Namespace",
         nodes: Optional[List[ast.AST]] = None,
         position: Optional[Position] = None,
         in_args: bool = True,
+        resolved_variables: Any = None,
     ) -> None:
         super().__init__()
         self.namespace = namespace
@@ -190,6 +187,7 @@ class VariableVisitorBase(Visitor):
         self._results: Dict[str, VariableDefinition] = {}
         self.current_kw_doc: Optional[KeywordDoc] = None
         self.current_kw: Optional[Keyword] = None
+        self._resolved_variables: Any = resolved_variables
 
     def get_variable_token(self, token: Token) -> Optional[Token]:
         return next(
@@ -344,12 +342,15 @@ class BlockVariableVisitor(OnlyArgumentsVisitor):
                 pass
 
     def _get_var_name(self, original: str, position: Position, require_assign: bool = True) -> Optional[str]:
-        robot_variables = resolve_robot_variables(
-            str(self.namespace.imports_manager.root_folder),
-            str(Path(self.namespace.source).parent) if self.namespace.source else ".",
-            self.namespace.imports_manager.get_resolvable_command_line_variables(),
-            variables=self.namespace.get_resolvable_variables(),
-        )
+        if self._resolved_variables is None:
+            self._resolved_variables = resolve_robot_variables(
+                str(self.namespace.imports_manager.root_folder),
+                str(Path(self.namespace.source).parent) if self.namespace.source else ".",
+                self.namespace.imports_manager.get_resolvable_command_line_variables(),
+                variables=self.namespace.get_resolvable_variables(),
+            )
+
+        robot_variables = self._resolved_variables
 
         try:
             replaced = robot_variables.replace_string(original)
@@ -680,8 +681,9 @@ class Namespace:
         self._namespaces: Optional[Dict[KeywordMatcher, List[LibraryEntry]]] = None
         self._libraries_matchers: Optional[Dict[KeywordMatcher, LibraryEntry]] = None
         self._resources: Dict[str, ResourceEntry] = OrderedDict()
+        self._resources_files: Dict[str, ResourceEntry] = OrderedDict()
         self._resources_matchers: Optional[Dict[KeywordMatcher, ResourceEntry]] = None
-        self._variables: Dict[str, VariablesEntry] = OrderedDict()
+        self._variables_imports: Dict[str, VariablesEntry] = OrderedDict()
         self._initialized = False
         self._invalid = False
         self._initialize_lock = RLock(default_timeout=120, name="Namespace.initialize")
@@ -694,15 +696,23 @@ class Namespace:
         self._own_variables: Optional[List[VariableDefinition]] = None
         self._own_variables_lock = RLock(default_timeout=120, name="Namespace.own_variables")
         self._global_variables: Optional[List[VariableDefinition]] = None
-        self._global_variables_dict: Optional[Dict[VariableMatcher, VariableDefinition]] = None
         self._global_variables_lock = RLock(default_timeout=120, name="Namespace.global_variables")
+        self._global_variables_dict: Optional[Dict[VariableMatcher, VariableDefinition]] = None
         self._global_variables_dict_lock = RLock(default_timeout=120, name="Namespace.global_variables_dict")
 
+        self._imported_variables: Optional[List[VariableDefinition]] = None
+        self._imported_variables_lock = RLock(default_timeout=120, name="Namespace._imported_variables_lock")
+
         self._global_resolvable_variables: Optional[Dict[str, Any]] = None
         self._global_resolvable_variables_lock = RLock(
             default_timeout=120, name="Namespace._global_resolvable_variables_lock"
         )
 
+        self._global_resolved_variables: Any = None
+        self._global_resolved_variables_lock = RLock(
+            default_timeout=120, name="Namespace._global_resolvabled_variables_lock"
+        )
+
         self._suite_variables: Optional[Dict[str, Any]] = None
         self._suite_variables_lock = RLock(default_timeout=120, name="Namespace.global_variables")
 
@@ -729,8 +739,6 @@ class Namespace:
 
         self._in_initialize = False
 
-        self._ignored_lines: Optional[List[int]] = None
-
     @event
     def has_invalidated(sender) -> None: ...
 
@@ -740,19 +748,14 @@ class Namespace:
     @event
     def has_analysed(sender) -> None: ...
 
-    @event
-    def library_import_changed(sender) -> None: ...
-
-    @event
-    def resource_import_changed(sender) -> None: ...
-
-    @event
-    def variables_import_changed(sender) -> None: ...
-
     @property
     def document(self) -> Optional[TextDocument]:
         return self._document() if self._document is not None else None
 
+    @property
+    def document_uri(self) -> str:
+        return self.document.document_uri if self.document is not None else str(Uri.from_path(self.source))
+
     @property
     def search_order(self) -> Tuple[str, ...]:
         if self._search_order is None:
@@ -802,7 +805,7 @@ class Namespace:
         invalidate = False
 
         for p in variables:
-            if any(e for e in self._variables.values() if e.library_doc.source == p.source):
+            if any(e for e in self._variables_imports.values() if e.library_doc.source == p.source):
                 invalidate = True
                 break
 
@@ -898,10 +901,10 @@ class Namespace:
 
         return self._resources
 
-    def get_imported_variables(self) -> Dict[str, VariablesEntry]:
+    def get_variables_imports(self) -> Dict[str, VariablesEntry]:
         self.ensure_initialized()
 
-        return self._variables
+        return self._variables_imports
 
     @_logger.call
     def get_library_doc(self) -> LibraryDoc:
@@ -910,7 +913,6 @@ class Namespace:
                 self._library_doc = self.imports_manager.get_libdoc_from_model(
                     self.model,
                     self.source,
-                    model_type="RESOURCE",
                     append_model_errors=self.document_type is not None and self.document_type == DocumentType.RESOURCE,
                 )
 
@@ -928,38 +930,38 @@ class Namespace:
     def ensure_initialized(self) -> bool:
         with self._initialize_lock:
             if not self._initialized:
+                with self._logger.measure_time(
+                    lambda: f"Initialize Namespace for {self.source}", context_name="import"
+                ):
+                    succeed = False
+                    try:
+                        imports = self.get_imports()
 
-                succeed = False
-                try:
-                    self._logger.debug(lambda: f"initialize {self.document}")
-
-                    imports = self.get_imports()
-
-                    variables = self.get_suite_variables()
+                        variables = self.get_suite_variables()
 
-                    self._import_default_libraries(variables)
-                    self._import_imports(
-                        imports,
-                        str(Path(self.source).parent),
-                        top_level=True,
-                        variables=variables,
-                    )
+                        self._import_default_libraries(variables)
+                        self._import_imports(
+                            imports,
+                            str(Path(self.source).parent),
+                            top_level=True,
+                            variables=variables,
+                        )
 
-                    self._reset_global_variables()
+                        self._reset_global_variables()
 
-                    self._initialized = True
-                    succeed = True
+                        self._initialized = True
+                        succeed = True
 
-                except BaseException:
-                    if self.document is not None:
-                        self.document.remove_data(Namespace)
-                        self.document.remove_data(Namespace.DataEntry)
+                    except BaseException:
+                        if self.document is not None:
+                            self.document.remove_data(Namespace)
+                            self.document.remove_data(Namespace.DataEntry)
 
-                    self._invalidate()
-                    raise
+                        self._invalidate()
+                        raise
 
-                if succeed:
-                    self.has_initialized(self)
+                    if succeed:
+                        self.has_initialized(self)
 
         return self._initialized
 
@@ -986,10 +988,10 @@ class Namespace:
 
             return self._own_variables
 
-    _builtin_variables: Optional[List[BuiltInVariableDefinition]] = None
+    _builtin_variables: Optional[List[VariableDefinition]] = None
 
     @classmethod
-    def get_builtin_variables(cls) -> List[BuiltInVariableDefinition]:
+    def get_builtin_variables(cls) -> List[VariableDefinition]:
         if cls._builtin_variables is None:
             cls._builtin_variables = [BuiltInVariableDefinition(0, 0, 0, 0, "", n, None) for n in BUILTIN_VARIABLES]
 
@@ -1001,11 +1003,14 @@ class Namespace:
 
     def _reset_global_variables(self) -> None:
         with self._global_variables_lock, self._global_variables_dict_lock, self._suite_variables_lock:
-            with self._global_resolvable_variables_lock:
-                self._global_variables = None
-                self._global_variables_dict = None
-                self._suite_variables = None
-                self._global_resolvable_variables = None
+            with self._global_resolvable_variables_lock, self._global_resolved_variables_lock:
+                with self._imported_variables_lock:
+                    self._global_variables = None
+                    self._global_variables_dict = None
+                    self._suite_variables = None
+                    self._global_resolvable_variables = None
+                    self._global_resolved_variables = None
+                    self._imported_variables = None
 
     def get_global_variables(self) -> List[VariableDefinition]:
         with self._global_variables_lock:
@@ -1015,7 +1020,7 @@ class Namespace:
                         self.get_command_line_variables(),
                         self.get_own_variables(),
                         *(e.variables for e in self._resources.values()),
-                        *(e.variables for e in self._variables.values()),
+                        *(e.variables for e in self._variables_imports.values()),
                         self.get_builtin_variables(),
                     )
                 )
@@ -1037,8 +1042,6 @@ class Namespace:
         skip_local_variables: bool = False,
         skip_global_variables: bool = False,
     ) -> Iterator[Tuple[VariableMatcher, VariableDefinition]]:
-        yielded: Dict[VariableMatcher, VariableDefinition] = {}
-
         test_or_keyword = None
         test_or_keyword_nodes = None
 
@@ -1056,43 +1059,41 @@ class Namespace:
             isinstance(test_or_keyword_nodes[-1], (Arguments, Setup, Timeout)) if test_or_keyword_nodes else False
         )
 
-        for var in chain(
-            *[
+        yield from (
+            (var.matcher, var)
+            for var in itertools.chain(
                 (
                     (
                         (OnlyArgumentsVisitor if only_args else BlockVariableVisitor)(
-                            self,
-                            nodes,
-                            position,
-                            in_args,
+                            self, nodes, position, in_args, resolved_variables=self.get_global_resolved_variables()
                         ).get(test_or_keyword)
                     )
                     if test_or_keyword is not None and not skip_local_variables
                     else []
-                )
-            ],
-            self.get_global_variables() if not skip_global_variables else [],
-        ):
-            if var.matcher not in yielded:
-                if skip_commandline_variables and isinstance(var, CommandLineVariableDefinition):
-                    continue
+                ),
+                [] if skip_global_variables or skip_commandline_variables else self.get_command_line_variables(),
+                [] if skip_global_variables else self.get_own_variables(),
+                [] if skip_global_variables else self.get_imported_variables(),
+                [] if skip_global_variables else self.get_builtin_variables(),
+            )
+        )
 
-                yielded[var.matcher] = var
+    def get_imported_variables(self) -> List[VariableDefinition]:
+        with self._imported_variables_lock:
+            if self._imported_variables is None:
+                self._imported_variables = list(
+                    itertools.chain(
+                        *(e.variables for e in self._resources.values()),
+                        *(e.variables for e in self._variables_imports.values()),
+                    ),
+                )
 
-                yield var.matcher, var
+        return self._imported_variables
 
     def get_suite_variables(self) -> Dict[str, Any]:
         with self._suite_variables_lock:
-            vars = {}
-
-            def check_var(var: VariableDefinition) -> bool:
-                if var.matcher in vars:
-                    return False
-                vars[var.matcher] = var
-
-                return var.has_value
-
-            self._suite_variables = {v.name: v.value for v in filter(check_var, self.get_global_variables())}
+            if self._suite_variables is None:
+                self._suite_variables = {v.name: v.value for v in reversed(self.get_global_variables())}
 
         return self._suite_variables
 
@@ -1117,6 +1118,19 @@ class Namespace:
                 }
             return self._global_resolvable_variables
 
+    def get_global_resolved_variables(
+        self,
+    ) -> Any:
+        with self._global_resolved_variables_lock:
+            if self._global_resolved_variables is None:
+                self._global_resolved_variables = resolve_robot_variables(
+                    str(self.imports_manager.root_folder),
+                    str(Path(self.source).parent) if self.source else ".",
+                    self.imports_manager.get_resolvable_command_line_variables(),
+                    variables=self.get_resolvable_variables(),
+                )
+            return self._global_resolved_variables
+
     def get_variable_matchers(
         self,
         nodes: Optional[List[ast.AST]] = None,
@@ -1154,15 +1168,24 @@ class Namespace:
         try:
             matcher = VariableMatcher(name)
 
-            for m, v in self.yield_variables(
-                nodes,
-                position,
-                skip_commandline_variables=skip_commandline_variables,
-                skip_local_variables=skip_local_variables,
-                skip_global_variables=True,
-            ):
-                if matcher == m:
-                    return v
+            if nodes:
+                result = next(
+                    (
+                        v
+                        for m, v in self.yield_variables(
+                            nodes,
+                            position,
+                            skip_commandline_variables=skip_commandline_variables,
+                            skip_local_variables=skip_local_variables,
+                            skip_global_variables=True,
+                        )
+                        if matcher == m
+                    ),
+                    None,
+                )
+
+                if result is not None:
+                    return result
 
             result = self.get_global_variables_dict().get(matcher, None)
             if matcher is not None:
@@ -1223,6 +1246,10 @@ class Namespace:
 
                 source = self.imports_manager.find_resource(value.name, base_dir, variables=variables)
 
+                if source in self._resources_files:
+                    self._logger.debug(lambda: f"Resource '{value.name}' already imported.", context_name="import")
+                    return None
+
                 if self.source == source:
                     if parent_import:
                         self.append_diagnostics(
@@ -1256,6 +1283,9 @@ class Namespace:
 
                     self._import_entries[value] = result
 
+                    if result.variables:
+                        self._reset_global_variables()
+
                     if top_level and (
                         not result.library_doc.errors
                         and top_level
@@ -1286,6 +1316,9 @@ class Namespace:
                 result.import_source = value.source
 
                 self._import_entries[value] = result
+
+                if result.variables:
+                    self._reset_global_variables()
             else:
                 raise DiagnosticsError("Unknown import type.")
 
@@ -1385,8 +1418,6 @@ class Namespace:
                         else None
                     ),
                 )
-        finally:
-            self._reset_global_variables()
 
         return result
 
@@ -1423,13 +1454,11 @@ class Namespace:
                 if entry is not None:
                     if isinstance(entry, ResourceEntry):
                         assert entry.library_doc.source is not None
-                        already_imported_resources = next(
-                            (e for e in self._resources.values() if e.library_doc.source == entry.library_doc.source),
-                            None,
-                        )
+                        allread_imported_resource = self._resources_files.get(entry.library_doc.source, None)
 
-                        if already_imported_resources is None and entry.library_doc.source != self.source:
+                        if allread_imported_resource is None and entry.library_doc.source != self.source:
                             self._resources[entry.import_name] = entry
+                            self._resources_files[entry.library_doc.source] = entry
                             if entry.variables:
                                 variables = self.get_suite_variables()
 
@@ -1463,9 +1492,7 @@ class Namespace:
                                     source=DIAGNOSTICS_SOURCE_NAME,
                                     code=Error.RECURSIVE_IMPORT,
                                 )
-                            elif (
-                                already_imported_resources is not None and already_imported_resources.library_doc.source
-                            ):
+                            elif allread_imported_resource is not None and allread_imported_resource.library_doc.source:
                                 self.append_diagnostics(
                                     range=entry.import_range,
                                     message=f"Resource {entry} already imported.",
@@ -1475,13 +1502,13 @@ class Namespace:
                                         [
                                             DiagnosticRelatedInformation(
                                                 location=Location(
-                                                    uri=str(Uri.from_path(already_imported_resources.import_source)),
-                                                    range=already_imported_resources.import_range,
+                                                    uri=str(Uri.from_path(allread_imported_resource.import_source)),
+                                                    range=allread_imported_resource.import_range,
                                                 ),
                                                 message="",
                                             )
                                         ]
-                                        if already_imported_resources.import_source
+                                        if allread_imported_resource.import_source
                                         else None
                                     ),
                                     code=Error.RESOURCE_ALREADY_IMPORTED,
@@ -1491,7 +1518,7 @@ class Namespace:
                         already_imported_variables = next(
                             (
                                 e
-                                for e in self._variables.values()
+                                for e in self._variables_imports.values()
                                 if e.library_doc.source == entry.library_doc.source
                                 and e.alias == entry.alias
                                 and e.args == entry.args
@@ -1503,7 +1530,7 @@ class Namespace:
                             and entry.library_doc is not None
                             and entry.library_doc.source_or_origin
                         ):
-                            self._variables[entry.library_doc.source_or_origin] = entry
+                            self._variables_imports[entry.library_doc.source_or_origin] = entry
                             if entry.variables:
                                 variables = self.get_suite_variables()
                         elif top_level and already_imported_variables and already_imported_variables.library_doc.source:
@@ -1737,7 +1764,7 @@ class Namespace:
         )
 
     @_logger.call
-    def get_imported_variables_libdoc(self, name: str, args: Tuple[str, ...] = ()) -> Optional[LibraryDoc]:
+    def get_variables_import_libdoc(self, name: str, args: Tuple[str, ...] = ()) -> Optional[LibraryDoc]:
         self.ensure_initialized()
 
         return next(
@@ -1835,8 +1862,6 @@ class Namespace:
 
     @_logger.call(condition=lambda self: not self._analyzed)
     def analyze(self) -> None:
-        from .namespace_analyzer import NamespaceAnalyzer
-
         with self._analyze_lock:
             if not self._analyzed:
                 canceled = False
@@ -1907,438 +1932,3 @@ class Namespace:
             raise_keyword_error=raise_keyword_error,
             handle_bdd_style=handle_bdd_style,
         )
-
-
-class DiagnosticsEntry(NamedTuple):
-    message: str
-    severity: DiagnosticSeverity
-    code: Optional[str] = None
-
-
-class CancelSearchError(Exception):
-    pass
-
-
-DEFAULT_BDD_PREFIXES = {"Given ", "When ", "Then ", "And ", "But "}
-
-
-class KeywordFinder:
-    def __init__(self, namespace: Namespace, library_doc: LibraryDoc) -> None:
-        self.namespace = namespace
-        self.self_library_doc = library_doc
-
-        self.diagnostics: List[DiagnosticsEntry] = []
-        self.multiple_keywords_result: Optional[List[KeywordDoc]] = None
-        self._cache: Dict[
-            Tuple[Optional[str], bool],
-            Tuple[
-                Optional[KeywordDoc],
-                List[DiagnosticsEntry],
-                Optional[List[KeywordDoc]],
-            ],
-        ] = {}
-        self.handle_bdd_style = True
-        self._all_keywords: Optional[List[LibraryEntry]] = None
-        self._resource_keywords: Optional[List[ResourceEntry]] = None
-        self._library_keywords: Optional[List[LibraryEntry]] = None
-
-    def reset_diagnostics(self) -> None:
-        self.diagnostics = []
-        self.multiple_keywords_result = None
-
-    def find_keyword(
-        self,
-        name: Optional[str],
-        *,
-        raise_keyword_error: bool = False,
-        handle_bdd_style: bool = True,
-    ) -> Optional[KeywordDoc]:
-        try:
-            self.reset_diagnostics()
-
-            self.handle_bdd_style = handle_bdd_style
-
-            cached = self._cache.get((name, self.handle_bdd_style), None)
-
-            if cached is not None:
-                self.diagnostics = cached[1]
-                self.multiple_keywords_result = cached[2]
-                return cached[0]
-
-            try:
-                result = self._find_keyword(name)
-                if result is None:
-                    self.diagnostics.append(
-                        DiagnosticsEntry(
-                            f"No keyword with name '{name}' found.",
-                            DiagnosticSeverity.ERROR,
-                            Error.KEYWORD_NOT_FOUND,
-                        )
-                    )
-            except KeywordError as e:
-                if e.multiple_keywords:
-                    self._add_to_multiple_keywords_result(e.multiple_keywords)
-
-                if raise_keyword_error:
-                    raise
-
-                result = None
-                self.diagnostics.append(DiagnosticsEntry(str(e), DiagnosticSeverity.ERROR, Error.KEYWORD_ERROR))
-
-            self._cache[(name, self.handle_bdd_style)] = (
-                result,
-                self.diagnostics,
-                self.multiple_keywords_result,
-            )
-
-            return result
-        except CancelSearchError:
-            return None
-
-    def _find_keyword(self, name: Optional[str]) -> Optional[KeywordDoc]:
-        if not name:
-            self.diagnostics.append(
-                DiagnosticsEntry(
-                    "Keyword name cannot be empty.",
-                    DiagnosticSeverity.ERROR,
-                    Error.KEYWORD_ERROR,
-                )
-            )
-            raise CancelSearchError
-        if not isinstance(name, str):
-            self.diagnostics.append(  # type: ignore
-                DiagnosticsEntry(
-                    "Keyword name must be a string.",
-                    DiagnosticSeverity.ERROR,
-                    Error.KEYWORD_ERROR,
-                )
-            )
-            raise CancelSearchError
-
-        result = self._get_keyword_from_self(name)
-        if not result and "." in name:
-            result = self._get_explicit_keyword(name)
-
-        if not result:
-            result = self._get_implicit_keyword(name)
-
-        if not result and self.handle_bdd_style:
-            return self._get_bdd_style_keyword(name)
-
-        return result
-
-    def _get_keyword_from_self(self, name: str) -> Optional[KeywordDoc]:
-        if get_robot_version() >= (6, 0):
-            found: List[Tuple[Optional[LibraryEntry], KeywordDoc]] = [
-                (None, v) for v in self.self_library_doc.keywords.get_all(name)
-            ]
-            if len(found) > 1:
-                found = self._select_best_matches(found)
-                if len(found) > 1:
-                    self.diagnostics.append(
-                        DiagnosticsEntry(
-                            self._create_multiple_keywords_found_message(name, found, implicit=False),
-                            DiagnosticSeverity.ERROR,
-                            Error.MULTIPLE_KEYWORDS,
-                        )
-                    )
-                    raise CancelSearchError
-
-            if len(found) == 1:
-                # TODO warning if keyword found is defined in resource and suite
-                return found[0][1]
-
-            return None
-
-        try:
-            return self.self_library_doc.keywords.get(name, None)
-        except KeywordError as e:
-            self.diagnostics.append(DiagnosticsEntry(str(e), DiagnosticSeverity.ERROR, Error.KEYWORD_ERROR))
-            raise CancelSearchError from e
-
-    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:])
-
-    def _get_explicit_keyword(self, name: str) -> Optional[KeywordDoc]:
-        found: List[Tuple[Optional[LibraryEntry], KeywordDoc]] = []
-        for owner_name, kw_name in self._yield_owner_and_kw_names(name):
-            found.extend(self.find_keywords(owner_name, kw_name))
-
-        if get_robot_version() >= (6, 0) and len(found) > 1:
-            found = self._select_best_matches(found)
-
-        if len(found) > 1:
-            self.diagnostics.append(
-                DiagnosticsEntry(
-                    self._create_multiple_keywords_found_message(name, found, implicit=False),
-                    DiagnosticSeverity.ERROR,
-                    Error.MULTIPLE_KEYWORDS,
-                )
-            )
-            raise CancelSearchError
-
-        return found[0][1] if found else None
-
-    def find_keywords(self, owner_name: str, name: str) -> List[Tuple[LibraryEntry, KeywordDoc]]:
-        if self._all_keywords is None:
-            self._all_keywords = list(
-                chain(
-                    self.namespace._libraries.values(),
-                    self.namespace._resources.values(),
-                )
-            )
-
-        if get_robot_version() >= (6, 0):
-            result: List[Tuple[LibraryEntry, KeywordDoc]] = []
-            for v in self._all_keywords:
-                if eq_namespace(v.alias or v.name, owner_name):
-                    result.extend((v, kw) for kw in v.library_doc.keywords.get_all(name))
-            return result
-
-        result = []
-        for v in self._all_keywords:
-            if eq_namespace(v.alias or v.name, owner_name):
-                kw = v.library_doc.keywords.get(name, None)
-                if kw is not None:
-                    result.append((v, kw))
-        return result
-
-    def _add_to_multiple_keywords_result(self, kw: Iterable[KeywordDoc]) -> None:
-        if self.multiple_keywords_result is None:
-            self.multiple_keywords_result = list(kw)
-        else:
-            self.multiple_keywords_result.extend(kw)
-
-    def _create_multiple_keywords_found_message(
-        self,
-        name: str,
-        found: Sequence[Tuple[Optional[LibraryEntry], KeywordDoc]],
-        implicit: bool = True,
-    ) -> str:
-        self._add_to_multiple_keywords_result([k for _, k in found])
-
-        if any(e[1].is_embedded for e in found):
-            error = f"Multiple keywords matching name '{name}' found"
-        else:
-            error = f"Multiple keywords with name '{name}' found"
-
-            if implicit:
-                error += ". Give the full name of the keyword you want to use"
-
-        names = sorted(f"{e[1].name if e[0] is None else f'{e[0].alias or e[0].name}.{e[1].name}'}" for e in found)
-        return "\n    ".join([f"{error}:", *names])
-
-    def _get_implicit_keyword(self, name: str) -> Optional[KeywordDoc]:
-        result = self._get_keyword_from_resource_files(name)
-        if not result:
-            return self._get_keyword_from_libraries(name)
-        return result
-
-    def _prioritize_same_file_or_public(
-        self, entries: List[Tuple[Optional[LibraryEntry], KeywordDoc]]
-    ) -> List[Tuple[Optional[LibraryEntry], KeywordDoc]]:
-        matches = [h for h in entries if h[1].source == self.namespace.source]
-        if matches:
-            return matches
-
-        matches = [handler for handler in entries if not handler[1].is_private()]
-
-        return matches or entries
-
-    def _select_best_matches(
-        self, entries: List[Tuple[Optional[LibraryEntry], KeywordDoc]]
-    ) -> List[Tuple[Optional[LibraryEntry], KeywordDoc]]:
-        normal = [hand for hand in entries if not hand[1].is_embedded]
-        if normal:
-            return normal
-
-        matches = [hand for hand in entries if not self._is_worse_match_than_others(hand, entries)]
-        return matches or entries
-
-    def _is_worse_match_than_others(
-        self,
-        candidate: Tuple[Optional[LibraryEntry], KeywordDoc],
-        alternatives: List[Tuple[Optional[LibraryEntry], KeywordDoc]],
-    ) -> bool:
-        for other in alternatives:
-            if (
-                candidate[1] is not other[1]
-                and self._is_better_match(other, candidate)
-                and not self._is_better_match(candidate, other)
-            ):
-                return True
-        return False
-
-    def _is_better_match(
-        self,
-        candidate: Tuple[Optional[LibraryEntry], KeywordDoc],
-        other: Tuple[Optional[LibraryEntry], KeywordDoc],
-    ) -> bool:
-        return (
-            other[1].matcher.embedded_arguments.match(candidate[1].name) is not None
-            and candidate[1].matcher.embedded_arguments.match(other[1].name) is None
-        )
-
-    def _get_keyword_from_resource_files(self, name: str) -> Optional[KeywordDoc]:
-        if self._resource_keywords is None:
-            self._resource_keywords = list(chain(self.namespace._resources.values()))
-
-        if get_robot_version() >= (6, 0):
-            found: List[Tuple[Optional[LibraryEntry], KeywordDoc]] = []
-            for v in self._resource_keywords:
-                r = v.library_doc.keywords.get_all(name)
-                if r:
-                    found.extend([(v, k) for k in r])
-        else:
-            found = []
-            for k in self._resource_keywords:
-                s = k.library_doc.keywords.get(name, None)
-                if s is not None:
-                    found.append((k, s))
-
-        if not found:
-            return None
-
-        if get_robot_version() >= (6, 0):
-            if len(found) > 1:
-                found = self._prioritize_same_file_or_public(found)
-
-                if len(found) > 1:
-                    found = self._select_best_matches(found)
-
-                    if len(found) > 1:
-                        found = self._get_keyword_based_on_search_order(found)
-
-        else:
-            if len(found) > 1:
-                found = self._get_keyword_based_on_search_order(found)
-
-        if len(found) == 1:
-            return found[0][1]
-
-        self.diagnostics.append(
-            DiagnosticsEntry(
-                self._create_multiple_keywords_found_message(name, found),
-                DiagnosticSeverity.ERROR,
-                Error.MULTIPLE_KEYWORDS,
-            )
-        )
-        raise CancelSearchError
-
-    def _get_keyword_based_on_search_order(
-        self, entries: List[Tuple[Optional[LibraryEntry], KeywordDoc]]
-    ) -> List[Tuple[Optional[LibraryEntry], KeywordDoc]]:
-        for libname in self.namespace.search_order:
-            for e in entries:
-                if e[0] is not None and eq_namespace(libname, e[0].alias or e[0].name):
-                    return [e]
-
-        return entries
-
-    def _get_keyword_from_libraries(self, name: str) -> Optional[KeywordDoc]:
-        if self._library_keywords is None:
-            self._library_keywords = list(chain(self.namespace._libraries.values()))
-
-        if get_robot_version() >= (6, 0):
-            found: List[Tuple[Optional[LibraryEntry], KeywordDoc]] = []
-            for v in self._library_keywords:
-                r = v.library_doc.keywords.get_all(name)
-                if r:
-                    found.extend([(v, k) for k in r])
-        else:
-            found = []
-
-            for k in self._library_keywords:
-                s = k.library_doc.keywords.get(name, None)
-                if s is not None:
-                    found.append((k, s))
-
-        if not found:
-            return None
-
-        if get_robot_version() >= (6, 0):
-            if len(found) > 1:
-                found = self._select_best_matches(found)
-                if len(found) > 1:
-                    found = self._get_keyword_based_on_search_order(found)
-        else:
-            if len(found) > 1:
-                found = self._get_keyword_based_on_search_order(found)
-            if len(found) == 2:
-                found = self._filter_stdlib_runner(*found)
-
-        if len(found) == 1:
-            return found[0][1]
-
-        self.diagnostics.append(
-            DiagnosticsEntry(
-                self._create_multiple_keywords_found_message(name, found),
-                DiagnosticSeverity.ERROR,
-                Error.MULTIPLE_KEYWORDS,
-            )
-        )
-        raise CancelSearchError
-
-    def _filter_stdlib_runner(
-        self,
-        entry1: Tuple[Optional[LibraryEntry], KeywordDoc],
-        entry2: Tuple[Optional[LibraryEntry], KeywordDoc],
-    ) -> List[Tuple[Optional[LibraryEntry], KeywordDoc]]:
-        stdlibs_without_remote = STDLIBS - {"Remote"}
-        if entry1[0] is not None and entry1[0].name in stdlibs_without_remote:
-            standard, custom = entry1, entry2
-        elif entry2[0] is not None and entry2[0].name in stdlibs_without_remote:
-            standard, custom = entry2, entry1
-        else:
-            return [entry1, entry2]
-
-        self.diagnostics.append(
-            DiagnosticsEntry(
-                self._create_custom_and_standard_keyword_conflict_warning_message(custom, standard),
-                DiagnosticSeverity.WARNING,
-                Error.CONFLICTING_LIBRARY_KEYWORDS,
-            )
-        )
-
-        return [custom]
-
-    def _create_custom_and_standard_keyword_conflict_warning_message(
-        self,
-        custom: Tuple[Optional[LibraryEntry], KeywordDoc],
-        standard: Tuple[Optional[LibraryEntry], KeywordDoc],
-    ) -> str:
-        custom_with_name = standard_with_name = ""
-        if custom[0] is not None and custom[0].alias is not None:
-            custom_with_name = " imported as '%s'" % custom[0].alias
-        if standard[0] is not None and standard[0].alias is not None:
-            standard_with_name = " imported as '%s'" % standard[0].alias
-        return (
-            f"Keyword '{standard[1].name}' found both from a custom test library "
-            f"'{'' if custom[0] is None else custom[0].name}'{custom_with_name} "
-            f"and a standard library '{standard[1].name}'{standard_with_name}. "
-            f"The custom keyword is used. To select explicitly, and to get "
-            f"rid of this warning, use either "
-            f"'{'' if custom[0] is None else custom[0].alias or custom[0].name}.{custom[1].name}' "
-            f"or '{'' if standard[0] is None else standard[0].alias or standard[0].name}.{standard[1].name}'."
-        )
-
-    def _get_bdd_style_keyword(self, name: str) -> Optional[KeywordDoc]:
-        if get_robot_version() < (6, 0):
-            lower = name.lower()
-            for prefix in ["given ", "when ", "then ", "and ", "but "]:
-                if lower.startswith(prefix):
-                    return self._find_keyword(name[len(prefix) :])
-            return None
-
-        parts = name.split()
-        if len(parts) < 2:
-            return None
-        for index in range(1, len(parts)):
-            prefix = " ".join(parts[:index]).title()
-            if prefix.title() in (
-                self.namespace.languages.bdd_prefixes if self.namespace.languages is not None else DEFAULT_BDD_PREFIXES
-            ):
-                return self._find_keyword(" ".join(parts[index:]))
-        return None