robotcode-robot 2.6.2__py3-none-any.whl → 2.8.0.dev548__py3-none-any.whl

robotcode/robot/diagnostics/data_cache.py

@@ -7,7 +7,7 @@ from contextlib import contextmanager
 from dataclasses import dataclass
 from enum import Enum
 from pathlib import Path
-from typing import Any, Callable, Generic, Iterator, List, Optional, Tuple, Type, TypeVar, Union
+from typing import Any, Callable, Generic, Iterable, Iterator, List, Optional, Tuple, Type, TypeVar, Union
 
 from robotcode.core.utils.logging import LoggingDescriptor
 
@@ -495,6 +495,17 @@ class SqliteDataCache:
             for r in rows
         ]
 
+    def remove_entries(self, section: CacheSection, entry_names: Iterable[str]) -> int:
+        """Remove the entries with these names from a section, and return how many of them there were."""
+        rows = [(name,) for name in entry_names]
+
+        def op() -> int:
+            cursor = self._conn.executemany(f"DELETE FROM {section.value} WHERE entry_name = ?", rows)
+            self._conn.commit()
+            return cursor.rowcount
+
+        return self._run(op)
+
     def clear_section(self, section: CacheSection) -> int:
         def op() -> int:
             cursor = self._conn.execute(f"DELETE FROM {section.value}")

robotcode/robot/diagnostics/diagnostic_rules.py

@@ -1,6 +1,14 @@
 """Shared diagnostic rule helpers."""
 
+import re
+from itertools import groupby
+from typing import List, Optional
+
+from robot.parsing.lexer.tokens import Token
+from robot.parsing.model.statements import Statement
+
 from .entities import VariableDefinition
+from .library_doc import KeywordDoc
 
 
 def is_variable_name_intentionally_unused(variable: VariableDefinition) -> bool:
@@ -10,3 +18,70 @@ def is_variable_name_intentionally_unused(variable: VariableDefinition) -> bool:
         and bool(variable.name_token.value)
         and variable.name_token.value.startswith("_")
     )
+
+
+def private_keyword_call_message(keyword: KeywordDoc, source: Optional[str]) -> Optional[str]:
+    """The `PrivateKeyword` message for a call of `keyword` in the file `source`, or `None` if the call is fine.
+
+    The file that contains the call decides, not the keyword that calls: Robot Framework also warns when
+    a test case calls a private keyword of its own suite file, which is robotframework/robotframework#5807.
+    """
+    if not keyword.is_private or keyword.source == source:
+        return None
+    if keyword.is_resource_keyword:
+        return f"Keyword '{keyword.longname}' is private and should only be called by keywords in the same file."
+    if keyword.is_library_keyword:
+        return f"Keyword '{keyword.longname}' is private and should not be called from Robot Framework files."
+    return None
+
+
+# The section headers of keyword documentation, as Robot Framework 7.5 recognizes them.
+_DOC_SECTION_HEADER = re.compile(
+    r"[*_]*(args|arguments|parameters|returns|return|yields|raises|raise|tags)[*_]*::?[*_]*(\s+.*)?",
+    re.IGNORECASE,
+)
+_TRAILING_BACKSLASH_OR_NEWLINE = re.compile(r"(\\+)n?$")
+
+
+def tags_line_without_empty_row(doc: str) -> Optional[int]:
+    """Index of the first `Tags:` line Robot Framework 7.5 warns about, or `None`.
+
+    Robot Framework accepts a section header only where a section may start:
+    on the first line, after an empty line and inside a named section
+    (`Args:`, `Returns:`, ...), whose indented and empty lines belong to it.
+    A `Tags:` header anywhere else is still used but deprecated.
+    """
+    in_named_section = False
+    can_start = True
+    for index, line in enumerate(doc.splitlines()):
+        header = _DOC_SECTION_HEADER.fullmatch(line)
+        if header and can_start:
+            in_named_section = True
+        elif header and header.group(1).lower() == "tags":
+            return index
+        elif in_named_section and line and not line[:2].isspace():
+            in_named_section = False
+        can_start = in_named_section or not line.strip()
+    return None
+
+
+def tags_row_without_empty_row(documentation: Statement) -> Optional[List[Token]]:
+    """The tokens of the `[Documentation]` row with a `Tags:` header Robot Framework warns about, or `None`."""
+    index = tags_line_without_empty_row(documentation.value)
+    if index is None:
+        return None
+
+    # `value` has one line per row, except that a row ending with a backslash or `\n` continues on the next row
+    line = 0
+    for _, row_tokens in groupby(documentation.get_tokens(Token.ARGUMENT), key=lambda t: t.lineno):
+        row = list(row_tokens)
+        if line == index:
+            return row
+        if not _has_trailing_backslash_or_newline(row[-1].value):
+            line += 1
+    return None
+
+
+def _has_trailing_backslash_or_newline(value: str) -> bool:
+    match = _TRAILING_BACKSLASH_OR_NEWLINE.search(value)
+    return bool(match and len(match.group(1)) % 2 == 1)

