robotcode-language-server 2.6.2__py3-none-any.whl → 2.8.0.dev548__py3-none-any.whl

robotcode/language_server/robotframework/parts/code_action_helper_mixin.py

@@ -2,9 +2,9 @@ from __future__ import annotations
 
 import ast
 from dataclasses import dataclass
-from typing import List, Optional, Tuple
+from typing import List, Optional, Tuple, Union
 
-from robotcode.core.lsp.types import DocumentUri, Position, Range
+from robotcode.core.lsp.types import CodeActionContext, CodeActionKind, DocumentUri, Position, Range
 from robotcode.core.text_document import TextDocument
 from robotcode.robot.diagnostics.namespace import Namespace
 from robotcode.robot.utils.ast import range_from_node
@@ -13,6 +13,21 @@ from robotcode.robot.utils.visitor import Visitor
 SHOW_DOCUMENT_SELECT_AND_RENAME_COMMAND = "_robotcode.codeActionShowDocumentSelectAndRename"
 
 
+def code_action_kind_requested(context: CodeActionContext, kind: Union[CodeActionKind, str]) -> bool:
+    """Whether a code action request with `context` asks for code actions of `kind`.
+
+    Without `only` it asks for every kind. With `only` it asks for the listed kinds and the kinds below them, since
+    the LSP defines kinds hierarchically: `refactor` also takes `refactor.extract.function`.
+    """
+    if not context.only:
+        return True
+    value = kind.value if isinstance(kind, CodeActionKind) else kind
+    return any(
+        value == requested or value.startswith(f"{requested}.")
+        for requested in (o.value if isinstance(o, CodeActionKind) else o for o in context.only)
+    )
+
+
 @dataclass
 class CodeActionDataBase:
     type: str

robotcode/language_server/robotframework/parts/code_action_quick_fixes.py

