robotcode-language-server 2.7.0__py3-none-any.whl → 2.8.0.dev8__py3-none-any.whl

robotcode/language_server/robotframework/parts/inline_value.py

@@ -1,5 +1,5 @@
 import ast
-from itertools import dropwhile, takewhile
+from itertools import chain, dropwhile, takewhile
 from typing import TYPE_CHECKING, Any, Iterator, List, Optional, Tuple
 
 from robot.parsing.lexer.tokens import Token
@@ -10,24 +10,33 @@ from robotcode.core.lsp.types import (
     InlineValue,
     InlineValueContext,
     InlineValueEvaluatableExpression,
+    Position,
     Range,
 )
 from robotcode.core.text_document import TextDocument
 from robotcode.core.utils.logging import LoggingDescriptor
 from robotcode.robot.diagnostics.model_helper import ModelHelper
+from robotcode.robot.diagnostics.semantic_analyzer.enums import NodeKind
+from robotcode.robot.diagnostics.semantic_analyzer.model import SemanticModel
+from robotcode.robot.diagnostics.semantic_analyzer.nodes import SemanticToken
 from robotcode.robot.utils.ast import (
     iter_nodes,
     range_from_node,
     range_from_token,
 )
 
+from .model_variables import (
+    iter_condition_ref_candidates,
+    iter_model_variable_candidates,
+    scannable_statement_tokens,
+)
 from .protocol_part import RobotLanguageServerProtocolPart
 
 if TYPE_CHECKING:
     from ..protocol import RobotLanguageServerProtocol
 
 
-class RobotInlineValueProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
+class RobotInlineValueProtocolPart(RobotLanguageServerProtocolPart):
     _logger = LoggingDescriptor()
 
     def __init__(self, parent: "RobotLanguageServerProtocol") -> None:
@@ -50,10 +59,14 @@ class RobotInlineValueProtocolPart(RobotLanguageServerProtocolPart, ModelHelper)
 
         namespace = self.parent.documents_cache.get_namespace(document)
 
-        model = self.parent.documents_cache.get_model(document)
-
         real_range = Range(range.start, min(range.end, context.stopped_location.end))
 
+        semantic_model = namespace.semantic_model
+        if semantic_model is not None:
+            return self._collect_from_model(semantic_model, real_range, context)
+
+        model = self.parent.documents_cache.get_model(document)
+
         def get_tokens() -> Iterator[Tuple[Token, ast.AST]]:
             for n in iter_nodes(model):
                 r = range_from_node(n)
@@ -71,15 +84,64 @@ class RobotInlineValueProtocolPart(RobotLanguageServerProtocolPart, ModelHelper)
                 get_tokens(),
             ),
         ):
