robotcode-language-server 2.4.0__py3-none-any.whl → 2.5.1__py3-none-any.whl

robotcode/language_server/__version__.py

@@ -1 +1 @@
-__version__ = "2.4.0"
+__version__ = "2.5.1"

robotcode/language_server/common/protocol.py

@@ -161,9 +161,6 @@ class LanguageServerProtocol(JsonRPCProtocol):
 
         self.is_initialized = Event()
 
-    def __del__(self) -> None:
-        self.trace = TraceValues.OFF
-
     @event
     def on_shutdown(sender) -> None:  # pragma: no cover, NOSONAR
         ...

robotcode/language_server/robotframework/parts/code_action_documentation.py

@@ -67,7 +67,7 @@ class RobotCodeActionDocumentationProtocolPart(RobotLanguageServerProtocolPart,
 
         namespace = self.parent.documents_cache.get_namespace(document)
 
-        model = self.parent.documents_cache.get_model(document, False)
+        model = self.parent.documents_cache.get_model(document)
         node = get_node_at_position(model, range.start)
 
         if context.only and isinstance(node, (LibraryImport, ResourceImport)):
@@ -115,17 +115,17 @@ class RobotCodeActionDocumentationProtocolPart(RobotLanguageServerProtocolPart,
 
                         if kw_doc.libtype == "LIBRARY":
                             entry = next(
-                                (v for v in (namespace.get_libraries()).values() if v.library_doc == kw_doc.parent),
+                                (v for v in namespace.libraries.values() if v.library_doc == kw_doc.parent),
                                 None,
                             )
 
                         elif kw_doc.libtype == "RESOURCE":
                             entry = next(
-                                (v for v in (namespace.get_resources()).values() if v.library_doc == kw_doc.parent),
+                                (v for v in namespace.resources.values() if v.library_doc == kw_doc.parent),
                                 None,
                             )
 
-                            self_libdoc = namespace.get_library_doc()
+                            self_libdoc = namespace.library_doc
                             if entry is None and self_libdoc == kw_doc.parent:
                                 entry = LibraryEntry(
                                     self_libdoc.name,

robotcode/language_server/robotframework/parts/code_action_quick_fixes.py

@@ -155,7 +155,7 @@ class RobotCodeActionQuickFixesProtocolPart(RobotLanguageServerProtocolPart, Mod
             CodeActionTriggerKind.INVOKED,
             CodeActionTriggerKind.AUTOMATIC,
         ]:
-            model = self.parent.documents_cache.get_model(document, False)
+            model = self.parent.documents_cache.get_model(document)
             namespace = self.parent.documents_cache.get_namespace(document)
 
             for diagnostic in (
@@ -218,7 +218,7 @@ class RobotCodeActionQuickFixesProtocolPart(RobotLanguageServerProtocolPart, Mod
         if document is None:
             return None
 
-        model = self.parent.documents_cache.get_model(document, False)
+        model = self.parent.documents_cache.get_model(document)
         node = get_node_at_position(model, data.range.start)
 
         if isinstance(node, (KeywordCall, Fixture, TestTemplate, Template)):
@@ -282,7 +282,7 @@ class RobotCodeActionQuickFixesProtocolPart(RobotLanguageServerProtocolPart, Mod
         return None
 
     def _apply_create_keyword(self, document: TextDocument, insert_text: str) -> Tuple[WorkspaceEdit, Range]:
-        model = self.parent.documents_cache.get_model(document, False)
+        model = self.parent.documents_cache.get_model(document)
         namespace = self.parent.documents_cache.get_namespace(document)
 
         insert_text, insert_range = self.create_insert_keyword_workspace_edit(document, model, namespace, insert_text)
@@ -406,7 +406,7 @@ class RobotCodeActionQuickFixesProtocolPart(RobotLanguageServerProtocolPart, Mod
                     diagnostic.range.start.line == diagnostic.range.end.line
                     and diagnostic.range.start.character < diagnostic.range.end.character
                 ):
-                    model = self.parent.documents_cache.get_model(document, False)
+                    model = self.parent.documents_cache.get_model(document)
                     nodes = get_nodes_at_position(model, range.start)
 
                     if not any(n for n in nodes if isinstance(n, (Keyword, TestCase))):
@@ -451,7 +451,7 @@ class RobotCodeActionQuickFixesProtocolPart(RobotLanguageServerProtocolPart, Mod
             if document is None:
                 return None
 
-            model = self.parent.documents_cache.get_model(document, False)
+            model = self.parent.documents_cache.get_model(document)
             nodes = get_nodes_at_position(model, data.range.start)
 
             if not any(n for n in nodes if isinstance(n, (Keyword, TestCase))):
@@ -554,7 +554,7 @@ class RobotCodeActionQuickFixesProtocolPart(RobotLanguageServerProtocolPart, Mod
             if document is None:
                 return None
 
-            model = self.parent.documents_cache.get_model(document, False)
+            model = self.parent.documents_cache.get_model(document)
             nodes = get_nodes_at_position(model, data.range.start)
 
             node = nodes[-1] if nodes else None
@@ -679,7 +679,7 @@ class RobotCodeActionQuickFixesProtocolPart(RobotLanguageServerProtocolPart, Mod
                     if not text:
                         continue
 
-                    model = self.parent.documents_cache.get_model(document, False)
+                    model = self.parent.documents_cache.get_model(document)
                     nodes = get_nodes_at_position(model, range.start)
 
                     if not any(n for n in nodes if isinstance(n, Keyword)):
@@ -713,7 +713,7 @@ class RobotCodeActionQuickFixesProtocolPart(RobotLanguageServerProtocolPart, Mod
             if not text:
                 return None
 
-            model = self.parent.documents_cache.get_model(document, False)
+            model = self.parent.documents_cache.get_model(document)
             nodes = get_nodes_at_position(model, data.range.start)
 
             keyword = next((n for n in nodes if isinstance(n, Keyword)), None)

robotcode/language_server/robotframework/parts/code_action_refactor.py

@@ -27,7 +27,6 @@ from robotcode.core.utils.dataclasses import as_dict, from_dict
 from robotcode.core.utils.inspect import iter_methods
 from robotcode.core.utils.logging import LoggingDescriptor
 from robotcode.robot.diagnostics.model_helper import ModelHelper
-from robotcode.robot.utils import get_robot_version
 from robotcode.robot.utils.ast import (
     get_node_at_position,
     get_nodes_at_position,
@@ -152,36 +151,31 @@ class RobotCodeActionRefactorProtocolPart(RobotLanguageServerProtocolPart, Model
 
     def get_valid_nodes_in_range(self, model: ast.AST, range: Range, also_return: bool = False) -> List[ast.AST]:
         from robot.parsing.lexer.tokens import Token as RobotToken
-        from robot.parsing.model.blocks import Block, Keyword, TestCase
+        from robot.parsing.model.blocks import Block, Keyword, TestCase, Try
         from robot.parsing.model.statements import (
+            Break,
             Comment,
+            Continue,
             Documentation,
             ElseHeader,
             ElseIfHeader,
             EmptyLine,
             End,
+            ExceptHeader,
+            FinallyHeader,
             Fixture,
             ForHeader,
             IfHeader,
             KeywordName,
             MultiValue,
+            ReturnStatement,
             SingleValue,
             TemplateArguments,
             TestCaseName,
+            TryHeader,
+            WhileHeader,
         )
 
-        if get_robot_version() >= (5, 0, 0):
-            from robot.parsing.model.blocks import Try
-            from robot.parsing.model.statements import (
-                Break,
-                Continue,
-                ExceptHeader,
-                FinallyHeader,
-                ReturnStatement,
-                TryHeader,
-                WhileHeader,
-            )
-
         if not isinstance(model, (Keyword, TestCase)):
             return []
 
@@ -205,7 +199,7 @@ class RobotCodeActionRefactorProtocolPart(RobotLanguageServerProtocolPart, Model
                         KeywordName,
                         TemplateArguments,
                     ),
-                ) or (also_return and get_robot_version() >= (5, 0, 0) and isinstance(node, ReturnStatement)):
+                ) or (also_return and isinstance(node, ReturnStatement)):
                     return []
 
                 result.append(node)
@@ -241,11 +235,11 @@ class RobotCodeActionRefactorProtocolPart(RobotLanguageServerProtocolPart, Model
             n
             for n in result
             if isinstance(n, (IfHeader, ElseIfHeader, ElseHeader, ForHeader, End))
-            or (get_robot_version() >= (5, 0) and isinstance(n, (WhileHeader, TryHeader, ExceptHeader, FinallyHeader)))
+            or isinstance(n, (WhileHeader, TryHeader, ExceptHeader, FinallyHeader))
         ):
             return []
 
-        if get_robot_version() >= (5, 0, 0) and any(
+        if any(
             n
             for n in result
             if isinstance(n, (Continue, Break))
@@ -267,7 +261,7 @@ class RobotCodeActionRefactorProtocolPart(RobotLanguageServerProtocolPart, Model
         if range.start == range.end:
             return None
 
-        model = self.parent.documents_cache.get_model(document, False)
+        model = self.parent.documents_cache.get_model(document)
         start_nodes = get_nodes_at_position(model, range.start)
 
         enabled = False
@@ -427,7 +421,7 @@ class RobotCodeActionRefactorProtocolPart(RobotLanguageServerProtocolPart, Model
             (context.only and CodeActionKind.REFACTOR_EXTRACT in context.only)
             or context.trigger_kind in [CodeActionTriggerKind.INVOKED, CodeActionTriggerKind.AUTOMATIC]
         ):
-            model = self.parent.documents_cache.get_model(document, False)
+            model = self.parent.documents_cache.get_model(document)
             node = get_node_at_position(model, range.start)
 
             if not isinstance(node, KeywordCall) or node.assign:
@@ -480,7 +474,7 @@ class RobotCodeActionRefactorProtocolPart(RobotLanguageServerProtocolPart, Model
         if document is None:
             return None
 
-        model = self.parent.documents_cache.get_model(document, False)
+        model = self.parent.documents_cache.get_model(document)
         nodes = get_nodes_at_position(model, range.start)
         if not nodes:
             return None
@@ -502,7 +496,7 @@ class RobotCodeActionRefactorProtocolPart(RobotLanguageServerProtocolPart, Model
         counter = 0
         namespace = self.parent.documents_cache.get_namespace(document)
         while True:
-            if namespace.find_variable(f"${{{var_name}}}", nodes, range.start, ignore_error=True) is None:
+            if namespace.find_variable(f"${{{var_name}}}", range.start) is None:
                 break
             counter += 1
             var_name = f"new_variable_{counter}"
@@ -544,7 +538,7 @@ class RobotCodeActionRefactorProtocolPart(RobotLanguageServerProtocolPart, Model
         if range.start == range.end:
             return None
 
-        model = self.parent.documents_cache.get_model(document, False)
+        model = self.parent.documents_cache.get_model(document)
         start_nodes = get_nodes_at_position(model, range.start)
 
         enabled = False
@@ -595,7 +589,7 @@ class RobotCodeActionRefactorProtocolPart(RobotLanguageServerProtocolPart, Model
         lines = document.get_lines()
         spaces = "".join(itertools.takewhile(str.isspace, lines[data.range.start.line]))
 
-        model = self.parent.documents_cache.get_model(document, False)
+        model = self.parent.documents_cache.get_model(document)
         namespace = self.parent.documents_cache.get_namespace(document)
 
         orig_keyword_name = "New Keyword"
@@ -619,8 +613,8 @@ class RobotCodeActionRefactorProtocolPart(RobotLanguageServerProtocolPart, Model
         if block is None:
             return None
 
-        variable_references = namespace.get_variable_references()
-        local_variable_assignments = namespace.get_local_variable_assignments()
+        variable_references = namespace.variable_references
+        local_variable_assignments = namespace.local_variable_assignments
 
         block_range = range_from_node(block, skip_non_data=True, allow_comments=True)
         argument_variables = {

robotcode/language_server/robotframework/parts/code_lens.py

@@ -73,7 +73,7 @@ class RobotCodeLensProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
         line = code_lens.data["line"]
 
         if self.parent.diagnostics.workspace_loaded_event.is_set():
-            kw_doc = self.get_keyword_definition_at_line(namespace.get_library_doc(), line)
+            kw_doc = self.get_keyword_definition_at_line(namespace.library_doc, line)
 
             if kw_doc is not None and not kw_doc.is_error_handler:
                 if not self.parent.robot_references.has_cached_keyword_references(

robotcode/language_server/robotframework/parts/completion.py

@@ -71,7 +71,7 @@ from robotcode.robot.diagnostics.library_doc import (
 )
 from robotcode.robot.diagnostics.model_helper import ModelHelper
 from robotcode.robot.diagnostics.namespace import DocumentType, Namespace
-from robotcode.robot.utils import get_robot_version
+from robotcode.robot.utils import RF_VERSION
 from robotcode.robot.utils.ast import (
     get_nodes_at_position,
     get_tokens_at_position,
@@ -85,7 +85,7 @@ from ...common.decorators import trigger_characters
 from ..configuration import CompletionConfig
 from .protocol_part import RobotLanguageServerProtocolPart
 
-if get_robot_version() >= (6, 1):
+if RF_VERSION >= (6, 1):
     from robot.parsing.lexer.settings import SuiteFileSettings
 else:
     from robot.parsing.lexer.settings import (
@@ -95,27 +95,19 @@ else:
 if TYPE_CHECKING:
     from ..protocol import RobotLanguageServerProtocol
 
-if get_robot_version() < (7, 0):
+if RF_VERSION < (7, 0):
     from robot.variables.search import VariableIterator
 else:
     from robot.variables.search import VariableMatches
 
 
-if get_robot_version() < (5, 0):
-    ALLOWED_VARIABLE_TOKENS = [
-        Token.NAME,
-        Token.ARGUMENT,
-        Token.KEYWORD,
-        Token.ASSIGN,
-    ]
-else:
-    ALLOWED_VARIABLE_TOKENS = [
-        Token.NAME,
-        Token.ARGUMENT,
-        Token.KEYWORD,
-        Token.ASSIGN,
-        Token.OPTION,
-    ]
+ALLOWED_VARIABLE_TOKENS = [
+    Token.NAME,
+    Token.ARGUMENT,
+    Token.KEYWORD,
+    Token.ASSIGN,
+    Token.OPTION,
+]
 
 
 DEFAULT_HEADER_STYLE = "*** {name}s ***"
@@ -141,7 +133,7 @@ class RobotCompletionProtocolPart(RobotLanguageServerProtocolPart):
         if config.header_style is not None:
             return config.header_style
 
-        return DEFAULT_HEADER_STYLE if get_robot_version() < (6, 0) else DEFAULT_HEADER_STYLE_51
+        return DEFAULT_HEADER_STYLE if RF_VERSION < (6, 0) else DEFAULT_HEADER_STYLE_51
 
     @language_id("robotframework")
     @trigger_characters(
@@ -168,7 +160,7 @@ class RobotCompletionProtocolPart(RobotLanguageServerProtocolPart):
         context: Optional[CompletionContext],
     ) -> Union[List[CompletionItem], CompletionList, None]:
         namespace = self.parent.documents_cache.get_initialized_namespace(document)
-        model = self.parent.documents_cache.get_model(document, False)
+        model = self.parent.documents_cache.get_model(document)
 
         config = self.get_config(document)
         self.doc_cache = {}
@@ -190,7 +182,7 @@ class RobotCompletionProtocolPart(RobotLanguageServerProtocolPart):
                 document = self.parent.documents.get(document_uri)
                 if document is not None:
                     namespace = self.parent.documents_cache.get_initialized_namespace(document)
-                    model = self.parent.documents_cache.get_model(document, False)
+                    model = self.parent.documents_cache.get_model(document)
                     if namespace is not None:
                         config = self.get_config(document)
 
@@ -231,29 +223,28 @@ def get_snippets() -> Dict[str, List[str]]:
             "IF": [r"IF    \${${1}}", "    $0", "END", ""],
         }
 
-        if get_robot_version() >= (5, 0):
-            __snippets.update(
-                {
-                    "TRYEX": [
-                        "TRY",
-                        "    $0",
-                        r"EXCEPT    message",
-                        "    ",
-                        "END",
-                        "",
-                    ],
-                    "TRYEXAS": [
-                        "TRY",
-                        "    $0",
-                        r"EXCEPT    message    AS    \${ex}",
-                        "    ",
-                        "END",
-                        "",
-                    ],
-                    "WHILE": [r"WHILE    ${1:expression}", "    $0", "END", ""],
-                }
-            )
-        if get_robot_version() >= (7, 0):
+        __snippets.update(
+            {
+                "TRYEX": [
+                    "TRY",
+                    "    $0",
+                    r"EXCEPT    message",
+                    "    ",
+                    "END",
+                    "",
+                ],
+                "TRYEXAS": [
+                    "TRY",
+                    "    $0",
+                    r"EXCEPT    message    AS    \${ex}",
+                    "    ",
+                    "END",
+                    "",
+                ],
+                "WHILE": [r"WHILE    ${1:expression}", "    $0", "END", ""],
+            }
+        )
+        if RF_VERSION >= (7, 0):
             __snippets.update(
                 {
                     "VAR ${}": [r"VAR    \${${1}}    ${0}"],
@@ -262,7 +253,7 @@ def get_snippets() -> Dict[str, List[str]]:
                 }
             )
 
-        if get_robot_version() >= (7, 2):
+        if RF_VERSION >= (7, 2):
             __snippets.update(
                 {
                     "GROUP": [
@@ -283,23 +274,25 @@ def get_reserved_keywords() -> List[str]:
     global __reserved_keywords
 
     if __reserved_keywords is None:
-        __reserved_keywords = ["FOR", "END", "IF", "ELSE", "ELSE IF"]
-
-        if get_robot_version() >= (5, 0):
-            __reserved_keywords += [
-                "TRY",
-                "EXCEPT",
-                "FINALLY",
-                "WHILE",
-                "BREAK",
-                "CONTINUE",
-                "RETURN",
-            ]
+        __reserved_keywords = [
+            "FOR",
+            "END",
+            "IF",
+            "ELSE",
+            "ELSE IF",
+            "TRY",
+            "EXCEPT",
+            "FINALLY",
+            "WHILE",
+            "BREAK",
+            "CONTINUE",
+            "RETURN",
+        ]
 
-        if get_robot_version() >= (7, 0):
+        if RF_VERSION >= (7, 0):
             __reserved_keywords += ["VAR"]
 
-        if get_robot_version() >= (7, 2):
+        if RF_VERSION >= (7, 2):
             __reserved_keywords += ["GROUP"]
 
         __reserved_keywords = sorted(__reserved_keywords)
@@ -419,7 +412,7 @@ class CompletionCollector(ModelHelper):
                                 lib_doc = next(
                                     (
                                         ld.library_doc
-                                        for ld in (self.namespace.get_libraries()).values()
+                                        for ld in self.namespace.libraries.values()
                                         if str(id(ld.library_doc)) == lib_id
                                     ),
                                     None,
@@ -467,7 +460,7 @@ class CompletionCollector(ModelHelper):
                                 lib_doc = next(
                                     (
                                         ld.library_doc
-                                        for ld in (self.namespace.get_resources()).values()
+                                        for ld in self.namespace.resources.values()
                                         if str(id(ld.library_doc)) == res_id
                                     ),
                                     None,
@@ -493,7 +486,7 @@ class CompletionCollector(ModelHelper):
 
                         elif (name := data.get("name", None)) is not None:
                             try:
-                                lib_doc = self.namespace.imports_manager.get_libdoc_for_resource_import(
+                                lib_doc = self.namespace.imports_manager.get_resource_doc_for_resource_import(
                                     name,
                                     str(document.uri.to_path().parent),
                                     variables=self.namespace.get_resolvable_variables(),
@@ -514,7 +507,7 @@ class CompletionCollector(ModelHelper):
                         if kw_id is not None:
                             try:
                                 kw_doc = next(
-                                    (kw for kw in self.namespace.get_keywords() if str(id(kw)) == kw_id),
+                                    (kw for kw in self.namespace.keywords if str(id(kw)) == kw_id),
                                     None,
                                 )
 
@@ -623,7 +616,7 @@ class CompletionCollector(ModelHelper):
                 text_edit=TextEdit(range=range, new_text=s.name[2:-1]),
                 filter_text=s.name[2:-1] if range is not None else None,
             )
-            for s in (self.namespace.get_variable_matchers(list(reversed(nodes)), position)).values()
+            for s in (self.namespace.get_variable_matchers(position)).values()
             if s.name is not None and (s.name_token is None or not position.is_in_range(range_from_token(s.name_token)))
         ]
 
@@ -774,7 +767,7 @@ class CompletionCollector(ModelHelper):
         if not kw.is_embedded:
             return kw.name
 
-        if get_robot_version() < (7, 0):
+        if RF_VERSION < (7, 0):
             for index, (before, variable, after) in enumerate(
                 VariableIterator(kw.name, identifiers="$", ignore_errors=True)
             ):
@@ -881,7 +874,7 @@ class CompletionCollector(ModelHelper):
                 if lib_name_index >= 0:
                     namespace_name = token.value[0 : lib_name_index - r.start.character]
 
-                    libraries = self.namespace.get_libraries()
+                    libraries = self.namespace.libraries
 
                     namespace_matcher = KeywordMatcher(namespace_name, is_namespace=True)
                     namespace_name = next(
@@ -931,7 +924,7 @@ class CompletionCollector(ModelHelper):
 
                     resources = {
                         k: v
-                        for k, v in self.namespace.get_resources().items()
+                        for k, v in self.namespace.resources.items()
                         if namespace_matcher == KeywordMatcher(v.name, is_namespace=True)
                     }
 
@@ -983,7 +976,7 @@ class CompletionCollector(ModelHelper):
         if namespace_matcher is not None:
             namespace_matcher = KeywordMatcher(namespace_matcher.name)
 
-        for kw in self.namespace.get_keywords():
+        for kw in self.namespace.keywords:
             if kw.is_error_handler:
                 continue
             if (
@@ -1019,7 +1012,7 @@ class CompletionCollector(ModelHelper):
         if valid_namespace and namespace_matcher is not None:
             return result
 
-        for k, v in (self.namespace.get_libraries()).items():
+        for k, v in self.namespace.libraries.items():
             result.append(
                 CompletionItem(
                     label=k,
@@ -1042,7 +1035,7 @@ class CompletionCollector(ModelHelper):
                 )
             )
 
-        for k, v in self.namespace.get_resources().items():
+        for k, v in self.namespace.resources.items():
             result.append(
                 CompletionItem(
                     label=v.name,
@@ -1705,7 +1698,7 @@ class CompletionCollector(ModelHelper):
                 complete_list = self.namespace.imports_manager.complete_library_import(
                     first_part if first_part else None,
                     str(self.document.uri.to_path().parent),
-                    self.namespace.get_resolvable_variables(nodes_at_position, position),
+                    self.namespace.get_resolvable_variables(position),
                 )
                 if not complete_list:
                     return None
@@ -1816,7 +1809,7 @@ class CompletionCollector(ModelHelper):
                 ):
                     return [
                         CompletionItem(
-                            label="AS" if get_robot_version() >= (6, 0) else "WITH NAME",
+                            label="AS" if RF_VERSION >= (6, 0) else "WITH NAME",
                             kind=CompletionItemKind.KEYWORD,
                             # detail=e.detail,
                             sort_text="99_NAMESPACE_MARKER",
@@ -1907,7 +1900,7 @@ class CompletionCollector(ModelHelper):
             complete_list = self.namespace.imports_manager.complete_resource_import(
                 first_part if first_part else None,
                 str(self.document.uri.to_path().parent),
-                self.namespace.get_resolvable_variables(nodes_at_position, position),
+                self.namespace.get_resolvable_variables(position),
             )
             if not complete_list:
                 return None
@@ -2031,7 +2024,7 @@ class CompletionCollector(ModelHelper):
                 complete_list = self.namespace.imports_manager.complete_variables_import(
                     first_part if first_part else None,
                     str(self.document.uri.to_path().parent),
-                    self.namespace.get_resolvable_variables(nodes_at_position, position),
+                    self.namespace.get_resolvable_variables(position),
                 )
                 if not complete_list:
                     return None
@@ -2270,7 +2263,7 @@ class CompletionCollector(ModelHelper):
             type_infos = keyword_doc.parent.get_types(kw_arguments[argument_index].types)
             for i, type_info in enumerate(type_infos):
                 if type_info.name == "boolean":
-                    if get_robot_version() >= (6, 0) and self.namespace.languages:
+                    if RF_VERSION >= (6, 0) and self.namespace.languages:
                         languages = self.namespace.languages.languages
 
                         if self.config.filter_default_language:
@@ -2400,6 +2393,20 @@ class CompletionCollector(ModelHelper):
                                 )
                             )
 
+            argument = kw_arguments[argument_index]
+            if argument.literal_values:
+                for literal_index, literal_value in enumerate(argument.literal_values):
+                    result.append(
+                        CompletionItem(
+                            label=literal_value,
+                            kind=CompletionItemKind.ENUM_MEMBER,
+                            detail="Literal",
+                            sort_text=f"09_{literal_index:09}_{literal_value}",
+                            insert_text_format=InsertTextFormat.PLAIN_TEXT,
+                            text_edit=TextEdit(range=completion_range, new_text=literal_value),
+                        )
+                    )
+
         if complete_argument_names:
             known_names = []
 
@@ -2495,19 +2502,17 @@ class CompletionCollector(ModelHelper):
             "robot:stop-on-failure",
             "robot:no-dry-run",
             "robot:exit",
+            "robot:skip",
+            "robot:skip-on-failure",
+            "robot:exclude",
+            "robot:recursive-continue-on-failure",
         }
 
-        if get_robot_version() >= (5, 0):
-            built_in_tags.add("robot:skip")
-            built_in_tags.add("robot:skip-on-failure")
-            built_in_tags.add("robot:exclude")
-            built_in_tags.add("robot:recursive-continue-on-failure")
-
-        if get_robot_version() >= (6, 0):
+        if RF_VERSION >= (6, 0):
             built_in_tags.add("robot:recursive-stop-on-failure")
             built_in_tags.add("robot:private")
 
-        if get_robot_version() >= (6, 1):
+        if RF_VERSION >= (6, 1):
             built_in_tags.add("robot:flatten")
 
         return [

robotcode/language_server/robotframework/parts/debugging_utils.py

@@ -56,7 +56,7 @@ class RobotDebuggingUtilsProtocolPart(RobotLanguageServerProtocolPart, ModelHelp
             return None
 
         namespace = self.parent.documents_cache.get_namespace(document)
-        model = self.parent.documents_cache.get_model(document, False)
+        model = self.parent.documents_cache.get_model(document)
 
         nodes = get_nodes_at_position(model, position)
         node = nodes[-1]
@@ -69,7 +69,7 @@ class RobotDebuggingUtilsProtocolPart(RobotLanguageServerProtocolPart, ModelHelp
         token_and_var = next(
             (
                 (t, v)
-                for t, v in self.iter_variables_from_token(token, namespace, nodes, position)
+                for t, v in self.iter_variables_from_token(token, namespace, position)
                 if position in range_from_token(t)
             ),
             None,
@@ -84,7 +84,7 @@ class RobotDebuggingUtilsProtocolPart(RobotLanguageServerProtocolPart, ModelHelp
             token_and_var = next(
                 (
                     (var_token, var)
-                    for var_token, var in self.iter_expression_variables_from_token(token, namespace, nodes, position)
+                    for var_token, var in self.iter_expression_variables_from_token(token, namespace, position)
                     if position in range_from_token(var_token)
                 ),
                 None,