@@ -38,7 +38,6 @@ from robotcode.core.lsp.types import (
     CodeActionContext,
     CodeActionDisabledType,
     CodeActionKind,
-    CodeActionTriggerKind,
     Command,
     OptionalVersionedTextDocumentIdentifier,
     Position,
@@ -73,6 +72,7 @@ from .code_action_helper_mixin import (
     CodeActionDataBase,
     CodeActionHelperMixin,
     FindSectionsVisitor,
+    code_action_kind_requested,
 )
 from .protocol_part import RobotLanguageServerProtocolPart
 
@@ -177,10 +177,7 @@ class RobotCodeActionQuickFixesProtocolPart(RobotLanguageServerProtocolPart, Mod
     ) -> Optional[List[Union[Command, CodeAction]]]:
         result: List[Union[Command, CodeAction]] = []
 
-        if (context.only and CodeActionKind.QUICK_FIX in context.only) or context.trigger_kind in [
-            CodeActionTriggerKind.INVOKED,
-            CodeActionTriggerKind.AUTOMATIC,
-        ]:
+        if code_action_kind_requested(context, CodeActionKind.QUICK_FIX):
             namespace = self.parent.documents_cache.get_namespace(document)
 
             for diagnostic in (
@@ -388,14 +385,7 @@ class RobotCodeActionQuickFixesProtocolPart(RobotLanguageServerProtocolPart, Mod
         if (
             range.start.line == range.end.line
             and range.start.character <= range.end.character
-            and (
-                (context.only and CodeActionKind.QUICK_FIX in context.only)
-                or context.trigger_kind
-                in [
-                    CodeActionTriggerKind.INVOKED,
-                    CodeActionTriggerKind.AUTOMATIC,
-                ]
-            )
+            and code_action_kind_requested(context, CodeActionKind.QUICK_FIX)
         ):
             all_diagnostics = [d for d in context.diagnostics if d.source and d.source.startswith("robotcode.")]
             if all_diagnostics:
@@ -471,10 +461,7 @@ class RobotCodeActionQuickFixesProtocolPart(RobotLanguageServerProtocolPart, Mod
     ) -> Optional[List[Union[Command, CodeAction]]]:
         result: List[Union[Command, CodeAction]] = []
 
-        if (context.only and CodeActionKind.QUICK_FIX in context.only) or context.trigger_kind in [
-            CodeActionTriggerKind.INVOKED,
-            CodeActionTriggerKind.AUTOMATIC,
-        ]:
+        if code_action_kind_requested(context, CodeActionKind.QUICK_FIX):
             for diagnostic in (
                 d
                 for d in context.diagnostics
@@ -587,10 +574,7 @@ class RobotCodeActionQuickFixesProtocolPart(RobotLanguageServerProtocolPart, Mod
     ) -> Optional[List[Union[Command, CodeAction]]]:
         result: List[Union[Command, CodeAction]] = []
 
-        if (context.only and CodeActionKind.QUICK_FIX in context.only) or context.trigger_kind in [
-            CodeActionTriggerKind.INVOKED,
-            CodeActionTriggerKind.AUTOMATIC,
-        ]:
+        if code_action_kind_requested(context, CodeActionKind.QUICK_FIX):
             for diagnostic in (
                 d
                 for d in context.diagnostics
@@ -737,10 +721,7 @@ class RobotCodeActionQuickFixesProtocolPart(RobotLanguageServerProtocolPart, Mod
     ) -> Optional[List[Union[Command, CodeAction]]]:
         result: List[Union[Command, CodeAction]] = []
 
-        if (context.only and CodeActionKind.QUICK_FIX in context.only) or context.trigger_kind in [
-            CodeActionTriggerKind.INVOKED,
-            CodeActionTriggerKind.AUTOMATIC,
-        ]:
+        if code_action_kind_requested(context, CodeActionKind.QUICK_FIX):
             for diagnostic in (
                 d
                 for d in context.diagnostics

robotcode/language_server/robotframework/parts/code_action_refactor.py

@@ -13,7 +13,6 @@ from robotcode.core.lsp.types import (
     CodeActionContext,
     CodeActionDisabledType,
     CodeActionKind,
-    CodeActionTriggerKind,
     Command,
     OptionalVersionedTextDocumentIdentifier,
     Position,
@@ -41,6 +40,7 @@ from .code_action_helper_mixin import (
     SHOW_DOCUMENT_SELECT_AND_RENAME_COMMAND,
     CodeActionDataBase,
     CodeActionHelperMixin,
+    code_action_kind_requested,
 )
 from .protocol_part import RobotLanguageServerProtocolPart
 
@@ -111,6 +111,7 @@ class RobotCodeActionRefactorProtocolPart(RobotLanguageServerProtocolPart, CodeA
     @code_action_kinds(
         [
             CODE_ACTION_KIND_REFACTOR_EXTRACT_FUNCTION,
+            CODE_ACTION_KIND_REFACTOR_EXTRACT_VARIABLE,
             CODE_ACTION_KIND_SURROUND_WITH,
         ]
     )
@@ -259,7 +260,7 @@ class RobotCodeActionRefactorProtocolPart(RobotLanguageServerProtocolPart, CodeA
     ) -> Optional[List[Union[Command, CodeAction]]]:
         from robot.parsing.model.blocks import Keyword, TestCase
 
-        if range.start == range.end:
+        if range.start == range.end or not code_action_kind_requested(context, CODE_ACTION_KIND_SURROUND_WITH):
             return None
 
         model = self.parent.documents_cache.get_model(document)
@@ -491,9 +492,8 @@ class RobotCodeActionRefactorProtocolPart(RobotLanguageServerProtocolPart, CodeA
     def code_action_assign_result_to_variable(
         self, document: TextDocument, range: Range, context: CodeActionContext
     ) -> Optional[List[Union[Command, CodeAction]]]:
-        if range.start.line != range.end.line or not (
-            (context.only and CodeActionKind.REFACTOR_EXTRACT in context.only)
-            or context.trigger_kind in [CodeActionTriggerKind.INVOKED, CodeActionTriggerKind.AUTOMATIC]
+        if range.start.line != range.end.line or not code_action_kind_requested(
+            context, CODE_ACTION_KIND_REFACTOR_EXTRACT_VARIABLE
         ):
             return None
 
@@ -575,7 +575,9 @@ class RobotCodeActionRefactorProtocolPart(RobotLanguageServerProtocolPart, CodeA
     ) -> Optional[List[Union[Command, CodeAction]]]:
         from robot.parsing.model.blocks import Keyword, TestCase
 
-        if range.start == range.end:
+        if range.start == range.end or not code_action_kind_requested(
+            context, CODE_ACTION_KIND_REFACTOR_EXTRACT_FUNCTION
+        ):
             return None
 
         model = self.parent.documents_cache.get_model(document)

robotcode/language_server/robotframework/parts/code_lens.py

@@ -8,7 +8,6 @@ from robotcode.core.text_document import TextDocument
 from robotcode.core.utils.logging import LoggingDescriptor
 from robotcode.language_server.robotframework.configuration import AnalysisConfig
 from robotcode.robot.diagnostics.library_doc import KeywordDoc
-from robotcode.robot.diagnostics.model_helper import ModelHelper
 from robotcode.robot.utils.ast import range_from_token
 from robotcode.robot.utils.visitor import Visitor
 
@@ -18,7 +17,7 @@ if TYPE_CHECKING:
     from ..protocol import RobotLanguageServerProtocol
 
 
-class RobotCodeLensProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
+class RobotCodeLensProtocolPart(RobotLanguageServerProtocolPart):
     _logger = LoggingDescriptor()
 
     def __init__(self, parent: "RobotLanguageServerProtocol") -> None:
@@ -73,7 +72,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.library_doc, line)
+            kw_doc = next((k for k in namespace.library_doc.keywords.keywords if k.line_no == line), None)
 
             if kw_doc is not None and not kw_doc.is_error_handler:
                 if not self.parent.robot_references.has_cached_keyword_references(
@@ -111,7 +110,7 @@ class RobotCodeLensProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
                         document, kw_doc, include_declaration=False
                     )
                     code_lens.command = Command(
-                        f"{len(references)} references",
+                        f"{len(references)} {'reference' if len(references) == 1 else 'references'}",
                         "editor.action.showReferences",
                         [str(document.uri), code_lens.range.start, references],
                     )

robotcode/language_server/robotframework/parts/completion.py

@@ -52,6 +52,7 @@ from robotcode.core.lsp.types import (
     CompletionContext,
     CompletionItem,
     CompletionItemKind,
+    CompletionItemLabelDetails,
     CompletionList,
     InsertTextFormat,
     MarkupContent,
@@ -62,12 +63,15 @@ from robotcode.core.lsp.types import (
 )
 from robotcode.core.text_document import TextDocument
 from robotcode.core.utils.logging import LoggingDescriptor
+from robotcode.robot.diagnostics.diagnostic_rules import private_keyword_call_message
 from robotcode.robot.diagnostics.entities import VariableDefinitionType
 from robotcode.robot.diagnostics.library_doc import (
+    ArgumentInfo,
     CompleteResultKind,
     KeywordArgumentKind,
     KeywordDoc,
     KeywordMatcher,
+    LibraryDoc,
 )
 from robotcode.robot.diagnostics.model_helper import ModelHelper
 from robotcode.robot.diagnostics.namespace import DocumentType, Namespace
@@ -80,9 +84,11 @@ from robotcode.robot.utils.ast import (
     whitespace_at_begin_of_token,
     whitespace_from_begin_of_token,
 )
+from robotcode.robot.utils.markdown_docs import LinkResolver
 
 from ...common.decorators import trigger_characters
 from ..configuration import CompletionConfig
+from .code_action_documentation import DocumentationTarget, keyword_reference_targets, link_documentation
 from .protocol_part import RobotLanguageServerProtocolPart
 
 if RF_VERSION >= (6, 1):
@@ -94,6 +100,7 @@ else:
 
 if TYPE_CHECKING:
     from ..protocol import RobotLanguageServerProtocol
+    from .code_action_documentation import RobotCodeActionDocumentationProtocolPart
 
 if RF_VERSION < (7, 0):
     from robot.variables.search import VariableIterator
@@ -319,6 +326,14 @@ class CompletionItemImportData(CompletionItemData):
     id: str
 
 
+# a file of a Variables import is resolved like a library, but has no page in the Documentation Viewer
+VARIABLES_IMPORT = "VARIABLES"
+
+
+class CompletionItemVariablesImportData(CompletionItemData):
+    import_type: str
+
+
 class CompletionCollector(ModelHelper):
     _logger = LoggingDescriptor()
 
@@ -409,18 +424,25 @@ class CompletionCollector(ModelHelper):
                     ]:
                         if (lib_id := data.get("id", None)) is not None:
                             try:
-                                lib_doc = next(
+                                lib_entry = next(
                                     (
-                                        ld.library_doc
+                                        ld
                                         for ld in self.namespace.libraries.values()
                                         if str(id(ld.library_doc)) == lib_id
                                     ),
                                     None,
                                 )
-                                if lib_doc is not None:
+                                if lib_entry is not None:
+                                    entry = lib_entry
                                     completion_item.documentation = MarkupContent(
                                         kind=MarkupKind.MARKDOWN,
-                                        value=lib_doc.to_markdown(False),
+                                        value=self._documentation(
+                                            lambda r: entry.library_doc.to_markdown(False, link_resolver=r),
+                                            lambda: self._code_action_documentation.entry_target(
+                                                entry, True, document, self.namespace
+                                            ),
+                                            entry.library_doc,
+                                        ),
                                     )
 
                             except (
@@ -444,9 +466,22 @@ class CompletionCollector(ModelHelper):
                                 )
 
                                 if lib_doc is not None:
+                                    library_doc = lib_doc
+                                    library_name = name
+                                    is_variables = cast(Dict[str, Any], data).get("import_type") == VARIABLES_IMPORT
                                     completion_item.documentation = MarkupContent(
                                         kind=MarkupKind.MARKDOWN,
-                                        value=lib_doc.to_markdown(False),
+                                        value=self._documentation(
+                                            lambda r: library_doc.to_markdown(False, link_resolver=r),
+                                            lambda: (
+                                                None
+                                                if is_variables
+                                                else self._code_action_documentation.import_target(
+                                                    library_name, (), True, document, self.namespace
+                                                )
+                                            ),
+                                            library_doc,
+                                        ),
                                     )
 
                             except (SystemExit, KeyboardInterrupt):
@@ -457,19 +492,26 @@ class CompletionCollector(ModelHelper):
                     elif comp_type == CompleteResultKind.RESOURCE.name:
                         if (res_id := data.get("id", None)) is not None:
                             try:
-                                lib_doc = next(
+                                res_entry = next(
                                     (
-                                        ld.library_doc
+                                        ld
                                         for ld in self.namespace.resources.values()
                                         if str(id(ld.library_doc)) == res_id
                                     ),
                                     None,
                                 )
 
-                                if lib_doc is not None:
+                                if res_entry is not None:
+                                    resource_entry = res_entry
                                     completion_item.documentation = MarkupContent(
                                         kind=MarkupKind.MARKDOWN,
-                                        value=lib_doc.to_markdown(False),
+                                        value=self._documentation(
+                                            lambda r: resource_entry.library_doc.to_markdown(False, link_resolver=r),
+                                            lambda: self._code_action_documentation.entry_target(
+                                                resource_entry, False, document, self.namespace
+                                            ),
+                                            resource_entry.library_doc,
+                                        ),
                                     )
 
                             except (
@@ -493,9 +535,17 @@ class CompletionCollector(ModelHelper):
                                 )
 
                                 if lib_doc is not None:
+                                    resource_doc = lib_doc
+                                    resource_name = name
                                     completion_item.documentation = MarkupContent(
                                         kind=MarkupKind.MARKDOWN,
-                                        value=lib_doc.to_markdown(False),
+                                        value=self._documentation(
+                                            lambda r: resource_doc.to_markdown(False, link_resolver=r),
+                                            lambda: self._code_action_documentation.import_target(
+                                                resource_name, (), False, document, self.namespace
+                                            ),
+                                            resource_doc,
+                                        ),
                                     )
 
                             except (SystemExit, KeyboardInterrupt):
@@ -512,9 +562,19 @@ class CompletionCollector(ModelHelper):
                                 )
 
                                 if kw_doc is not None:
+                                    keyword_doc = kw_doc
                                     completion_item.documentation = MarkupContent(
                                         kind=MarkupKind.MARKDOWN,
-                                        value=kw_doc.to_markdown(),
+                                        value=self._documentation(
+                                            lambda r: keyword_doc.to_markdown(
+                                                link_resolver=r,
+                                                reference_targets=keyword_reference_targets(keyword_doc, r is not None),
+                                            ),
+                                            lambda: self._code_action_documentation.keyword_target(
+                                                keyword_doc, None, document, self.namespace
+                                            ),
+                                            keyword_doc.parent,
+                                        ),
                                     )
 
                             except (
@@ -532,6 +592,37 @@ class CompletionCollector(ModelHelper):
 
         return completion_item
 
+    @property
+    def _links(self) -> bool:
+        return self.parent.parent.robot_initialization_options.documentation_viewer_links
+
+    @property
+    def _code_action_documentation(self) -> "RobotCodeActionDocumentationProtocolPart":
+        return self.parent.parent.robot_code_action_documentation
+
+    def _documentation(
+        self,
+        render: Callable[[Optional[LinkResolver]], str],
+        target: Callable[[], Optional[DocumentationTarget]],
+        library_doc: Optional[LibraryDoc],
+        *,
+        heading: bool = True,
+    ) -> str:
+        """The documentation of an item; with links, linked into the Documentation Viewer at the page of `target`."""
+        if not self._links:
+            return render(None)
+        documentation_target = target()
+        link_resolver = (
+            self._code_action_documentation.link_resolver(
+                self.document, self.namespace, documentation_target, library_doc
+            )
+            if documentation_target is not None and library_doc is not None
+            else None
+        )
+        return link_documentation(
+            render, documentation_target, library_doc, heading=heading, link_resolver=link_resolver
+        )
+
     def create_headers_completion_items(self, range: Optional[Range]) -> List[CompletionItem]:
         doc_type = self.parent.parent.documents_cache.get_document_type(self.document)
 
@@ -810,6 +901,24 @@ class CompletionCollector(ModelHelper):
 
         return result
 
+    def _is_foreign_private(self, kw: KeywordDoc) -> bool:
+        return private_keyword_call_message(kw, self.namespace.source) is not None
+
+    def _is_hidden(self, kw: KeywordDoc, private: bool) -> bool:
+        return (private and self.config.hide_private_keywords) or (
+            kw.is_deprecated and self.config.hide_deprecated_keywords
+        )
+
+    @staticmethod
+    def _private_label_details(private: bool) -> Optional[CompletionItemLabelDetails]:
+        return CompletionItemLabelDetails(description="private") if private else None
+
+    @staticmethod
+    def _keyword_sort_text(prefix: str, kw: KeywordDoc, private: bool) -> str:
+        """Other keywords first, then deprecated ones, then the shown private keywords of other files."""
+        rank = 2 if private else 1 if kw.is_deprecated else 0
+        return f"{prefix}{rank}_{kw.name}"
+
     def create_keyword_completion_items(
         self,
         token: Optional[Token],
@@ -889,13 +998,18 @@ class CompletionCollector(ModelHelper):
                         for kw in libraries[namespace_name].library_doc.keywords.values():
                             if kw.is_error_handler:
                                 continue
+                            private = self._is_foreign_private(kw)
+                            if self._is_hidden(kw, private):
+                                continue
                             result.append(
                                 CompletionItem(
                                     label=kw.name,
+                                    label_details=self._private_label_details(private),
                                     kind=CompletionItemKind.FUNCTION,
                                     detail=f"{CompleteResultKind.KEYWORD.value} "
                                     f"{f'({kw.libname})' if kw.libname is not None else ''}",
-                                    sort_text=f"019_{kw.name}",
+                                    deprecated=kw.is_deprecated,
+                                    sort_text=self._keyword_sort_text("019_", kw, private),
                                     insert_text_format=(
                                         InsertTextFormat.PLAIN_TEXT if not kw.is_embedded else InsertTextFormat.SNIPPET
                                     ),
@@ -935,14 +1049,19 @@ class CompletionCollector(ModelHelper):
                             for kw in res.library_doc.keywords.values():
                                 if kw.is_error_handler:
                                     continue
+                                private = self._is_foreign_private(kw)
+                                if self._is_hidden(kw, private):
+                                    continue
 
                                 result.append(
                                     CompletionItem(
                                         label=kw.name,
+                                        label_details=self._private_label_details(private),
                                         kind=CompletionItemKind.FUNCTION,
                                         detail=f"{CompleteResultKind.KEYWORD.value} "
                                         f"{f'({kw.libname})' if kw.libname is not None else ''}",
-                                        sort_text=f"019_{kw.name}",
+                                        deprecated=kw.is_deprecated,
+                                        sort_text=self._keyword_sort_text("019_", kw, private),
                                         insert_text_format=(
                                             InsertTextFormat.PLAIN_TEXT
                                             if not kw.is_embedded
@@ -985,14 +1104,18 @@ class CompletionCollector(ModelHelper):
                 and not kw.matcher.normalized_name.startswith(namespace_matcher.normalized_name)
             ):
                 continue
+            private = self._is_foreign_private(kw)
+            if self._is_hidden(kw, private):
+                continue
 
             result.append(
                 CompletionItem(
                     label=kw.name,
+                    label_details=self._private_label_details(private),
                     kind=CompletionItemKind.FUNCTION,
                     detail=f"{CompleteResultKind.KEYWORD.value} {f'({kw.libname})' if kw.libname is not None else ''}",
                     deprecated=kw.is_deprecated,
-                    sort_text=f"020_{kw.name}",
+                    sort_text=self._keyword_sort_text("020_", kw, private),
                     insert_text_format=InsertTextFormat.PLAIN_TEXT if not kw.is_embedded else InsertTextFormat.SNIPPET,
                     text_edit=TextEdit(
                         range=r,
@@ -1783,6 +1906,13 @@ class CompletionCollector(ModelHelper):
                             kw_node.tokens[name_token_index:],
                             token_at_position,
                             position,
+                            (
+                                self._code_action_documentation.import_target(
+                                    import_node.name, import_node.args, True, self.document, self.namespace, libdoc
+                                )
+                                if self._links
+                                else None
+                            ),
                         )
 
             except (SystemExit, KeyboardInterrupt, CancelledError):
@@ -2056,10 +2186,11 @@ class CompletionCollector(ModelHelper):
                     sort_text=f"030_{e.label}",
                     insert_text_format=InsertTextFormat.PLAIN_TEXT,
                     text_edit=TextEdit(range=r, new_text=e.label) if r is not None else None,
-                    data=CompletionItemData(
+                    data=CompletionItemVariablesImportData(
                         document_uri=str(self.document.uri),
                         type=e.kind.name,
                         name=((first_part) if first_part is not None else "") + e.label,
+                        import_type=VARIABLES_IMPORT,
                     ),
                 )
                 for e in complete_list
@@ -2175,11 +2306,19 @@ class CompletionCollector(ModelHelper):
 
         keyword_token_index = kw_node.tokens.index(keyword_token)
 
+        target = None
+        if self._links:
+            prefix_entry, _ = self.get_namespace_info_from_keyword_token(self.namespace, keyword_doc_and_token[1])
+            target = self._code_action_documentation.keyword_target(
+                keyword_doc, prefix_entry, self.document, self.namespace
+            )
+
         return self._complete_keyword_arguments_at_position(
             keyword_doc,
             kw_node.tokens[keyword_token_index:],
             token_at_position,
             position,
+            target,
         )
 
     TRUE_STRINGS = {"TRUE", "YES", "ON", "1"}
@@ -2191,10 +2330,15 @@ class CompletionCollector(ModelHelper):
         tokens: Tuple[Token, ...],
         token_at_position: Token,
         position: Position,
+        target: Optional[DocumentationTarget] = None,
     ) -> Optional[List[CompletionItem]]:
         if keyword_doc.is_any_run_keyword():
             return None
 
+        def type_documentation(markdown: str) -> str:
+            # the documentation of a type links no names, only its links to a place in the documentation
+            return self._documentation(lambda _: markdown, lambda: target, None, heading=False)
+
         (
             argument_index,
             kw_arguments,
@@ -2260,7 +2404,7 @@ class CompletionCollector(ModelHelper):
                 or has_name
             )
         ):
-            type_infos = keyword_doc.parent.get_types(kw_arguments[argument_index].types)
+            type_infos = keyword_doc.parent.get_types_for_argument(kw_arguments[argument_index])
             for i, type_info in enumerate(type_infos):
                 if type_info.name == "boolean":
                     if RF_VERSION >= (6, 0) and self.namespace.languages:
@@ -2287,7 +2431,7 @@ class CompletionCollector(ModelHelper):
                     for i, b_snippet in enumerate(bool_snippets):
                         if b_snippet[0]:
                             cache_name = f"BOOL{id(type_info)}_{i}"
-                            self.parent.doc_cache[cache_name] = type_info.to_markdown()
+                            self.parent.doc_cache[cache_name] = type_documentation(type_info.to_markdown())
                             result.append(
                                 CompletionItem(
                                     label=b_snippet[0],
@@ -2312,7 +2456,9 @@ class CompletionCollector(ModelHelper):
                             label="None",
                             kind=CompletionItemKind.CONSTANT,
                             detail=f"{type_info.name}",
-                            documentation=MarkupContent(MarkupKind.MARKDOWN, type_info.to_markdown()),
+                            documentation=MarkupContent(
+                                MarkupKind.MARKDOWN, type_documentation(type_info.to_markdown())
+                            ),
                             sort_text="50_000_None",
                             insert_text_format=InsertTextFormat.PLAIN_TEXT,
                             text_edit=TextEdit(range=completion_range, new_text="None"),
@@ -2323,7 +2469,9 @@ class CompletionCollector(ModelHelper):
                             label="${None}",
                             kind=CompletionItemKind.VARIABLE,
                             detail=f"{type_info.name}",
-                            documentation=MarkupContent(MarkupKind.MARKDOWN, type_info.to_markdown()),
+                            documentation=MarkupContent(
+                                MarkupKind.MARKDOWN, type_documentation(type_info.to_markdown())
+                            ),
                             sort_text="50_001_None",
                             insert_text_format=InsertTextFormat.PLAIN_TEXT,
                             text_edit=TextEdit(range=completion_range, new_text="${None}"),
@@ -2332,7 +2480,7 @@ class CompletionCollector(ModelHelper):
                 if type_info.members:
                     for member_index, member in enumerate(type_info.members):
                         cache_name = f"TYPE_MEMBER{id(type_info)}_{member_index}"
-                        self.parent.doc_cache[cache_name] = (
+                        self.parent.doc_cache[cache_name] = type_documentation(
                             f"```python\n{member.name} = {member.value}\n```"
                             "\n\n---"
                             f"\n{type_info.to_markdown(only_doc=True)}"
@@ -2375,7 +2523,7 @@ class CompletionCollector(ModelHelper):
                     ]
                     for i, snippet in enumerate(snippets):
                         cache_name = f"TYPE_ITEMS{id(type_info)}_{i}"
-                        self.parent.doc_cache[cache_name] = type_info.to_markdown()
+                        self.parent.doc_cache[cache_name] = type_documentation(type_info.to_markdown())
                         if snippet:
                             result.append(
                                 CompletionItem(
@@ -2449,6 +2597,29 @@ class CompletionCollector(ModelHelper):
                         - 1
                     )
 
+            # once for all arguments of the keyword
+            targets = keyword_reference_targets(keyword_doc, self._links)
+
+            def documentation_data(argument: ArgumentInfo) -> Optional[CompletionItemData]:
+                # the description of the argument and the documentation of its types, sent when the item is resolved
+                doc = self._documentation(
+                    lambda r: (
+                        keyword_doc.argument_to_markdown(argument, link_resolver=r, reference_targets=targets) or ""
+                    ),
+                    lambda: target,
+                    keyword_doc.parent,
+                    heading=False,
+                )
+                if not doc:
+                    return None
+                cache_name = f"ARG{id(keyword_doc)}_{argument.name}"
+                self.parent.doc_cache[cache_name] = doc
+                return CompletionItemData(
+                    document_uri=str(self.document.uri),
+                    type=CompleteResultKind.DOC_CACHE.name,
+                    name=cache_name,
+                )
+
             result += [
                 CompletionItem(
                     label=f"{e.signature(False)}=",
@@ -2460,6 +2631,7 @@ class CompletionCollector(ModelHelper):
                     text_edit=TextEdit(range=completion_range, new_text=f"{e.name}="),
                     command=Command("", "editor.action.triggerSuggest", []),
                     preselect=True if i == preselected else None,
+                    data=documentation_data(e),
                 )
                 for i, e in enumerate(kw_arguments)
                 if e.name not in known_names