robotcode-language-server 0.92.0__tar.gz → 0.93.0__tar.gz

{robotcode_language_server-0.92.0 → robotcode_language_server-0.93.0}/.gitignore

@@ -282,6 +282,8 @@ playground/
 test-results
 results.html
 report.html
+log.html
+output.xml
 
 # pyenv
 .python-version

{robotcode_language_server-0.92.0 → robotcode_language_server-0.93.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: robotcode-language-server
-Version: 0.92.0
+Version: 0.93.0
 Summary: RobotCode Language Server for Robot Framework
 Project-URL: Homepage, https://robotcode.io
 Project-URL: Donate, https://opencollective.com/robotcode
@@ -25,10 +25,10 @@ Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: >=3.8
-Requires-Dist: robotcode-analyze==0.92.0
-Requires-Dist: robotcode-jsonrpc2==0.92.0
-Requires-Dist: robotcode-robot==0.92.0
-Requires-Dist: robotcode==0.92.0
+Requires-Dist: robotcode-analyze==0.93.0
+Requires-Dist: robotcode-jsonrpc2==0.93.0
+Requires-Dist: robotcode-robot==0.93.0
+Requires-Dist: robotcode==0.93.0
 Requires-Dist: robotframework>=4.1.0
 Description-Content-Type: text/markdown
 

{robotcode_language_server-0.92.0 → robotcode_language_server-0.93.0}/pyproject.toml

@@ -27,10 +27,10 @@ classifiers = [
 ]
 dependencies = [
   "robotframework>=4.1.0",
-  "robotcode-jsonrpc2==0.92.0",
-  "robotcode-robot==0.92.0",
-  "robotcode-analyze==0.92.0",
-  "robotcode==0.92.0",
+  "robotcode-jsonrpc2==0.93.0",
+  "robotcode-robot==0.93.0",
+  "robotcode-analyze==0.93.0",
+  "robotcode==0.93.0",
 ]
 dynamic = ["version"]
 

robotcode_language_server-0.93.0/src/robotcode/language_server/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.93.0"

{robotcode_language_server-0.92.0 → robotcode_language_server-0.93.0}/src/robotcode/language_server/cli.py

@@ -82,7 +82,13 @@ def language_server(
     profile: Optional[RobotBaseProfile] = None
     analysis_config: Optional[WorkspaceAnalysisConfig] = None
 
-    config_files, root_folder, _ = get_config_files(paths, app.config.config_files, verbose_callback=app.verbose)
+    config_files, root_folder, _ = get_config_files(
+        paths,
+        app.config.config_files,
+        root_folder=app.config.root,
+        no_vcs=app.config.no_vcs,
+        verbose_callback=app.verbose,
+    )
     if root_folder:
         os.chdir(root_folder)
 

{robotcode_language_server-0.92.0 → robotcode_language_server-0.93.0}/src/robotcode/language_server/common/parts/diagnostics.py

@@ -65,12 +65,6 @@ class DiagnosticsResult:
     skipped: bool = False
 
 
-@dataclass
-class WorkspaceDocumentsResult:
-    name: Optional[str]
-    document: TextDocument
-
-
 @dataclass
 class DiagnosticsData:
     lock: RLock
@@ -158,7 +152,7 @@ class DiagnosticsProtocolPart(LanguageServerProtocolPart):
     @event
     def load_workspace_documents(
         sender,
-    ) -> Optional[List[WorkspaceDocumentsResult]]: ...
+    ) -> None: ...
 
     @event
     def on_workspace_loaded(sender: Any) -> None: ...
@@ -362,72 +356,74 @@ class DiagnosticsProtocolPart(LanguageServerProtocolPart):
                     check_current_task_canceled(1)
                     continue
 
-                self._logger.debug(lambda: f"start collecting workspace diagnostics for {len(documents)} documents")
+                with self._logger.measure_time(
+                    lambda: f"analyzing workspace for {len(documents)} documents",
+                    context_name="workspace_diagnostics",
+                ):
 
-                self.on_workspace_diagnostics_analyze(self)
+                    self.on_workspace_diagnostics_analyze(self)
 
-                if self._break_diagnostics_loop_event.is_set():
-                    self._logger.debug("break workspace diagnostics loop 1")
-                    self.on_workspace_diagnostics_break(self)
-                    continue
+                    if self._break_diagnostics_loop_event.is_set():
+                        self._logger.debug("break workspace diagnostics loop 1", context_name="workspace_diagnostics")
+                        self.on_workspace_diagnostics_break(self)
+                        continue
 
-                start = time.monotonic()
-                with self.parent.window.progress(
-                    "Analyze Workspace",
-                    cancellable=False,
-                    current=0,
-                    max=len(documents),
-                    start=False,
-                ) as progress:
-                    for i, document in enumerate(documents):
-                        self._logger.debug(lambda: f"Analyze {document}")
-                        check_current_task_canceled()
+                    with self.parent.window.progress(
+                        "Analyze Workspace",
+                        cancellable=False,
+                        current=0,
+                        max=len(documents),
+                        start=False,
+                    ) as progress:
+                        for i, document in enumerate(documents):
+                            check_current_task_canceled()
+
+                            if self._break_diagnostics_loop_event.is_set():
+                                self._logger.debug(
+                                    "break workspace diagnostics loop 2", context_name="workspace_diagnostics"
+                                )
+                                self.on_workspace_diagnostics_break(self)
+                                break
 
-                        if self._break_diagnostics_loop_event.is_set():
-                            self._logger.debug("break workspace diagnostics loop 2")
-                            self.on_workspace_diagnostics_break(self)
-                            break
+                            done_something = True
 
-                        done_something = True
-
-                        analysis_mode = self.get_analysis_progress_mode(document.uri)
-
-                        if analysis_mode == AnalysisProgressMode.DETAILED:
-                            progress.begin()
-                            path = document.uri.to_path()
-                            folder = self.parent.workspace.get_workspace_folder(document.uri)
-                            name = path if folder is None else path.relative_to(folder.uri.to_path())
-
-                            progress.report(f"Analyze {i+1}/{len(documents)}: {name}", current=i + 1)
-                        elif analysis_mode == AnalysisProgressMode.SIMPLE:
-                            progress.begin()
-                            progress.report(f"Analyze {i+1}/{len(documents)}", current=i + 1)
-
-                        try:
-                            with self._current_diagnostics_task_lock:
-                                self._current_diagnostics_task = run_as_task(self._analyse_document, document)
-                            self._current_diagnostics_task.result(self._diagnostics_task_timeout)
-
-                        except CancelledError:
-                            self._logger.debug(lambda: f"Analyzing {document} cancelled")
-                        except BaseException as e:
-                            ex = e
-                            self._logger.exception(
-                                lambda: f"Error in analyzing ${document}: {ex}",
-                                exc_info=ex,
-                            )
-                        finally:
-                            with self._current_diagnostics_task_lock:
-                                self._current_diagnostics_task = None
+                            analysis_mode = self.get_analysis_progress_mode(document.uri)
 
-                self._logger.debug(
-                    lambda: f"Analyzing workspace for {len(documents)} " f"documents takes {time.monotonic() - start}s"
-                )
+                            if analysis_mode == AnalysisProgressMode.DETAILED:
+                                progress.begin()
+                                path = document.uri.to_path()
+                                folder = self.parent.workspace.get_workspace_folder(document.uri)
+                                name = path if folder is None else path.relative_to(folder.uri.to_path())
 
-                if self._break_diagnostics_loop_event.is_set():
-                    self._logger.debug("break workspace diagnostics loop 3")
-                    self.on_workspace_diagnostics_break(self)
-                    continue
+                                progress.report(f"Analyze {i+1}/{len(documents)}: {name}", current=i + 1)
+                            elif analysis_mode == AnalysisProgressMode.SIMPLE:
+                                progress.begin()
+                                progress.report(f"Analyze {i+1}/{len(documents)}", current=i + 1)
+
+                            try:
+                                with self._current_diagnostics_task_lock:
+                                    self._current_diagnostics_task = run_as_task(self._analyse_document, document)
+                                self._current_diagnostics_task.result(self._diagnostics_task_timeout)
+
+                            except CancelledError:
+                                self._logger.debug(
+                                    lambda: f"Analyzing {document.uri} cancelled", context_name="workspace_diagnostics"
+                                )
+                            except BaseException as e:
+                                ex = e
+                                self._logger.exception(
+                                    lambda: f"Error in analyzing ${document.uri}: {ex}",
+                                    exc_info=ex,
+                                    context_name="workspace_diagnostics",
+                                )
+                            finally:
+                                with self._current_diagnostics_task_lock:
+                                    self._current_diagnostics_task = None
+
+                    if self._break_diagnostics_loop_event.is_set():
+                        self._logger.debug("break workspace diagnostics loop 3", context_name="workspace_diagnostics")
+                        self.on_workspace_diagnostics_break(self)
+                        continue
 
                 self.on_workspace_diagnostics_collect(self)
 
@@ -437,78 +433,86 @@ class DiagnosticsProtocolPart(LanguageServerProtocolPart):
                     if doc.opened_in_editor or self.get_diagnostics_mode(document.uri) == DiagnosticsMode.WORKSPACE
                 ]
 