robotcode/robot/diagnostics/diagnostics_modifier.py

@@ -4,7 +4,7 @@ from ast import AST
 from collections import defaultdict
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import Dict, List, Optional, Set, Union
+from typing import Dict, List, Optional, Set, Tuple, Union
 
 from robot.parsing.lexer.tokens import Token
 from robot.parsing.model.blocks import Block, File
@@ -13,7 +13,8 @@ from robotcode.core.lsp.types import Diagnostic, DiagnosticSeverity
 
 from ..utils.visitor import Visitor
 
-ACTIONS = ["ignore", "error", "warn", "warning", "info", "information", "hint", "reset"]
+# The long names come before their short forms, the pattern takes the first alternative that matches.
+ACTIONS = ["ignore", "error", "warning", "warn", "information", "info", "hint", "reset"]
 
 ROBOTCODE_ACTION_AND_CODES_PATTERN = re.compile(rf"(?P<action>{'|'.join(ACTIONS)})(\[(?P<codes>[^\]]*?)\])?")
 
@@ -35,10 +36,22 @@ class ModifierAction(Enum):
         return cls(value)
 
 
+# How near a modifier is to the line it affects: an inline modifier at the end of the line, an indented comment in
+# a block, or a top-level comment of the file.
+_FILE_LEVEL = 0
+_BLOCK_LEVEL = 1
+_INLINE_LEVEL = 2
+
+# The rank of a modifier: its level, then the line of its comment, then its position in the comment. The higher rank
+# wins, also between a modifier for a code and one without a list (`*`).
+Rank = Tuple[int, int, int]
+
+
 @dataclass
 class RulesAndCodes:
     codes: Dict[Union[str, int], Set[int]]
     actions: Dict[int, Dict[Union[str, int], ModifierAction]]
+    ranks: Dict[int, Dict[Union[str, int], Rank]] = field(default_factory=lambda: defaultdict(dict))
 
 
 _translation_table = str.maketrans("", "", "_- ")
@@ -79,15 +92,19 @@ class ModifiersVisitor(Visitor):
         self.generic_visit(node)
 
     def visit_Block(self, node: Block) -> None:  # noqa: N802
+        # Restored afterwards, so that a modifier after a nested block (IF, FOR, ...) belongs to the outer block.
+        parent_block = self.current_block
         self.current_block = node
         self.generic_visit(node)
+        self.current_block = parent_block
 
     def visit_Statement(self, node: Statement) -> None:  # noqa: N802
         self._handle_statement_comments(node)
         self.generic_visit(node)
 
-    def _parse_robotcode_disabler(self, comment: str) -> Dict[ModifierAction, List[str]]:
-        result: Dict[ModifierAction, List[str]] = {}
+    def _parse_actions(self, comment: str) -> List[Tuple[ModifierAction, str]]:
+        """The actions of a modifier comment and their codes, in the order they are written."""
+        result: List[Tuple[ModifierAction, str]] = []
 
         comment = comment.strip()
         m = ROBOTCODE_ACTION_AND_CODES_PATTERN.match(comment)
@@ -98,17 +115,35 @@ class ModifiersVisitor(Visitor):
             action_str = m.group("action")
             action = ModifierAction.from_str(action_str)
             messages = m.group("codes")