-            if token.type == RobotToken.ARGUMENT and isinstance(node, self.get_expression_statement_types()):
-                for t, var in self.iter_expression_variables_from_token(
+            if token.type == RobotToken.ARGUMENT and isinstance(node, ModelHelper.get_expression_statement_types()):
+                for t, var in ModelHelper.iter_expression_variables_from_token(
                     token, namespace, context.stopped_location.start
                 ):
                     if var.name != "${CURDIR}":
                         result.append(InlineValueEvaluatableExpression(range_from_token(t), var.name))
 
-            for t, var in self.iter_variables_from_token(token, namespace, context.stopped_location.start):
+            for t, var in ModelHelper.iter_variables_from_token(token, namespace, context.stopped_location.start):
                 if var.name != "${CURDIR}":
                     result.append(InlineValueEvaluatableExpression(range_from_token(t), var.name))
 
         return result
+
+    def _collect_from_model(
+        self,
+        semantic_model: SemanticModel,
+        real_range: Range,
+        context: InlineValueContext,
+    ) -> List[InlineValue]:
+        """Model path: variable occurrences from the pre-built statement
+        tokens, resolved at the debugger's stopped location."""
+        resolve_line = context.stopped_location.start.line + 1
+        resolve_col = context.stopped_location.start.character
+
+        def get_model_tokens() -> Iterator[Tuple[NodeKind, SemanticToken]]:
+            for stmt in semantic_model.statements:
+                if not stmt.tokens:
+                    continue
+                first = stmt.tokens[0]
+                last = stmt.tokens[-1]
+                start = Position(line=first.line - 1, character=first.col_offset)
+                end = Position(line=last.line - 1, character=last.col_offset + last.length)
+                if start in real_range or end in real_range:
+                    for token in scannable_statement_tokens(stmt):
+                        yield stmt.kind, token
+                if start > real_range.end:
+                    break
+
+        result: List[InlineValue] = []
+        for stmt_kind, token in takewhile(
+            lambda t: t[1].line - 1 <= real_range.end.line,
+            dropwhile(
+                lambda t: Position(line=t[1].line - 1, character=t[1].col_offset) < real_range.start,
+                get_model_tokens(),
+            ),
+        ):
+            # Legacy per-token order: the condition cell's bare-`$var`
+            # expression refs first, then the regular variables.
+            for candidate in chain(
+                iter_condition_ref_candidates(token),
+                iter_model_variable_candidates(token, semantic_model, resolve_line, resolve_col, stmt_kind),
+            ):
+                if not candidate.primary:
+                    continue
+                # `extended=False`: the extended-syntax fallback is already
+                # encoded in the candidates' lookup names.
+                var = semantic_model.find_variable(candidate.lookup_name, resolve_line, resolve_col, extended=False)
+                if var is not None and var.name != "${CURDIR}":
+                    result.append(InlineValueEvaluatableExpression(candidate.range, var.name))
+
+        return result

robotcode/language_server/robotframework/parts/keywords_treeview.py

@@ -1,13 +1,18 @@
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, List, Optional
+from typing import TYPE_CHECKING, Any, Callable, List, Mapping, Optional, Tuple
 
 from robotcode.core.lsp.types import TextDocumentIdentifier
+from robotcode.core.text_document import TextDocument
 from robotcode.core.uri import Uri
 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.model_helper import ModelHelper
+from robotcode.robot.diagnostics.entities import LibraryEntry
+from robotcode.robot.diagnostics.library_doc import KeywordDoc, LibraryDoc
+from robotcode.robot.diagnostics.namespace import Namespace
+from robotcode.robot.utils.markdown_docs import LinkResolver, ReferenceTarget
 
+from .code_action_documentation import DocumentationTarget, keyword_reference_targets, link_documentation
 from .protocol_part import RobotLanguageServerProtocolPart
 
 if TYPE_CHECKING:
@@ -72,7 +77,7 @@ class GetDocumentationUrl(CamelSnakeMixin):
     keyword_id: Optional[str] = None
 
 
-class RobotKeywordsTreeViewPart(RobotLanguageServerProtocolPart, ModelHelper):
+class RobotKeywordsTreeViewPart(RobotLanguageServerProtocolPart):
     _logger = LoggingDescriptor()
 
     def __init__(self, parent: "RobotLanguageServerProtocol") -> None:
@@ -96,50 +101,117 @@ class RobotKeywordsTreeViewPart(RobotLanguageServerProtocolPart, ModelHelper):
         result = []
 
         for _k, v in namespace.libraries.items():
+            documentation, keywords = (
+                self._import_documentation(v, True, document, namespace) if not no_documentation else (None, None)
+            )
             result.append(
                 DocumentImport(
                     name=v.name,
                     alias=v.alias,
                     id=str(hash(v)),
                     type="library",
-                    documentation=v.library_doc.to_markdown(add_signature=False) if not no_documentation else None,
-                    keywords=[
-                        Keyword(
-                            l.name,
-                            str(hash(l)),
-                            l.parameter_signature(),
-                            l.to_markdown(add_signature=False) if not no_documentation else None,
-                        )
-                        for l in v.library_doc.keywords.values()
-                    ]
-                    if not no_documentation
-                    else None,
+                    documentation=documentation,
+                    keywords=keywords,
                 )
             )
         for _k, v in namespace.resources.items():
+            documentation, keywords = (
+                self._import_documentation(v, False, document, namespace) if not no_documentation else (None, None)
+            )
             result.append(
                 DocumentImport(
                     name=v.name,
                     alias=None,
                     id=str(hash(v)),
                     type="resource",
-                    documentation=v.library_doc.to_markdown(add_signature=False) if not no_documentation else None,
-                    keywords=[
-                        Keyword(
-                            l.name,
-                            str(hash(l)),
-                            l.parameter_signature(),
-                            l.to_markdown(add_signature=False) if not no_documentation else None,
-                        )
-                        for l in v.library_doc.keywords.values()
-                    ]
-                    if not no_documentation
-                    else None,
+                    documentation=documentation,
+                    keywords=keywords,
                 )
             )
 
         return result
 
+    @property
+    def _links(self) -> bool:
+        return self.parent.robot_initialization_options.documentation_viewer_links
+
+    def _import_documentation(
+        self, entry: LibraryEntry, is_library: bool, document: TextDocument, namespace: Namespace
+    ) -> Tuple[str, List[Keyword]]:
+        """The tooltips of an import and of its keywords."""
+        library_doc = entry.library_doc
+        target = (
+            self.parent.robot_code_action_documentation.entry_target(entry, is_library, document, namespace)
+            if self._links
+            else None
+        )
+        link_resolver = self._link_resolver(document, namespace, target, library_doc)
+        return (
+            self._documentation(
+                lambda link_resolver: library_doc.to_markdown(add_signature=False, link_resolver=link_resolver),
+                target,
+                link_resolver,
+            ),
+            self._keywords(list(library_doc.keywords.values()), target, link_resolver),
+        )
+
+    def _link_resolver(
+        self,
+        document: TextDocument,
+        namespace: Namespace,
+        target: Optional[DocumentationTarget],
+        library_doc: LibraryDoc,
+    ) -> Optional[LinkResolver]:
+        # one for the tooltips of an import and all of its keywords
+        if target is None:
+            return None
+        return self.parent.robot_code_action_documentation.link_resolver(document, namespace, target, library_doc)
+
+    def _keywords(
+        self,
+        keywords: List[KeywordDoc],
+        target: Optional[DocumentationTarget],
+        link_resolver: Optional[LinkResolver],
+    ) -> List[Keyword]:
+        """The keywords of a library, a resource file or the document with their tooltips."""
+        # once for all keywords, they share their library and its documentation format
+        targets = keyword_reference_targets(keywords[0], self._links) if keywords else None
+        return [self._keyword(kw, target, link_resolver, targets) for kw in keywords]
+
+    def _keyword(
+        self,
+        kw: KeywordDoc,
+        target: Optional[DocumentationTarget],
+        link_resolver: Optional[LinkResolver],
+        targets: Optional[Mapping[str, ReferenceTarget]],
+    ) -> Keyword:
+        return Keyword(
+            kw.name,
+            str(hash(kw)),
+            kw.parameter_signature(),
+            self._documentation(
+                lambda link_resolver: kw.to_markdown(
+                    add_signature=False, link_resolver=link_resolver, reference_targets=targets
+                ),
+                target,
+                link_resolver,
+                heading=False,
+            ),
+        )
+
+    def _documentation(
+        self,
+        render: Callable[[Optional[LinkResolver]], str],
+        target: Optional[DocumentationTarget],
+        link_resolver: Optional[LinkResolver],
+        *,
+        heading: bool = True,
+    ) -> str:
+        """A tooltip; with links, linked into the Documentation Viewer at the page of `target`."""
+        if not self._links:
+            return render(None)
+        return link_documentation(render, target, None, heading=heading, link_resolver=link_resolver)
+
     @rpc_method(name="robot/keywordsview/getDocumentKeywords", param_type=GetDocumentKeywordsParams, threaded=True)
     @_logger.call
     def _get_document_keywords(
@@ -155,31 +227,27 @@ class RobotKeywordsTreeViewPart(RobotLanguageServerProtocolPart, ModelHelper):
 
         namespace = self.parent.documents_cache.get_namespace(document)
 
-        return [
-            Keyword(
-                l.name,
-                str(hash(l)),
-                l.parameter_signature(),
-                l.to_markdown(add_signature=False) if not no_documentation else None,
-            )
-            for l in namespace.library_doc.keywords.values()
-        ]
+        keywords = list(namespace.library_doc.keywords.values())
+        if no_documentation:
+            return [Keyword(l.name, str(hash(l)), l.parameter_signature(), None) for l in keywords]
 
-    @rpc_method(name="robot/keywordsview/getDocumentationUrl", param_type=GetDocumentationUrl, threaded=True)
-    @_logger.call
-    def _get_documentation_url(
+        target = (
+            self.parent.robot_code_action_documentation.document_target(document, namespace) if self._links else None
+        )
+        return self._keywords(keywords, target, self._link_resolver(document, namespace, target, namespace.library_doc))
+
+    def _documentation_target(
         self,
         text_document: TextDocumentIdentifier,
-        import_id: Optional[str] = None,
-        keyword_id: Optional[str] = None,
-        *args: Any,
-        **kwargs: Any,
-    ) -> Optional[str]:
+        import_id: Optional[str],
+        keyword_id: Optional[str],
+    ) -> Optional[DocumentationTarget]:
         document = self.parent.documents.get(text_document.uri)
         if document is None:
             return None
 
         namespace = self.parent.documents_cache.get_namespace(document)
+        documentation = self.parent.robot_code_action_documentation
 
         keyword_name = None
 
@@ -189,25 +257,55 @@ class RobotKeywordsTreeViewPart(RobotLanguageServerProtocolPart, ModelHelper):
                 if keyword is not None:
                     keyword_name = keyword.name
 
-            return self.parent.robot_code_action_documentation.build_url(
-                str(document.uri.to_path().name), (), document, namespace, keyword_name
-            )
+            return documentation.document_target(document, namespace, keyword_name)
 
+        is_library = True
         entry = next((l for l in namespace.libraries.values() if str(hash(l)) == import_id), None)
         if entry is None:
+            is_library = False
             entry = next((l for l in namespace.resources.values() if str(hash(l)) == import_id), None)
 
-        if keyword_id and entry is not None:
+        if entry is None:
+            return None
+
+        if keyword_id:
             keyword = next((l for l in entry.library_doc.keywords.values() if str(hash(l)) == keyword_id), None)
             if keyword is not None:
                 keyword_name = keyword.name
 
-        if entry is not None:
-            return self.parent.robot_code_action_documentation.build_url(
-                entry.import_name, entry.args, document, namespace, keyword_name
-            )
+        return documentation.entry_target(entry, is_library, document, namespace, keyword_name)
+
+    @rpc_method(name="robot/keywordsview/getDocumentationTarget", param_type=GetDocumentationUrl, threaded=True)
+    @_logger.call
+    def _get_documentation_target(
+        self,
+        text_document: TextDocumentIdentifier,
+        import_id: Optional[str] = None,
+        keyword_id: Optional[str] = None,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Optional[DocumentationTarget]:
+        return self._documentation_target(text_document, import_id, keyword_id)
+
+    @rpc_method(name="robot/keywordsview/getDocumentationUrl", param_type=GetDocumentationUrl, threaded=True)
+    @_logger.call
+    def _get_documentation_url(
+        self,
+        text_document: TextDocumentIdentifier,
+        import_id: Optional[str] = None,
+        keyword_id: Optional[str] = None,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Optional[str]:
+        target = self._documentation_target(text_document, import_id, keyword_id)
+        if target is None:
+            return None
+
+        document = self.parent.documents.get(text_document.uri)
+        if document is None:
+            return None
 
-        return None
+        return self.parent.robot_code_action_documentation.build_url(target, document)
 
     @rpc_method(
         name="robot/keywordsview/getLibraryDocumentation", param_type=GetLibraryDocumentationParams, threaded=True