-                for document in set(documents) - set(documents_to_collect):
-                    check_current_task_canceled()
+                with self._logger.measure_time(
+                    lambda: f"collect workspace diagnostic for {len(documents_to_collect)} documents",
+                    context_name="collect_workspace_diagnostics",
+                ):
 
-                    if self._break_diagnostics_loop_event.is_set():
-                        self._logger.debug("break workspace diagnostics loop 4")
-                        self.on_workspace_diagnostics_break(self)
-                        break
-
-                    self.reset_document_diagnostics_data(document)
-
-                start = time.monotonic()
-                with self.parent.window.progress(
-                    "Collect Diagnostics",
-                    cancellable=False,
-                    current=0,
-                    max=len(documents_to_collect),
-                    start=False,
-                ) as progress:
-                    for i, document in enumerate(documents_to_collect):
-                        self._logger.debug(lambda: f"Collect diagnostics for {document}")
+                    for document in set(documents) - set(documents_to_collect):
                         check_current_task_canceled()
 
                         if self._break_diagnostics_loop_event.is_set():
-                            self._logger.debug("break workspace diagnostics loop 5")
+                            self._logger.debug("break workspace diagnostics loop 4")
                             self.on_workspace_diagnostics_break(self)
                             break
 
-                        mode = self.get_diagnostics_mode(document.uri)
-                        if mode == DiagnosticsMode.OFF:
-                            self.reset_document_diagnostics_data(document)
-                            continue
-
-                        done_something = True
-
-                        analysis_mode = self.get_analysis_progress_mode(document.uri)
-
-                        if analysis_mode == AnalysisProgressMode.DETAILED:
-                            progress.begin()
-                            path = document.uri.to_path()
-                            folder = self.parent.workspace.get_workspace_folder(document.uri)
-                            name = path if folder is None else path.relative_to(folder.uri.to_path())
-
-                            progress.report(f"Collect {i+1}/{len(documents_to_collect)}: {name}", current=i + 1)
-                        elif analysis_mode == AnalysisProgressMode.SIMPLE:
-                            progress.begin()
-                            progress.report(f"Collect {i+1}/{len(documents_to_collect)}", current=i + 1)
-
-                        try:
-                            with self._current_diagnostics_task_lock:
-                                self._current_diagnostics_task = self.create_document_diagnostics_task(
-                                    document,
-                                    False,
-                                    mode == DiagnosticsMode.WORKSPACE or document.opened_in_editor,
-                                )
-                            if self._current_diagnostics_task is not None:
-                                self._current_diagnostics_task.result(self._diagnostics_task_timeout)
-                        except CancelledError:
-                            self._logger.debug(lambda: f"Collecting diagnostics for {document} cancelled")
-                        except BaseException as e:
-                            ex = e
-                            self._logger.exception(
-                                lambda: f"Error getting diagnostics for ${document}: {ex}",
-                                exc_info=ex,
+                        self.reset_document_diagnostics_data(document)
+
+                    with self.parent.window.progress(
+                        "Collect Diagnostics",
+                        cancellable=False,
+                        current=0,
+                        max=len(documents_to_collect),
+                        start=False,
+                    ) as progress:
+                        for i, document in enumerate(documents_to_collect):
+                            self._logger.debug(
+                                lambda: f"collect diagnostics for {document.uri}",
+                                context_name="collect_workspace_diagnostics",
                             )
-                        finally:
-                            with self._current_diagnostics_task_lock:
-                                self._current_diagnostics_task = None
+                            check_current_task_canceled()
 
-                self._logger.debug(
-                    lambda: f"collecting workspace diagnostics for {len(documents_to_collect)} "
-                    f"documents takes {time.monotonic() - start}s"
-                )
+                            if self._break_diagnostics_loop_event.is_set():
+                                self._logger.debug(
+                                    "break workspace diagnostics loop 5", context_name="collect_workspace_diagnostics"
+                                )
+                                self.on_workspace_diagnostics_break(self)
+                                break
+
+                            mode = self.get_diagnostics_mode(document.uri)
+                            if mode == DiagnosticsMode.OFF:
+                                self.reset_document_diagnostics_data(document)
+                                continue
+
+                            done_something = True
+
+                            analysis_mode = self.get_analysis_progress_mode(document.uri)
+
+                            if analysis_mode == AnalysisProgressMode.DETAILED:
+                                progress.begin()
+                                path = document.uri.to_path()
+                                folder = self.parent.workspace.get_workspace_folder(document.uri)
+                                name = path if folder is None else path.relative_to(folder.uri.to_path())
+
+                                progress.report(f"Collect {i+1}/{len(documents_to_collect)}: {name}", current=i + 1)
+                            elif analysis_mode == AnalysisProgressMode.SIMPLE:
+                                progress.begin()
+                                progress.report(f"Collect {i+1}/{len(documents_to_collect)}", current=i + 1)
+
+                            try:
+                                with self._current_diagnostics_task_lock:
+                                    self._current_diagnostics_task = self.create_document_diagnostics_task(
+                                        document,
+                                        False,
+                                        mode == DiagnosticsMode.WORKSPACE or document.opened_in_editor,
+                                    )
+                                if self._current_diagnostics_task is not None:
+                                    self._current_diagnostics_task.result(self._diagnostics_task_timeout)
+                            except CancelledError:
+                                self._logger.debug(
+                                    lambda: f"Collecting diagnostics for {document.uri} cancelled",
+                                    context_name="collect_workspace_diagnostics",
+                                )
+                            except BaseException as e:
+                                ex = e
+                                self._logger.exception(
+                                    lambda: f"Error getting diagnostics for ${document.uri}: {ex}",
+                                    exc_info=ex,
+                                    context_name="collect_workspace_diagnostics",
+                                )
+                            finally:
+                                with self._current_diagnostics_task_lock:
+                                    self._current_diagnostics_task = None
 
             except (SystemExit, KeyboardInterrupt, CancelledError):
                 raise

{robotcode_language_server-0.92.0 → robotcode_language_server-0.93.0}/src/robotcode/language_server/robotframework/parts/hover.py

@@ -184,11 +184,19 @@ class RobotHoverProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
                 )
 
                 if found_range is not None:
-                    result.append((found_range, kw.to_markdown()))
+                    txt = kw.to_markdown()
+                    if kw.libtype == "RESOURCE":
+                        txt = namespace.imports_manager.replace_variables_scalar(
+                            txt,
+                            str(document.uri.to_path().parent),
+                            namespace.get_resolvable_variables(nodes, position),
+                        )
+                    result.append((found_range, txt))
             if result:
                 r = result[0][0]
                 if all(r == i[0] for i in result):
                     doc = "\n\n---\n\n".join(i[1] for i in result)
+
                     return Hover(
                         contents=MarkupContent(kind=MarkupKind.MARKDOWN, value=doc),
                         range=r,
@@ -233,6 +241,7 @@ class RobotHoverProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
         document: TextDocument,
         position: Position,
     ) -> Optional[Hover]:
+        namespace = self.parent.documents_cache.get_namespace(document)
         test_case = cast(TestCase, node)
 
         if not position.is_in_range(range_from_node(test_case.header)):
@@ -259,6 +268,11 @@ class RobotHoverProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
             txt += "\n*Tags*: "
             txt += f"{', '.join(tags.values)}\n"
 
+        txt = namespace.imports_manager.replace_variables_scalar(
+            txt,
+            str(document.uri.to_path().parent),
+            namespace.get_resolvable_variables(nodes, position),
+        )
         return Hover(
             contents=MarkupContent(kind=MarkupKind.MARKDOWN, value=MarkDownFormatter().format(txt)),
             range=range_from_token(name_token),

{robotcode_language_server-0.92.0 → robotcode_language_server-0.93.0}/src/robotcode/language_server/robotframework/parts/inlay_hint.py

@@ -329,8 +329,7 @@ class RobotInlayHintProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
 
         except (SystemExit, KeyboardInterrupt):
             raise
-        except BaseException as e:
-            self._logger.exception(e)
+        except BaseException:
             return None
 
         arguments = library_node.get_tokens(RobotToken.ARGUMENT)
@@ -373,8 +372,7 @@ class RobotInlayHintProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
 
         except (SystemExit, KeyboardInterrupt):
             raise
-        except BaseException as e:
-            self._logger.exception(e)
+        except BaseException:
             return None
 
         arguments = library_node.get_tokens(RobotToken.ARGUMENT)

robotcode_language_server-0.93.0/src/robotcode/language_server/robotframework/parts/robot_workspace.py

@@ -0,0 +1,128 @@
+from concurrent.futures import CancelledError
+from logging import CRITICAL
+from pathlib import Path
+from threading import Event
+from typing import TYPE_CHECKING, Any, List, Optional
+
+from robotcode.core.ignore_spec import DEFAULT_SPEC_RULES, GIT_IGNORE_FILE, ROBOT_IGNORE_FILE, IgnoreSpec, iter_files
+from robotcode.core.language import language_id
+from robotcode.core.uri import Uri
+from robotcode.core.utils.logging import LoggingDescriptor
+from robotcode.jsonrpc2.protocol import rpc_method
+from robotcode.language_server.common.parts.diagnostics import (
+    AnalysisProgressMode,
+    DiagnosticsMode,
+)
+from robotcode.language_server.robotframework.configuration import AnalysisConfig
+from robotcode.robot.diagnostics.library_doc import (
+    RESOURCE_FILE_EXTENSION,
+    ROBOT_FILE_EXTENSION,
+)
+
+from ..configuration import RobotCodeConfig
+
+if TYPE_CHECKING:
+    from ..protocol import RobotLanguageServerProtocol
+
+from .protocol_part import RobotLanguageServerProtocolPart
+
+
+class CantReadDocumentError(Exception):
+    pass
+
+
+class RobotWorkspaceProtocolPart(RobotLanguageServerProtocolPart):
+    _logger = LoggingDescriptor()
+
+    def __init__(self, parent: "RobotLanguageServerProtocol") -> None:
+        super().__init__(parent)
+        self.parent.documents.on_read_document_text.add(self.on_read_document_text)
+        self.parent.diagnostics.load_workspace_documents.add(self.load_workspace_documents)
+        self.parent.diagnostics.on_get_diagnostics_mode.add(self.on_get_diagnostics_mode)
+        self.parent.diagnostics.on_get_analysis_progress_mode.add(self.on_get_analysis_progress_mode)
+        self.documents_loaded = Event()
+
+    @language_id("robotframework")
+    def on_read_document_text(self, sender: Any, uri: Uri) -> Optional[str]:
+        from robot.utils import FileReader
+
+        with FileReader(uri.to_path()) as reader:
+            return str(reader.read())
+
+    def on_get_diagnostics_mode(self, sender: Any, uri: Uri) -> Optional[DiagnosticsMode]:
+        config = self.parent.workspace.get_configuration(AnalysisConfig, uri)
+        return config.diagnostic_mode
+
+    def on_get_analysis_progress_mode(self, sender: Any, uri: Uri) -> Optional[AnalysisProgressMode]:
+        config = self.parent.workspace.get_configuration(AnalysisConfig, uri)
+        return config.progress_mode
+
+    def load_workspace_documents(self, sender: Any) -> None:
+        with self._logger.measure_time(lambda: "loading workspace documents", context_name="load_workspace_documents"):
+            try:
+                result: List[Path] = []
+
+                for folder in self.parent.workspace.workspace_folders:
+                    config = self.parent.workspace.get_configuration(RobotCodeConfig, folder.uri)
+
+                    extensions = [ROBOT_FILE_EXTENSION, RESOURCE_FILE_EXTENSION]
+                    with self.parent.window.progress("Collect sources", cancellable=False):
+                        files = list(
+                            filter(
+                                lambda f: f.suffix in extensions,
+                                iter_files(
+                                    folder.uri.to_path(),
+                                    ignore_files=[ROBOT_IGNORE_FILE, GIT_IGNORE_FILE],
+                                    include_hidden=False,
+                                    parent_spec=IgnoreSpec.from_list(
+                                        [*DEFAULT_SPEC_RULES, *(config.workspace.exclude_patterns or [])],
+                                        folder.uri.to_path(),
+                                    ),
+                                    verbose_callback=self._logger.debug,
+                                    verbose_trace=False,
+                                ),
+                            )
+                        )
+
+                    result.extend(files)
+
+                    canceled = False
+                    with self.parent.window.progress(
+                        "Load workspace", current=0, max=len(files), start=False, cancellable=False
+                    ) as progress:
+                        for i, f in enumerate(files):
+                            try:
+                                self.parent.documents.get_or_open_document(f)
+
+                                if config.analysis.progress_mode != AnalysisProgressMode.OFF:
+                                    name = f.relative_to(folder.uri.to_path())
+
+                                    progress.begin()
+                                    progress.report(
+                                        (
+                                            f"Load {name!s}"
+                                            if config.analysis.progress_mode == AnalysisProgressMode.DETAILED
+                                            else None
+                                        ),
+                                        current=i,
+                                    )
+                            except (SystemExit, KeyboardInterrupt):
+                                raise
+                            except CancelledError:
+                                canceled = True
+                                break
+                            except BaseException as e:
+                                ex = e
+                                self._logger.exception(
+                                    lambda: f"Can't load document {f}: {ex}",
+                                    level=CRITICAL,
+                                    context_name="load_workspace_documents",
+                                )
+            finally:
+                if canceled:
+                    self._logger.info(lambda: "Workspace loading canceled")
+
+    @rpc_method(name="robot/cache/clear", threaded=True)
+    def robot_cache_clear(self) -> None:
+        for folder in self.parent.workspace.workspace_folders:
+            self.parent.documents_cache.get_imports_manager_for_workspace_folder(folder).clear_cache()

{robotcode_language_server-0.92.0 → robotcode_language_server-0.93.0}/src/robotcode/language_server/robotframework/parts/semantic_tokens.py

@@ -21,8 +21,10 @@ from typing import (
 )
 
 from robot.parsing.lexer.tokens import Token
+from robot.parsing.model.blocks import Section
 from robot.parsing.model.statements import (
     Arguments,
+    Documentation,
     Fixture,
     KeywordCall,
     LibraryImport,
@@ -62,6 +64,7 @@ from robotcode.robot.diagnostics.model_helper import ModelHelper
 from robotcode.robot.diagnostics.namespace import DEFAULT_BDD_PREFIXES, Namespace
 from robotcode.robot.utils import get_robot_version
 from robotcode.robot.utils.ast import (
+    cached_isinstance,
     iter_nodes,
     iter_over_keyword_names_and_owners,
     token_in_range,
@@ -72,6 +75,9 @@ from .protocol_part import RobotLanguageServerProtocolPart
 if get_robot_version() >= (5, 0):
     from robot.parsing.model.statements import ExceptHeader, WhileHeader
 
+if get_robot_version() >= (7, 0):
+    from robot.parsing.model.blocks import InvalidSection
+
 if TYPE_CHECKING:
     from ..protocol import RobotLanguageServerProtocol
 
@@ -120,6 +126,7 @@ class RobotSemTokenTypes(Enum):
 
 class RobotSemTokenModifiers(Enum):
     BUILTIN = "builtin"
+    EMBEDDED = "embedded"
 
 
 @dataclass
@@ -340,6 +347,7 @@ class RobotSemanticTokenProtocolPart(RobotLanguageServerProtocolPart):
         node: ast.AST,
         col_offset: Optional[int] = None,
         length: Optional[int] = None,
+        yield_arguments: bool = False,
     ) -> Iterator[SemTokenInfo]:
         sem_info = cls.mapping().get(token.type, None) if token.type is not None else None
         if sem_info is not None:
@@ -391,7 +399,7 @@ class RobotSemanticTokenProtocolPart(RobotLanguageServerProtocolPart):
                     yield SemTokenInfo.from_token(token, sem_type, sem_mod)
 
             elif token.type in [Token.KEYWORD, ROBOT_KEYWORD_INNER] or (
-                token.type == Token.NAME and isinstance(node, (Fixture, Template, TestTemplate))
+                token.type == Token.NAME and cached_isinstance(node, Fixture, Template, TestTemplate)
             ):
                 if (
                     namespace.find_keyword(
@@ -461,6 +469,9 @@ class RobotSemanticTokenProtocolPart(RobotLanguageServerProtocolPart):
 
                 kw_index = len(kw_namespace) + 1 if kw_namespace else 0
 
+                if token.type == Token.NAME and kw_doc is not None:
+                    sem_type = RobotSemTokenTypes.KEYWORD
+
                 if kw_namespace:
                     kw = token.value[kw_index:]
 
@@ -501,13 +512,25 @@ class RobotSemanticTokenProtocolPart(RobotLanguageServerProtocolPart):
                                 col_offset + kw_index + start,
                                 arg_start - start,
                             )
-                            yield SemTokenInfo.from_token(
-                                token,
-                                RobotSemTokenTypes.EMBEDDED_ARGUMENT,
-                                sem_mod,
-                                col_offset + kw_index + arg_start,
-                                arg_end - arg_start,
+
+                            embedded_token = Token(
+                                Token.ARGUMENT,
+                                token.value[arg_start:arg_end],
+                                token.lineno,
+                                token.col_offset + arg_start,
                             )
+
+                            for sub_token in ModelHelper.tokenize_variables(
+                                embedded_token,
+                                ignore_errors=True,
+                                identifiers="$@&%",
+                            ):
+                                for e in cls.generate_sem_sub_tokens(
+                                    namespace, builtin_library_doc, sub_token, node, yield_arguments=True
+                                ):
+                                    e.sem_modifiers = {RobotSemTokenModifiers.EMBEDDED}
+                                    yield e
+
                             start = arg_end + 1
 
                         if start < end:
@@ -521,7 +544,7 @@ class RobotSemanticTokenProtocolPart(RobotLanguageServerProtocolPart):
 
                 else:
                     yield SemTokenInfo.from_token(token, sem_type, sem_mod, col_offset + kw_index, len(kw))
-            elif token.type == Token.NAME and isinstance(node, (LibraryImport, ResourceImport, VariablesImport)):
+            elif token.type == Token.NAME and cached_isinstance(node, LibraryImport, ResourceImport, VariablesImport):
                 if "\\" in token.value:
                     if col_offset is None:
                         col_offset = token.col_offset
@@ -543,7 +566,9 @@ class RobotSemanticTokenProtocolPart(RobotLanguageServerProtocolPart):
                         length,
                     )
             elif get_robot_version() >= (5, 0) and token.type == Token.OPTION:
-                if (isinstance(node, ExceptHeader) or isinstance(node, WhileHeader)) and "=" in token.value:
+                if (
+                    cached_isinstance(node, ExceptHeader) or cached_isinstance(node, WhileHeader)
+                ) and "=" in token.value:
                     if col_offset is None:
                         col_offset = token.col_offset
 
@@ -589,7 +614,12 @@ class RobotSemanticTokenProtocolPart(RobotLanguageServerProtocolPart):
                     1,
                 )
             else:
-                if token.type != Token.ARGUMENT or token.type != Token.NAME and isinstance(node, Metadata):
+                if (
+                    yield_arguments
+                    or token.type != Token.ARGUMENT
+                    or token.type != Token.NAME
+                    and cached_isinstance(node, Metadata)
+                ):
                     yield SemTokenInfo.from_token(token, sem_type, sem_mod, col_offset, length)
 
     def generate_sem_tokens(
@@ -602,25 +632,25 @@ class RobotSemanticTokenProtocolPart(RobotLanguageServerProtocolPart):
         if (
             token.type in {Token.ARGUMENT, Token.TESTCASE_NAME, Token.KEYWORD_NAME}
             or token.type == Token.NAME
-            and isinstance(node, (VariablesImport, LibraryImport, ResourceImport))
+            and cached_isinstance(node, VariablesImport, LibraryImport, ResourceImport)
         ):
-            if (isinstance(node, Variable) and token.type == Token.ARGUMENT and node.name and node.name[0] == "&") or (
-                isinstance(node, Arguments)
-            ):
+            if (
+                cached_isinstance(node, Variable) and token.type == Token.ARGUMENT and node.name and node.name[0] == "&"
+            ) or (cached_isinstance(node, Arguments)):
                 name, value = split_from_equals(token.value)
                 if value is not None:
                     length = len(name)
 
                     yield SemTokenInfo.from_token(
                         Token(
-                            ROBOT_NAMED_ARGUMENT if isinstance(node, Variable) else SemanticTokenTypes.PARAMETER,
+                            ROBOT_NAMED_ARGUMENT if cached_isinstance(node, Variable) else SemanticTokenTypes.PARAMETER,
                             name,
                             token.lineno,
                             token.col_offset,
                         ),
                         (
                             RobotSemTokenTypes.NAMED_ARGUMENT
-                            if isinstance(node, Variable)
+                            if cached_isinstance(node, Variable)
                             else SemanticTokenTypes.PARAMETER
                         ),
                     )
@@ -640,7 +670,7 @@ class RobotSemanticTokenProtocolPart(RobotLanguageServerProtocolPart):
                         token.col_offset + length + 1,
                         token.error,
                     )
-                elif isinstance(node, Arguments) and name:
+                elif cached_isinstance(node, Arguments) and name:
                     yield SemTokenInfo.from_token(
                         Token(
                             ROBOT_NAMED_ARGUMENT,
@@ -663,11 +693,13 @@ class RobotSemanticTokenProtocolPart(RobotLanguageServerProtocolPart):
                 ignore_errors=True,
                 identifiers="$" if token.type == Token.KEYWORD_NAME else "$@&%",
             ):
-                for e in self.generate_sem_sub_tokens(namespace, builtin_library_doc, sub_token, node):
+                for e in self.generate_sem_sub_tokens(
+                    namespace, builtin_library_doc, sub_token, node, yield_arguments=True
+                ):
                     yield e
 
         else:
-            for e in self.generate_sem_sub_tokens(namespace, builtin_library_doc, token, node):
+            for e in self.generate_sem_sub_tokens(namespace, builtin_library_doc, token, node, yield_arguments=True):
                 yield e
 
     def generate_run_kw_tokens(
@@ -953,11 +985,19 @@ class RobotSemanticTokenProtocolPart(RobotLanguageServerProtocolPart):
         last_col = 0
 
         def get_tokens() -> Iterator[Tuple[Token, ast.AST]]:
+            current_section: Optional[Section] = None
+            in_invalid_section = False
+
             for node in iter_nodes(model):
+                if cached_isinstance(node, Section):
+                    current_section = node
+                    if get_robot_version() >= (7, 0):
+                        in_invalid_section = cached_isinstance(current_section, InvalidSection)
+
                 check_current_task_canceled()
 
-                if isinstance(node, Statement):
-                    if isinstance(node, LibraryImport) and node.name:
+                if cached_isinstance(node, Statement):
+                    if cached_isinstance(node, LibraryImport) and node.name:
                         lib_doc = namespace.get_imported_library_libdoc(node.name, node.args, node.alias)
                         kw_doc = lib_doc.inits.keywords[0] if lib_doc and lib_doc.inits else None
                         if lib_doc is not None:
@@ -1009,7 +1049,7 @@ class RobotSemanticTokenProtocolPart(RobotLanguageServerProtocolPart):
 
                                 yield token, node
                             continue
-                    if isinstance(node, VariablesImport) and node.name:
+                    if cached_isinstance(node, VariablesImport) and node.name:
                         lib_doc = namespace.get_imported_variables_libdoc(node.name, node.args)
                         kw_doc = lib_doc.inits.keywords[0] if lib_doc and lib_doc.inits else None
                         if lib_doc is not None:
@@ -1061,12 +1101,12 @@ class RobotSemanticTokenProtocolPart(RobotLanguageServerProtocolPart):
 
                                 yield token, node
                             continue
-                    if isinstance(node, (KeywordCall, Fixture)):
+                    if cached_isinstance(node, KeywordCall, Fixture):
                         kw_token = cast(
                             Token,
                             (
                                 node.get_token(Token.KEYWORD)
-                                if isinstance(node, KeywordCall)
+                                if cached_isinstance(node, KeywordCall)
                                 else node.get_token(Token.NAME)
                             ),
                         )
@@ -1109,8 +1149,16 @@ class RobotSemanticTokenProtocolPart(RobotLanguageServerProtocolPart):
                                     yield kw_res
 
                                 continue
+                    if cached_isinstance(node, Documentation):
+                        for token in node.tokens:
+                            if token.type == Token.ARGUMENT:
+                                continue
+                            yield token, node
+                        continue
 
                     for token in node.tokens:
+                        if not in_invalid_section and token.type == Token.COMMENT:
+                            continue
                         yield token, node
 
         lines = document.get_lines()
@@ -1136,6 +1184,7 @@ class RobotSemanticTokenProtocolPart(RobotLanguageServerProtocolPart):
                         ),
                     ),
                 )
+
                 token_col_offset = token_range.start.character
                 token_length = token_range.end.character - token_range.start.character
 

robotcode_language_server-0.92.0/src/robotcode/language_server/__version__.py

@@ -1 +0,0 @@
-__version__ = "0.92.0"

robotcode_language_server-0.92.0/src/robotcode/language_server/robotframework/parts/robot_workspace.py

@@ -1,125 +0,0 @@
-import time
-from concurrent.futures import CancelledError
-from logging import CRITICAL
-from threading import Event
-from typing import TYPE_CHECKING, Any, List, Optional
-
-from robotcode.core.ignore_spec import DEFAULT_SPEC_RULES, GIT_IGNORE_FILE, ROBOT_IGNORE_FILE, IgnoreSpec, iter_files
-from robotcode.core.language import language_id
-from robotcode.core.uri import Uri
-from robotcode.core.utils.logging import LoggingDescriptor
-from robotcode.jsonrpc2.protocol import rpc_method
-from robotcode.language_server.common.parts.diagnostics import (
-    AnalysisProgressMode,
-    DiagnosticsMode,
-    WorkspaceDocumentsResult,
-)
-from robotcode.language_server.robotframework.configuration import AnalysisConfig
-from robotcode.robot.diagnostics.library_doc import (
-    RESOURCE_FILE_EXTENSION,
-    ROBOT_FILE_EXTENSION,
-)
-
-from ..configuration import RobotCodeConfig
-
-if TYPE_CHECKING:
-    from ..protocol import RobotLanguageServerProtocol
-
-from .protocol_part import RobotLanguageServerProtocolPart
-
-
-class CantReadDocumentError(Exception):
-    pass
-
-
-class RobotWorkspaceProtocolPart(RobotLanguageServerProtocolPart):
-    _logger = LoggingDescriptor()
-
-    def __init__(self, parent: "RobotLanguageServerProtocol") -> None:
-        super().__init__(parent)
-        self.parent.documents.on_read_document_text.add(self.on_read_document_text)
-        self.parent.diagnostics.load_workspace_documents.add(self.load_workspace_documents)
-        self.parent.diagnostics.on_get_diagnostics_mode.add(self.on_get_diagnostics_mode)
-        self.parent.diagnostics.on_get_analysis_progress_mode.add(self.on_get_analysis_progress_mode)
-        self.documents_loaded = Event()
-
-    @language_id("robotframework")
-    def on_read_document_text(self, sender: Any, uri: Uri) -> Optional[str]:
-        from robot.utils import FileReader
-
-        with FileReader(uri.to_path()) as reader:
-            return str(reader.read())
-
-    def on_get_diagnostics_mode(self, sender: Any, uri: Uri) -> Optional[DiagnosticsMode]:
-        config = self.parent.workspace.get_configuration(AnalysisConfig, uri)
-        return config.diagnostic_mode
-
-    def on_get_analysis_progress_mode(self, sender: Any, uri: Uri) -> Optional[AnalysisProgressMode]:
-        config = self.parent.workspace.get_configuration(AnalysisConfig, uri)
-        return config.progress_mode
-
-    def load_workspace_documents(self, sender: Any) -> List[WorkspaceDocumentsResult]:
-        start = time.monotonic()
-        try:
-            result: List[WorkspaceDocumentsResult] = []
-
-            for folder in self.parent.workspace.workspace_folders:
-                config = self.parent.workspace.get_configuration(RobotCodeConfig, folder.uri)
-
-                extensions = [ROBOT_FILE_EXTENSION, RESOURCE_FILE_EXTENSION]
-                with self.parent.window.progress("Collect sources", cancellable=False):
-                    files = list(
-                        filter(
-                            lambda f: f.suffix in extensions,
-                            iter_files(
-                                folder.uri.to_path(),
-                                ignore_files=[ROBOT_IGNORE_FILE, GIT_IGNORE_FILE],
-                                include_hidden=False,
-                                parent_spec=IgnoreSpec.from_list(
-                                    [*DEFAULT_SPEC_RULES, *(config.workspace.exclude_patterns or [])],
-                                    folder.uri.to_path(),
-                                ),
-                            ),
-                        )
-                    )
-
-                canceled = False
-                with self.parent.window.progress(
-                    "Load workspace", current=0, max=len(files), start=False, cancellable=False
-                ) as progress:
-                    for i, f in enumerate(files):
-                        try:
-                            self.parent.documents.get_or_open_document(f)
-
-                            if config.analysis.progress_mode != AnalysisProgressMode.OFF:
-                                name = f.relative_to(folder.uri.to_path())
-
-                                progress.begin()
-                                progress.report(
-                                    (
-                                        f"Load {name!s}"
-                                        if config.analysis.progress_mode == AnalysisProgressMode.DETAILED
-                                        else None
-                                    ),
-                                    current=i,
-                                )
-                        except (SystemExit, KeyboardInterrupt):
-                            raise
-                        except CancelledError:
-                            canceled = True
-                            break
-                        except BaseException as e:
-                            ex = e
-                            self._logger.exception(lambda: f"Can't load document {f}: {ex}", level=CRITICAL)
-
-            if canceled:
-                return []
-
-            return result
-        finally:
-            self._logger.info(lambda: f"Workspace loaded {len(result)} documents in {time.monotonic() - start}s")
-
-    @rpc_method(name="robot/cache/clear", threaded=True)
-    def robot_cache_clear(self) -> None:
-        for folder in self.parent.workspace.workspace_folders:
-            self.parent.documents_cache.get_imports_manager_for_workspace_folder(folder).clear_cache()