-            result[action] = (
+            codes = (
                 [m.strip().translate(_translation_table).lower() for m in messages.split(",")]
                 if messages is not None
                 else ["*"]
             )
+            for code in codes:
+                # A code belongs to the rightmost action that names it, also when an action appears more than once.
+                result = [entry for entry in result if entry[1] != code]
+                result.append((action, code))
 
         return result
 
+    def _parse_robotcode_disabler(self, comment: str) -> Dict[ModifierAction, List[str]]:
+        result: Dict[ModifierAction, List[str]] = {}
+        for action, code in self._parse_actions(comment):
+            result.setdefault(action, []).append(code)
+        return result
+
+    def _add_rule(self, lineno: int, code: str, action: ModifierAction, rank: Rank) -> None:
+        self.rules_and_codes.codes[code].add(lineno)
+        current = self.rules_and_codes.ranks[lineno].get(code)
+        if current is None or rank >= current:
+            self.rules_and_codes.actions[lineno][code] = action
+            self.rules_and_codes.ranks[lineno][code] = rank
+
     def _handle_statement_comments(self, node: Statement) -> None:
         first_comment = True
         has_marker = False
+        position = 0
 
         for token in node.get_tokens(Token.COMMENT):
             value = token.value.strip()
@@ -127,15 +162,15 @@ class ModifiersVisitor(Visitor):
                 continue
 
             if has_marker:
-                actions = self._parse_robotcode_disabler(value)
+                actions = self._parse_actions(value)
 
                 if not actions:
                     break
 
-                for action, codes in actions.items():
-                    for code in codes:
-                        self.rules_and_codes.codes[code].add(token.lineno - 1)
-                        self.rules_and_codes.actions[token.lineno - 1][code] = action
+                lineno = token.lineno - 1
+                for action, code in actions:
+                    self._add_rule(lineno, code, action, (_INLINE_LEVEL, lineno, position))
+                    position += 1
 
     def _handle_comment(self, node: Comment) -> None:
         first_comment = True
@@ -143,9 +178,12 @@ class ModifiersVisitor(Visitor):
 
         start_lineno = node.lineno - 1
         end_lineno = self.file_end_lineno
+        level = _FILE_LEVEL
+        position = 0
 
         if node.tokens[0].type == Token.SEPARATOR and self.current_block is not None:
             end_lineno = self.current_block.end_lineno - 1
+            level = _BLOCK_LEVEL
         for token in node.get_tokens(Token.COMMENT):
             value = token.value.strip()
             if first_comment and value.startswith("#"):
@@ -163,16 +201,16 @@ class ModifiersVisitor(Visitor):
                 continue
 
             if has_marker:
-                actions = self._parse_robotcode_disabler(value)
+                actions = self._parse_actions(value)
 
                 if not actions:
                     break
 
-                for action, codes in actions.items():
-                    for code in codes:
-                        self.rules_and_codes.codes[code].update(range(start_lineno, end_lineno + 1))
-                        for i in range(start_lineno, end_lineno + 1):
-                            self.rules_and_codes.actions[i][code] = action
+                for action, code in actions:
+                    rank = (level, start_lineno, position)
+                    position += 1
+                    for i in range(start_lineno, end_lineno + 1):
+                        self._add_rule(i, code, action, rank)
 
 
 @dataclass
@@ -211,34 +249,25 @@ class DiagnosticsModifier:
                 else "unknowncode"
             )
 
-            lines = self.rules_and_codes.codes.get(code)
-
-            if lines is None or (lines is not None and diagnostic.range.start.line not in lines):
-                code = "*"
-                lines = self.rules_and_codes.codes.get(code)
-
             modified = False
