robotcode-language-server 2.5.0__py3-none-any.whl → 2.6.0__py3-none-any.whl

robotcode/language_server/__version__.py

@@ -1 +1 @@
-__version__ = "2.5.0"
+__version__ = "2.6.0"

robotcode/language_server/common/parts/diagnostics.py

@@ -436,7 +436,7 @@ class DiagnosticsProtocolPart(LanguageServerProtocolPart):
                 documents_to_collect = [
                     doc
                     for doc in documents
-                    if doc.opened_in_editor or self.get_diagnostics_mode(document.uri) == DiagnosticsMode.WORKSPACE
+                    if doc.opened_in_editor or self.get_diagnostics_mode(doc.uri) == DiagnosticsMode.WORKSPACE
                 ]
 
                 with self._logger.measure_time(

robotcode/language_server/robotframework/parts/code_action_documentation.py

@@ -10,6 +10,7 @@ from robotcode.core.lsp.types import (
     CodeActionContext,
     CodeActionKind,
     Command,
+    Position,
     Range,
 )
 from robotcode.core.text_document import TextDocument
@@ -18,9 +19,16 @@ from robotcode.core.utils.dataclasses import CamelSnakeMixin
 from robotcode.core.utils.logging import LoggingDescriptor
 from robotcode.jsonrpc2.protocol import rpc_method
 from robotcode.robot.diagnostics.entities import LibraryEntry
-from robotcode.robot.diagnostics.library_doc import resolve_robot_variables
+from robotcode.robot.diagnostics.library_doc import KeywordDoc, resolve_robot_variables
 from robotcode.robot.diagnostics.model_helper import ModelHelper
 from robotcode.robot.diagnostics.namespace import Namespace
+from robotcode.robot.diagnostics.semantic_analyzer.enums import ImportType, NodeKind, TokenKind
+from robotcode.robot.diagnostics.semantic_analyzer.model import SemanticModel
+from robotcode.robot.diagnostics.semantic_analyzer.nodes import (
+    DefinitionStatement,
+    ImportStatement,
+    KeywordCallStatement,
+)
 from robotcode.robot.utils.ast import get_node_at_position, range_from_token
 
 from ...common.decorators import code_action_kinds
@@ -53,6 +61,26 @@ class RobotCodeActionDocumentationProtocolPart(RobotLanguageServerProtocolPart,
         document: TextDocument,
         range: Range,
         context: CodeActionContext,
+    ) -> Optional[List[Union[Command, CodeAction]]]:
+        namespace = self.parent.documents_cache.get_namespace(document)
+
+        # Tier 2 model-based path — used when the experimental SemanticAnalyzer
+        # is enabled. Reads everything off the SemanticModel: statement kind
+        # via `model.statement_at()`, the pre-resolved `keyword_doc`, the
+        # `import_name`, and SemanticTokens for cursor-position checks. No
+        # `find_keyword`, no AST walk.
+        semantic_model = namespace.semantic_model
+        if semantic_model is not None:
+            return self._collect_from_model(document, range, context, namespace, semantic_model)
+
+        return self._collect_legacy(document, range, context, namespace)
+
+    def _collect_legacy(
+        self,
+        document: TextDocument,
+        range: Range,
+        context: CodeActionContext,
+        namespace: Namespace,
     ) -> Optional[List[Union[Command, CodeAction]]]:
         from robot.parsing.lexer import Token as RobotToken
         from robot.parsing.model.statements import (
@@ -65,8 +93,6 @@ class RobotCodeActionDocumentationProtocolPart(RobotLanguageServerProtocolPart,
             TestTemplate,
         )
 
-        namespace = self.parent.documents_cache.get_namespace(document)
-
         model = self.parent.documents_cache.get_model(document)
         node = get_node_at_position(model, range.start)
 
@@ -111,40 +137,7 @@ class RobotCodeActionDocumentationProtocolPart(RobotLanguageServerProtocolPart,
 
                 if kw_doc is not None:
                     if context.only and CodeActionKind.SOURCE.value in context.only:
-                        entry: Optional[LibraryEntry] = None
-
-                        if kw_doc.libtype == "LIBRARY":
-                            entry = next(
-                                (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.resources.values() if v.library_doc == kw_doc.parent),
-                                None,
-                            )
-
-                            self_libdoc = namespace.library_doc
-                            if entry is None and self_libdoc == kw_doc.parent:
-                                entry = LibraryEntry(
-                                    self_libdoc.name,
-                                    str(document.uri.to_path().name),
-                                    self_libdoc,
-                                )
-
-                        if entry is None:
-                            return None
-
-                        url = self.build_url(
-                            entry.import_name,
-                            entry.args,
-                            document,
-                            namespace,
-                            kw_doc.name,
-                        )
-
-                        return [self.open_documentation_code_action(url)]
+                        return self._build_keyword_action(kw_doc, document, namespace)
 
         if isinstance(node, KeywordName):
             name_token = node.get_token(RobotToken.KEYWORD_NAME)
@@ -161,6 +154,159 @@ class RobotCodeActionDocumentationProtocolPart(RobotLanguageServerProtocolPart,
 
         return None
 
+    # ------------------------------------------------------------------
+    # Tier 2 model-based collection
+    # ------------------------------------------------------------------
+
+    def _collect_from_model(
+        self,
+        document: TextDocument,
+        range: Range,
+        context: CodeActionContext,
+        namespace: Namespace,
+        model: SemanticModel,
+    ) -> Optional[List[Union[Command, CodeAction]]]:
+        """Mirror legacy three-branch logic (import / keyword-call / keyword-def)
+        purely off the SemanticModel — no AST walks, no `find_keyword`.
+
+        Position checks use SemanticTokens; URL inputs read from pre-resolved
+        statement fields (`import_name`, `keyword_doc`, `name`).
+        """
+        # SemanticModel uses 1-indexed lines; LSP positions are 0-indexed.
+        stmt = model.statement_at(range.start.line + 1)
+        if stmt is None:
+            return None
+
+        # Branch 1: Library / Resource import — gated on context.only at entry.
+        if (
+            context.only
+            and isinstance(stmt, ImportStatement)
+            and stmt.import_type in (ImportType.LIBRARY, ImportType.RESOURCE)
+            and CodeActionKind.SOURCE.value in context.only
+        ):
+            return self._import_action_from_model(stmt, document, range, namespace)
+
+        # Branch 2: keyword call / fixture / template.
+        if isinstance(stmt, KeywordCallStatement):
+            if range.start != range.end:
+                return None
+            kw_doc = stmt.keyword_doc
+            if kw_doc is None:
+                return None
+            if not self._cursor_on_keyword_reference(range.start, stmt):
+                return None
+            if not (context.only and CodeActionKind.SOURCE.value in context.only):
+                return None
+            return self._build_keyword_action(kw_doc, document, namespace)
+
+        # Branch 3: keyword definition header — no context.only check
+        # (legacy doesn't gate this branch either).
+        if isinstance(stmt, DefinitionStatement) and stmt.kind is NodeKind.KEYWORD_DEF:
+            name_tok = next((t for t in stmt.tokens if t.kind is TokenKind.KEYWORD_NAME), None)
+            if name_tok is None or range not in name_tok.range:
+                return None
+            url = self.build_url(
+                str(document.uri.to_path().name),
+                (),
+                document,
+                namespace,
+                name_tok.value,
+            )
+            return [self.open_documentation_code_action(url)]
+
+        return None
+
+    def _import_action_from_model(
+        self,
+        stmt: ImportStatement,
+        document: TextDocument,
+        range: Range,
+        namespace: Namespace,
+    ) -> Optional[List[Union[Command, CodeAction]]]:
+        """Library / Resource import branch built off SemanticTokens.
+
+        - The import path lives in the IMPORT_NAME token (cursor-position check).
+        - Library `args` are the ARGUMENT tokens BEFORE the optional WITH NAME
+          marker (CONTROL_FLOW); anything after is the alias and must be
+          excluded — matches RF's `LibraryImport.args` semantics.
+        - Resource imports never carry args (RF API returns ()).
+        """
+        name_tok = next((t for t in stmt.tokens if t.kind is TokenKind.IMPORT_NAME), None)
+        if name_tok is None or range not in name_tok.range:
+            return None
+
+        if stmt.import_type is ImportType.LIBRARY:
+            arg_values: List[str] = []
+            for tok in stmt.tokens:
+                if tok.kind is TokenKind.CONTROL_FLOW:
+                    break  # WITH NAME — everything after is the alias
+                if tok.kind is TokenKind.ARGUMENT:
+                    arg_values.append(tok.value)
+            args: Tuple[str, ...] = tuple(arg_values)
+        else:
+            args = ()
+
+        url = self.build_url(stmt.import_name or "", args, document, namespace)
+        return [self.open_documentation_code_action(url)]
+
+    @staticmethod
+    def _cursor_on_keyword_reference(pos: Position, stmt: KeywordCallStatement) -> bool:
+        """Cursor is within the NAMESPACE / SEPARATOR / KEYWORD SemanticTokens
+        that make up the keyword reference (BDD prefix excluded). Mirrors
+        the legacy `position.is_in_range(range_from_token(keyword_token))`
+        after the BDD-prefix strip that
+        `get_keyworddoc_and_token_from_position` does.
+        """
+        return any(
+            pos in t.range
+            for t in stmt.tokens
+            if t.kind in (TokenKind.NAMESPACE, TokenKind.SEPARATOR, TokenKind.KEYWORD)
+        )
+
+    def _build_keyword_action(
+        self,
+        kw_doc: KeywordDoc,
+        document: TextDocument,
+        namespace: Namespace,
+    ) -> Optional[List[Union[Command, CodeAction]]]:
+        """Resolve the LibraryEntry that owns `kw_doc` and build the
+        Open-Documentation action. Shared between legacy and model paths so
+        the URL construction stays identical."""
+        entry: Optional[LibraryEntry] = None
+
+        if kw_doc.libtype == "LIBRARY":
+            entry = next(
+                (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.resources.values() if v.library_doc == kw_doc.parent),
+                None,
+            )
+
+            self_libdoc = namespace.library_doc
+            if entry is None and self_libdoc == kw_doc.parent:
+                entry = LibraryEntry(
+                    self_libdoc.name,
+                    str(document.uri.to_path().name),
+                    self_libdoc,
+                )
+
+        if entry is None:
+            return None
+
+        url = self.build_url(
+            entry.import_name,
+            entry.args,
+            document,
+            namespace,
+            kw_doc.name,
+        )
+
+        return [self.open_documentation_code_action(url)]
+
     def open_documentation_code_action(self, url: str) -> CodeAction:
         return CodeAction(
             "Open Documentation",

robotcode/language_server/robotframework/parts/code_action_quick_fixes.py

@@ -4,6 +4,7 @@ from string import Template as StringTemplate
 from typing import (
     TYPE_CHECKING,
     Any,
+    Iterable,
     List,
     Mapping,
     Optional,
@@ -49,8 +50,13 @@ from robotcode.core.text_document import TextDocument
 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.entities import LibraryEntry
 from robotcode.robot.diagnostics.errors import DIAGNOSTICS_SOURCE_NAME, Error
 from robotcode.robot.diagnostics.model_helper import ModelHelper
+from robotcode.robot.diagnostics.namespace import Namespace
+from robotcode.robot.diagnostics.semantic_analyzer.enums import TokenKind
+from robotcode.robot.diagnostics.semantic_analyzer.model import SemanticModel
+from robotcode.robot.diagnostics.semantic_analyzer.nodes import KeywordCallStatement
 from robotcode.robot.utils.ast import (
     FirstAndLastRealStatementFinder,
     get_node_at_position,
@@ -97,6 +103,26 @@ ${name}
 )
 
 
+def _format_create_keyword_args(arg_values: Iterable[str]) -> List[str]:
+    """Build the placeholder list for the new keyword's `[Arguments]` line.
+
+    For each argument value:
+    - `name=value` with a literal `name` (no variables in it) → `${name}`
+    - everything else → `${argN}` (N counted across all arguments)
+
+    Pure function so both the AST and SemanticModel paths produce
+    identical output for the same set of argument values.
+    """
+    out: List[str] = []
+    for value in arg_values:
+        name, val = split_from_equals(value)
+        if val is not None and not contains_variable(name, "$@&%"):
+            out.append(f"${{{name}}}")
+        else:
+            out.append(f"${{arg{len(out) + 1}}}")
+    return out
+
+
 class RobotCodeActionQuickFixesProtocolPart(RobotLanguageServerProtocolPart, ModelHelper, CodeActionHelperMixin):
     _logger = LoggingDescriptor()
 
@@ -155,7 +181,6 @@ class RobotCodeActionQuickFixesProtocolPart(RobotLanguageServerProtocolPart, Mod
             CodeActionTriggerKind.INVOKED,
             CodeActionTriggerKind.AUTOMATIC,
         ]:
-            model = self.parent.documents_cache.get_model(document)
             namespace = self.parent.documents_cache.get_namespace(document)
 
             for diagnostic in (
@@ -163,123 +188,176 @@ class RobotCodeActionQuickFixesProtocolPart(RobotLanguageServerProtocolPart, Mod
                 for d in context.diagnostics
                 if d.source == DIAGNOSTICS_SOURCE_NAME and d.code == Error.KEYWORD_NOT_FOUND
             ):
+                resolved = self._resolve_create_keyword_target(document, diagnostic.range.start, namespace)
+                if resolved is None:
+                    continue
+                text, lib_entry = resolved
+
                 disabled = None
-                node = get_node_at_position(model, diagnostic.range.start)
+                if lib_entry is not None and lib_entry.library_doc.type == "LIBRARY":
+                    disabled = CodeActionDisabledType("Keyword is from a library")
 
-                if isinstance(node, (KeywordCall, Fixture, TestTemplate, Template)):
-                    tokens = get_tokens_at_position(node, diagnostic.range.start)
-                    if not tokens:
-                        continue
+                result.append(
+                    CodeAction(
+                        f"Create Keyword `{text}`",
+                        kind=CodeActionKind.QUICK_FIX,
+                        data=as_dict(
+                            CodeActionData(
+                                "quickfix",
+                                "create_keyword",
+                                document.document_uri,
+                                diagnostic.range,
+                            )
+                        ),
+                        diagnostics=[diagnostic],
+                        disabled=disabled,
+                        is_preferred=True,
+                    )
+                )
 
-                    keyword_token = tokens[-1]
+        return result if result else None
 
-                    bdd_token, token = self.split_bdd_prefix(namespace, keyword_token)
-                    if bdd_token is not None and token is not None:
-                        keyword_token = token
+    # ------------------------------------------------------------------
+    # Tier 2 model-based resolution for the "Create Keyword" quick fix
+    # ------------------------------------------------------------------
 
-                    (
-                        lib_entry,
-                        kw_namespace,
-                    ) = self.get_namespace_info_from_keyword_token(namespace, keyword_token)
+    def _resolve_create_keyword_target(
+        self,
+        document: TextDocument,
+        position: Position,
+        namespace: Namespace,
+    ) -> Optional[Tuple[str, Optional[LibraryEntry]]]:
+        """Resolve the bare keyword name + owning LibraryEntry for the
+        "Create Keyword" quick fix at `position`.
+
+        Returns `(text, lib_entry)` or `None` if the position isn't a
+        KeywordCall / Fixture / Template AST node, or the keyword name is
+        empty after stripping the BDD / namespace prefix.
+
+        When the experimental SemanticAnalyzer is enabled the data comes
+        directly from the SemanticStatement; otherwise we fall back to
+        the legacy AST + `ModelHelper` path.
+        """
+        semantic_model = namespace.semantic_model
+        if semantic_model is not None:
+            return self._resolve_create_keyword_target_from_model(position, semantic_model)
+        return self._resolve_create_keyword_target_legacy(document, position, namespace)
+
+    def _resolve_create_keyword_target_from_model(
+        self,
+        position: Position,
+        model: SemanticModel,
+    ) -> Optional[Tuple[str, Optional[LibraryEntry]]]:
+        """SemanticModel branch: KEYWORD SemanticToken already has the bare
+        name (BDD prefix and namespace are split into their own tokens),
+        and `KeywordCallStatement.lib_entry` is the pre-resolved owner."""
+        stmt = model.statement_at(position.line + 1)
+        if not isinstance(stmt, KeywordCallStatement):
+            return None
+        kw_tok = next((t for t in stmt.tokens if t.kind is TokenKind.KEYWORD), None)
+        if kw_tok is None or not kw_tok.value:
+            return None
+        return kw_tok.value, stmt.lib_entry
 
-                    if lib_entry is not None and lib_entry.library_doc.type == "LIBRARY":
-                        disabled = CodeActionDisabledType("Keyword is from a library")
+    def _resolve_create_keyword_target_legacy(
+        self,
+        document: TextDocument,
+        position: Position,
+        namespace: Namespace,
+    ) -> Optional[Tuple[str, Optional[LibraryEntry]]]:
+        """AST + `ModelHelper` fallback (used when the experimental
+        analyzer is off). Mirrors the original inline logic exactly so
+        the model-path migration stays output-equivalent."""
+        model = self.parent.documents_cache.get_model(document)
+        node = get_node_at_position(model, position)
+        if not isinstance(node, (KeywordCall, Fixture, TestTemplate, Template)):
+            return None
 
-                    text = keyword_token.value
+        tokens = get_tokens_at_position(node, position)
+        if not tokens:
+            return None
+        keyword_token = tokens[-1]
 
-                    if lib_entry and kw_namespace:
-                        text = text[len(kw_namespace) + 1 :].strip()
+        bdd_token, token = self.split_bdd_prefix(namespace, keyword_token)
+        if bdd_token is not None and token is not None:
+            keyword_token = token
 
-                    if not text:
-                        continue
+        lib_entry, kw_namespace = self.get_namespace_info_from_keyword_token(namespace, keyword_token)
 
-                    result.append(
-                        CodeAction(
-                            f"Create Keyword `{text}`",
-                            kind=CodeActionKind.QUICK_FIX,
-                            data=as_dict(
-                                CodeActionData(
-                                    "quickfix",
-                                    "create_keyword",
-                                    document.document_uri,
-                                    diagnostic.range,
-                                )
-                            ),
-                            diagnostics=[diagnostic],
-                            disabled=disabled,
-                            is_preferred=True,
-                        )
-                    )
+        text = keyword_token.value
+        if lib_entry and kw_namespace:
+            text = text[len(kw_namespace) + 1 :].strip()
+        if not text:
+            return None
 
-        return result if result else None
+        return text, lib_entry
 
     def resolve_code_action_create_keyword(self, code_action: CodeAction, data: CodeActionData) -> Optional[CodeAction]:
         document = self.parent.documents.get(data.document_uri)
         if document is None:
             return None
 
-        model = self.parent.documents_cache.get_model(document)
-        node = get_node_at_position(model, data.range.start)
-
-        if isinstance(node, (KeywordCall, Fixture, TestTemplate, Template)):
-            tokens = get_tokens_at_position(node, data.range.start)
-            if not tokens:
-                return None
-
-            keyword_token = tokens[-1]
-
-            namespace = self.parent.documents_cache.get_namespace(document)
-
-            bdd_token, token = self.split_bdd_prefix(namespace, keyword_token)
-            if bdd_token is not None and token is not None:
-                keyword_token = token
-
-            (
-                lib_entry,
-                kw_namespace,
-            ) = self.get_namespace_info_from_keyword_token(namespace, keyword_token)
-
-            if lib_entry is not None and lib_entry.library_doc.type == "LIBRARY":
-                return None
-
-            text = keyword_token.value
-
-            if lib_entry and kw_namespace:
-                text = text[len(kw_namespace) + 1 :].strip()
+        namespace = self.parent.documents_cache.get_namespace(document)
 
-            if not text:
-                return None
+        resolved = self._resolve_create_keyword_target(document, data.range.start, namespace)
+        if resolved is None:
+            return None
+        text, lib_entry = resolved
 
-            arguments = []
+        # Library keywords can't be auto-created; legacy returns None here.
+        if lib_entry is not None and lib_entry.library_doc.type == "LIBRARY":
+            return None
 
-            for t in node.get_tokens(Token.ARGUMENT):
-                name, value = split_from_equals(cast(Token, t).value)
-                if value is not None and not contains_variable(name, "$@&%"):
-                    arguments.append(f"${{{name}}}")
-                else:
-                    arguments.append(f"${{arg{len(arguments) + 1}}}")
+        arguments = self._collect_create_keyword_arguments(document, data.range.start, namespace)
 
-            insert_text = (
-                KEYWORD_WITH_ARGS_TEMPLATE.substitute(name=text, args="    ".join(arguments))
-                if arguments
-                else KEYWORD_TEMPLATE.substitute(name=text)
-            )
+        insert_text = (
+            KEYWORD_WITH_ARGS_TEMPLATE.substitute(name=text, args="    ".join(arguments))
+            if arguments
+            else KEYWORD_TEMPLATE.substitute(name=text)
+        )
 
-            if lib_entry is not None and lib_entry.library_doc.type == "RESOURCE" and lib_entry.library_doc.source:
-                dest_document = self.parent.documents.get_or_open_document(lib_entry.library_doc.source)
-            else:
-                dest_document = document
+        if lib_entry is not None and lib_entry.library_doc.type == "RESOURCE" and lib_entry.library_doc.source:
+            dest_document = self.parent.documents.get_or_open_document(lib_entry.library_doc.source)
+        else:
+            dest_document = document
 
-            code_action.edit, select_range = self._apply_create_keyword(dest_document, insert_text)
+        code_action.edit, select_range = self._apply_create_keyword(dest_document, insert_text)
 
-            code_action.command = Command(
-                SHOW_DOCUMENT_SELECT_AND_RENAME_COMMAND,
-                SHOW_DOCUMENT_SELECT_AND_RENAME_COMMAND,
-                [dest_document.document_uri, select_range, False],
-            )
-            return code_action
+        code_action.command = Command(
+            SHOW_DOCUMENT_SELECT_AND_RENAME_COMMAND,
+            SHOW_DOCUMENT_SELECT_AND_RENAME_COMMAND,
+            [dest_document.document_uri, select_range, False],
+        )
+        return code_action
 
-        return None
+    def _collect_create_keyword_arguments(
+        self,
+        document: TextDocument,
+        position: Position,
+        namespace: Namespace,
+    ) -> List[str]:
+        """Build the `${name}` / `${argN}` placeholder list for the new
+        keyword's `[Arguments]` line, derived from the offending call's
+        ARGUMENT tokens.
+
+        SemanticModel-based when available (iterates `stmt.tokens`),
+        falls back to the AST `node.get_tokens(ARGUMENT)` walk otherwise.
+        Both paths apply the same `name=value` heuristic via
+        `split_from_equals`.
+        """
+        semantic_model = namespace.semantic_model
+        if semantic_model is not None:
+            stmt = semantic_model.statement_at(position.line + 1)
+            if isinstance(stmt, KeywordCallStatement):
+                arg_tokens = [t for t in stmt.tokens if t.kind is TokenKind.ARGUMENT]
+                return _format_create_keyword_args(t.value for t in arg_tokens)
+            return []
+
+        ast_model = self.parent.documents_cache.get_model(document)
+        node = get_node_at_position(ast_model, position)
+        if not isinstance(node, (KeywordCall, Fixture, TestTemplate, Template)):
+            return []
+        return _format_create_keyword_args(cast(Token, t).value for t in node.get_tokens(Token.ARGUMENT))
 
     def _apply_create_keyword(self, document: TextDocument, insert_text: str) -> Tuple[WorkspaceEdit, Range]:
         model = self.parent.documents_cache.get_model(document)