-            if lines is not None and diagnostic.range.start.line in lines:
-                actions = self.rules_and_codes.actions.get(diagnostic.range.start.line)
-                if actions is not None:
-                    action = actions.get(code)
-                    if action is not None:
-                        if action == ModifierAction.IGNORE:
-                            return None
-                        if action == ModifierAction.RESET:
-                            pass
-                        elif action == ModifierAction.ERROR:
-                            modified = True
-                            diagnostic.severity = DiagnosticSeverity.ERROR
-                        elif action == ModifierAction.WARNING:
-                            modified = True
-                            diagnostic.severity = DiagnosticSeverity.WARNING
-                        elif action == ModifierAction.INFORMATION:
-                            modified = True
-                            diagnostic.severity = DiagnosticSeverity.INFORMATION
-                        elif action == ModifierAction.HINT:
-                            modified = True
-                            diagnostic.severity = DiagnosticSeverity.HINT
+            action = self._action_for(diagnostic.range.start.line, code)
+            if action is not None:
+                if action == ModifierAction.IGNORE:
+                    return None
+                if action == ModifierAction.RESET:
+                    pass
+                elif action == ModifierAction.ERROR:
+                    modified = True
+                    diagnostic.severity = DiagnosticSeverity.ERROR
+                elif action == ModifierAction.WARNING:
+                    modified = True
+                    diagnostic.severity = DiagnosticSeverity.WARNING
+                elif action == ModifierAction.INFORMATION:
+                    modified = True
+                    diagnostic.severity = DiagnosticSeverity.INFORMATION
+                elif action == ModifierAction.HINT:
+                    modified = True
+                    diagnostic.severity = DiagnosticSeverity.HINT
 
             if not modified:
                 if orig_code in self.config.ignore:
@@ -264,5 +293,16 @@ class DiagnosticsModifier:
 
         return diagnostic
 
+    def _action_for(self, line: int, code: str) -> Optional[ModifierAction]:
+        """The action of the nearest modifier on `line` for `code`: one that names the code, or one without a list."""
+        actions = self.rules_and_codes.actions.get(line)
+        if not actions:
+            return None
+        ranks = self.rules_and_codes.ranks.get(line, {})
+        keys = [key for key in (code, "*") if key in actions]
+        if not keys:
+            return None
+        return actions[max(keys, key=lambda key: ranks.get(key, (-1, -1, -1)))]
+
     def modify_diagnostics(self, diagnostics: List[Diagnostic]) -> List[Diagnostic]:
         return [d for d in map(self.modify_diagnostic, diagnostics) if d is not None]

robotcode/robot/diagnostics/document_cache_helper.py

@@ -8,6 +8,7 @@ from logging import CRITICAL
 from pathlib import Path
 from typing import (
     Any,
+    Dict,
     Iterable,
     Iterator,
     List,
@@ -24,6 +25,7 @@ from robotcode.core.filewatcher import FileWatcherManagerBase
 from robotcode.core.text_document import TextDocument
 from robotcode.core.uri import Uri
 from robotcode.core.utils.logging import LoggingDescriptor
+from robotcode.core.utils.path import DiskInfo, normalized_path
 from robotcode.core.workspace import Workspace, WorkspaceFolder
 from robotcode.robot.diagnostics.diagnostics_modifier import (
     DiagnosticModifiersConfig,
@@ -58,6 +60,23 @@ class UnknownFileTypeError(Exception):
     pass
 
 
+def _namespace_cache_key(source: str, document_type: Optional[DocumentType]) -> str:
+    """Disk-cache entry name for a namespace.
+
+    Includes the document type because the same file can be analyzed both as
+    a suite (GENERAL) and as an imported resource (RESOURCE) — the results
+    must not overwrite each other. "\\n" as separator is impossible in Windows
+    paths and never appears in real-world POSIX paths (where it is technically
+    legal); the key is parsed back only to tell the source of an entry.
+    """
+    return f"{source}\n{document_type.value if document_type is not None else ''}"
+
+
+def _namespace_cache_source(entry_name: str) -> str:
+    """The source of a namespace entry in the disk cache, see `_namespace_cache_key`."""
+    return entry_name.split("\n", 1)[0]
+
+
 class _CacheEntry:
     pass
 
@@ -108,15 +127,30 @@ class DocumentsCacheHelper:
 
         with self._project_indexes_lock:
             if folder not in self._project_indexes:
-                self._project_indexes[folder] = ProjectIndex()
+                self._project_indexes[folder] = self._create_project_index()
             return self._project_indexes[folder]
 
     def default_project_index(self) -> ProjectIndex:
         with self._project_indexes_lock:
             if self._default_project_index is None:
-                self._default_project_index = ProjectIndex()
+                self._default_project_index = self._create_project_index()
             return self._default_project_index
 
+    def _create_project_index(self) -> ProjectIndex:
+        documents_manager = self.documents_manager
+        # converting a path is most of the cost of a lookup, and the URI of a file does not change
+        uris: Dict[str, Uri] = {}
+
+        # only the files the documents manager still holds count; the check refers to the documents manager and
+        # not to this helper, which would make the helper and its indexes a reference cycle
+        def is_known_source(source: str) -> bool:
+            uri = uris.get(source)
+            if uri is None:
+                uri = uris[source] = Uri.from_path(source).normalized()
+            return documents_manager.get(uri) is not None
+
+        return ProjectIndex(is_known_source)
+
     def get_languages_for_document(self, document_or_uri: Union[TextDocument, Uri, str]) -> Optional[Languages]:
         if RF_VERSION < (6, 0):
             return None
@@ -405,9 +439,7 @@ class DocumentsCacheHelper:
     def namespace_invalidated(sender, namespace: Namespace) -> None: ...
 
     def _invalidate_namespace(self, sender: Namespace) -> None:
-        if sender.document is not None:
-            self.get_project_index(sender.document).remove_file(sender.source)
-
+        # the file's references stay in the index until its next analysis replaces them
         document = sender.document
         if document is not None:
             document.remove_cache_entry(self.__get_general_namespace)
@@ -438,11 +470,16 @@ class DocumentsCacheHelper:
         imports_manager = self.get_imports_manager(document)
         semantic_model_enabled = self._is_semantic_model_enabled(document)
 
+        # Capture the disk state before the model is parsed: this snapshot can
+        # only be older than the analyzed content, never newer, so anything
+        # persisted under it self-heals with a cache miss.
+        disk_info = document.disk_info
+
         # --- Try disk cache (cold-start acceleration) ---
         cache_namespaces = self.analysis_config.cache.cache_namespaces
-        if cache_namespaces and document.version is None:
+        if cache_namespaces and document.version is None and disk_info is not None:
             result = self._try_load_cached_namespace(
-                source, document, document_type, imports_manager, semantic_model_enabled
+                source, document, document_type, imports_manager, semantic_model_enabled, disk_info
             )
             if result is not None:
                 return result
@@ -457,6 +494,13 @@ class DocumentsCacheHelper:
         else:
             model = self.get_model(document)
 
+        # The document may have been re-read from disk while the model was
+        # parsed; the captured snapshot then no longer describes the parsed
+        # content and must not label anything written during the build (the
+        # builder writes RESOURCE cache entries under this snapshot).
+        if disk_info is not None and document.disk_info != disk_info:
+            disk_info = None
+
         languages, workspace_languages = self.build_languages_from_model(document, model)
         builder = NamespaceBuilder(
             imports_manager,
@@ -466,14 +510,20 @@ class DocumentsCacheHelper:
             document_type,
             languages,
             workspace_languages,
+            disk_info=disk_info,
         )
         builder.set_semantic_model_enabled(semantic_model_enabled)
 
         result = builder.build()
 
-        # Save to disk cache
-        if cache_namespaces:
-            self._save_namespace_to_cache(source, result, imports_manager, semantic_model_enabled)
+        # Save to disk cache — the re-checks in _namespace_is_cacheable catch
+        # a watcher re-read (disk_info) and a didOpen on another thread
+        # (version) that happened during the build.
+        if cache_namespaces and self._namespace_is_cacheable(document, disk_info):
+            assert disk_info is not None
+            self._save_namespace_to_cache(
+                source, document, document_type, result, imports_manager, disk_info, semantic_model_enabled
+            )
 
         # Update the folder-scoped reference index
         self.get_project_index(document).update_file(result.source, result)
@@ -491,6 +541,18 @@ class DocumentsCacheHelper:
         experimental_config = self.workspace.get_configuration(ExperimentalConfig, document.uri)
         return self.analysis_config.semantic_model or experimental_config.semantic_model
 
+    @staticmethod
+    def _namespace_is_cacheable(document: TextDocument, disk_info: Optional[DiskInfo]) -> bool:
+        """Whether a namespace built from this document may be persisted.
+
+        Only when the analyzed content is the on-disk state: not an editor
+        buffer (version), backed by a trusted snapshot, and the document still
+        holds exactly that snapshot.
+        """
+        return (
+            document.version is None and disk_info is not None and disk_info.trusted and document.disk_info == disk_info
+        )
+
     def _try_load_cached_namespace(
         self,
         source: str,
@@ -498,10 +560,14 @@ class DocumentsCacheHelper:
         document_type: Optional[DocumentType],
         imports_manager: ImportsManager,
         semantic_model_enabled: bool,
+        disk_info: DiskInfo,
     ) -> Optional[Namespace]:
         """Attempt to load a Namespace from the disk cache.
 
-        Returns None on cache miss or validation failure.
+        ``disk_info`` is the snapshot of the document content the namespace
+        will represent; the cached entry is validated against it, not against
+        the current disk state. Returns None on cache miss or validation
+        failure.
         """
         data_cache = imports_manager.data_cache
 
@@ -510,7 +576,9 @@ class DocumentsCacheHelper:
             return None
 
         try:
-            entry = data_cache.read_entry(CacheSection.NAMESPACE, source, NamespaceMetaData, NamespaceData)
+            entry = data_cache.read_entry(
+                CacheSection.NAMESPACE, _namespace_cache_key(source, document_type), NamespaceMetaData, NamespaceData
+            )
         except (SystemExit, KeyboardInterrupt):
             raise
         except BaseException as e:
@@ -536,7 +604,7 @@ class DocumentsCacheHelper:
             )
             return None
 
-        if not imports_manager.validate_namespace_meta(meta):
+        if not imports_manager.validate_namespace_meta(meta, disk_info):
             self._logger.debug(
                 lambda: f"Cache miss for {source}: cached entry is stale, re-analyzing",
                 context_name="cache",
@@ -585,22 +653,93 @@ class DocumentsCacheHelper:
 
         return result
 
+    def remove_cached_analysis(self, path: Path) -> None:
+        """Remove the entries of a Robot Framework file from the analysis cache, as for a file that was deleted."""
+        uri = Uri.from_path(path).normalized()
+        source = str(uri.to_path())
+        try:
+            imports_manager = self.get_imports_manager_for_uri(uri)
+            imports_manager.data_cache.remove_entries(
+                CacheSection.NAMESPACE, [_namespace_cache_key(source, document_type) for document_type in DocumentType]
+            )
+            imports_manager.remove_cached_resource_docs([str(normalized_path(source))])
+        except (SystemExit, KeyboardInterrupt):
+            raise
+        except BaseException as e:
+            ex = e
+            self._logger.debug(
+                lambda: f"Failed to remove the analysis cache entries of {source}: {ex}",
+                context_name="cache",
+            )
+
+    def remove_cached_analyses_of_missing_files(self, folder: WorkspaceFolder) -> None:
+        """Remove the entries of the files that do not exist from the analysis cache of a workspace folder."""
+        imports_manager = self.get_imports_manager_for_workspace_folder(folder)
+        data_cache = imports_manager.data_cache
+        try:
+            for section, source_of in (
+                (CacheSection.NAMESPACE, _namespace_cache_source),
+                (CacheSection.RESOURCE, str),
+            ):
+                missing = [
+                    entry.entry_name
+                    for entry in data_cache.list_entries(section)
+                    if not Path(source_of(entry.entry_name)).exists()
+                ]
+                if not missing:
+                    continue
+                if section == CacheSection.RESOURCE:
+                    imports_manager.remove_cached_resource_docs(missing)
+                else:
+                    data_cache.remove_entries(section, missing)
+        except (SystemExit, KeyboardInterrupt):
+            raise
+        except BaseException as e:
+            ex = e
+            self._logger.debug(
+                lambda: f"Failed to remove the cache entries of missing files: {ex}", context_name="cache"
+            )
+
     def _save_namespace_to_cache(
         self,
         source: str,
+        document: TextDocument,
+        document_type: Optional[DocumentType],
         namespace: Namespace,
         imports_manager: ImportsManager,
+        disk_info: DiskInfo,
         semantic_model_enabled: bool,
     ) -> None:
-        """Save a Namespace to the disk cache."""
+        """Save a Namespace to the disk cache.
+
+        ``disk_info`` must be the snapshot captured before the namespace was
+        built; the entry is skipped when the namespace's state is not fully
+        trustworthy or the document changed in the meantime.
+        """
         try:
             meta = imports_manager.build_namespace_meta(
-                source, namespace, semantic_model_enabled=semantic_model_enabled
+                source, namespace, disk_info, semantic_model_enabled=semantic_model_enabled
             )
+            if meta is None:
+                self._logger.debug(
+                    lambda: f"Skip caching namespace for {source}: state not trustworthy",
+                    context_name="cache",
+                )
+                return
+
             data = namespace.to_data()
 
+            # to_data() takes time — re-check that the document still holds
+            # exactly the content this namespace was built from.
+            if not self._namespace_is_cacheable(document, disk_info):
+                self._logger.debug(
+                    lambda: f"Skip caching namespace for {source}: document changed during save",
+                    context_name="cache",
+                )
+                return
+
             data_cache = imports_manager.data_cache
-            data_cache.save_entry(CacheSection.NAMESPACE, source, meta, data)
+            data_cache.save_entry(CacheSection.NAMESPACE, _namespace_cache_key(source, document_type), meta, data)
         except (SystemExit, KeyboardInterrupt):
             raise
         except BaseException as e:
@@ -707,7 +846,9 @@ class DocumentsCacheHelper:
     def calc_cache_path(self, folder_uri: Uri) -> Path:
         from .data_cache import resolve_cache_base_path
 
-        return resolve_cache_base_path(folder_uri.to_path())
+        folder = folder_uri.to_path()
+        cache_dir = self.analysis_config.cache_dir
+        return resolve_cache_base_path(folder / cache_dir if cache_dir else folder)
 
     def get_diagnostic_modifier(self, document: TextDocument) -> DiagnosticsModifier:
         return document.get_cache(self.__get_diagnostic_modifier)

robotcode/robot/diagnostics/errors.py

@@ -20,6 +20,12 @@ class Error:
     VARIABLES_ALREADY_IMPORTED = "VariablesAlreadyImported"
     LIBRARY_ALREADY_IMPORTED = "LibraryAlreadyImported"
     LIBRARY_OVERRIDES_BUILTIN = "LibraryOverridesBuiltIn"
+    LIBRARY_IMPORT_IGNORED = "LibraryImportIgnored"
+    LIBRARY_LOADED_WITHOUT_ARGUMENTS = "LibraryLoadedWithoutArguments"
+    LIBRARY_TIMEOUT_ERROR = "LibraryTimeoutError"
+    VARIABLES_TIMEOUT_ERROR = "VariablesTimeoutError"
+    LIBRARY_EXIT_ERROR = "LibraryExitError"
+    VARIABLES_EXIT_ERROR = "VariablesExitError"
     DEPRECATED_KEYWORD = "DeprecatedKeyword"
     KEYWORD_CONTAINS_ERRORS = "KeywordContainsErrors"
     RESERVED_KEYWORD = "ReservedKeyword"
@@ -32,6 +38,7 @@ class Error:
     DEPRECATED_HYPHEN_TAG = "DeprecatedHyphenTag"
     DEPRECATED_RETURN_SETTING = "DeprecatedReturnSetting"
     DEPRECATED_FORCE_TAG = "DeprecatedForceTag"
+    TAGS_WITHOUT_EMPTY_ROW = "TagsWithoutEmptyRow"
     IMPORT_REQUIRES_VALUE = "ImportRequiresValue"
     KEYWORD_ERROR = "KeywordError"
     MULTIPLE_KEYWORDS = "MultipleKeywords"