robotcode-robot 2.6.2__py3-none-any.whl → 2.7.0__py3-none-any.whl

robotcode/robot/__version__.py

@@ -1 +1 @@
-__version__ = "2.6.2"
+__version__ = "2.7.0"

robotcode/robot/config/model.py

@@ -2912,6 +2912,23 @@ class RobotBaseProfile(CommonOptions, CommonExtendOptions, RobotOptions, RobotEx
             """
     )
 
+    wrapper: Optional[List[Union[str, StringExpression]]] = field(
+        description="""\
+            Command prefix the test run is executed through (the actual
+            `robotcode` command line is appended to it), e.g. to bring up the
+            services, servers, mocks or session the tests need around them. For
+            plain environment variables use `env` instead. The selected
+            profile's `env` is applied first, so the wrapper can rely on it.
+
+            Examples:
+            ```toml
+            [profiles.integration]
+            wrapper = ["./with-test-services.sh"]
+            # or a ready-made tool, e.g. ["xvfb-run", "-a"] for headless UI tests
+            ```
+            """,
+    )
+
     rebot: Optional[RebotProfile] = field(
         description="""\
             Options to be passed to _rebot_.
@@ -2979,6 +2996,18 @@ class RobotExtendBaseProfile(RobotBaseProfile):
         alias="extend-env",
     )
 
+    extend_wrapper: Optional[List[Union[str, StringExpression]]] = field(
+        description="""\
+            Append extra entries to the `wrapper` command prefix.
+
+            Examples:
+            ```toml
+            extend-wrapper = ["--some-flag"]
+            ```
+            """,
+        alias="extend-wrapper",
+    )
+
     extend_paths: Union[str, List[str], None] = field(
         description="""\
             Append extra entries to the paths argument.

robotcode/robot/diagnostics/document_cache_helper.py

@@ -24,6 +24,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
 from robotcode.core.workspace import Workspace, WorkspaceFolder
 from robotcode.robot.diagnostics.diagnostics_modifier import (
     DiagnosticModifiersConfig,
@@ -58,6 +59,18 @@ 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 an opaque entry name and is never parsed back.
+    """
+    return f"{source}\n{document_type.value if document_type is not None else ''}"
+
+
 class _CacheEntry:
     pass
 
@@ -438,11 +451,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 +475,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 +491,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 +522,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 +541,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 +557,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 +585,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",
@@ -588,19 +637,43 @@ class DocumentsCacheHelper:
     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:

robotcode/robot/diagnostics/import_resolver.py

@@ -59,6 +59,12 @@ class ResolvedImports:
     resources: Dict[str, ResourceEntry] = field(default_factory=dict)
     variables_imports: Dict[str, VariablesEntry] = field(default_factory=dict)
 
+    # Metadata of each resolved dependency, captured together with its doc at
+    # resolve time (keys: "lib:{import_name}", "res:{source}", "var:{import_name}").
+    # A None value means the dependency was resolved but no trustworthy meta
+    # exists — namespaces built from it must not be persisted.
+    dependency_metas: Dict[str, Optional[Any]] = field(default_factory=dict)
+
 
 class ImportResolver:
     """Resolves all imports for a Robot Framework file.
@@ -78,6 +84,7 @@ class ImportResolver:
 
     __slots__ = (
         "_base_dir",
+        "_dependency_metas",
         "_diagnostics",
         "_import_entries",
         "_imports_manager",
@@ -115,6 +122,7 @@ class ImportResolver:
         self._variables: Dict[str, Any] = {}
         self._variables_dirty = True
         self._source_hints: Dict[str, str] = {}
+        self._dependency_metas: Dict[str, Optional[Any]] = {}
 
     def resolve(self, imports: Iterable[Import], *, source_hints: Optional[Dict[str, str]] = None) -> ResolvedImports:
         """Resolve all imports and return the result."""
@@ -129,6 +137,7 @@ class ImportResolver:
             variables_imports=self._variables_imports,
             import_entries=self._import_entries,
             diagnostics=self._diagnostics,
+            dependency_metas=self._dependency_metas,
         )
 
     # ------------------------------------------------------------------
@@ -186,13 +195,14 @@ class ImportResolver:
         ):
             for library in DEFAULT_LIBRARIES:
                 try:
-                    library_doc = self._imports_manager.get_libdoc_for_library_import(
+                    library_doc, meta = self._imports_manager.get_libdoc_for_library_import_with_meta(
                         library,
                         (),
                         base_dir=self._base_dir,
                         sentinel=None,
                         variables=self._variables,
                     )
+                    self._dependency_metas[f"lib:{library}"] = meta
                     entry = LibraryEntry(
                         name=library_doc.name,
                         import_name=library,
@@ -312,13 +322,14 @@ class ImportResolver:
     def _import_library(self, imp: LibraryImport, base_dir: str, *, top_level: bool) -> None:
         assert imp.name is not None
 
-        library_doc = self._imports_manager.get_libdoc_for_library_import(
+        library_doc, meta = self._imports_manager.get_libdoc_for_library_import_with_meta(
             imp.name,
             imp.args,
             base_dir=base_dir,
             sentinel=self._sentinel,
             variables=self._variables,
         )
+        self._dependency_metas[f"lib:{imp.name}"] = meta
         entry = LibraryEntry(
             name=library_doc.name,
             import_name=imp.name,
@@ -407,13 +418,17 @@ class ImportResolver:
             if hint is not None and os.path.isfile(hint):
                 source_hint = hint
 
-        resource_doc = self._imports_manager.get_resource_doc_for_resource_import(
+        resource_doc, meta = self._imports_manager.get_resource_doc_for_resource_import_with_meta(
             imp.name,
             base_dir,
             sentinel=self._sentinel,
             variables=self._variables,
             source=source_hint,
         )
+        if resource_doc.source is not None:
+            # setdefault: on re-imports of the same resource the meta captured
+            # with the first (analyzed) doc wins.
+            self._dependency_metas.setdefault(f"res:{resource_doc.source}", meta)
         entry = ResourceEntry(
             name=resource_doc.name,
             import_name=imp.name,
@@ -535,13 +550,14 @@ class ImportResolver:
     def _import_variables(self, imp: VariablesImport, base_dir: str, *, top_level: bool) -> None:
         assert imp.name is not None
 
-        library_doc = self._imports_manager.get_libdoc_for_variables_import(
+        library_doc, meta = self._imports_manager.get_libdoc_for_variables_import_with_meta(
             imp.name,
             imp.args,
             base_dir=base_dir,
             sentinel=self._sentinel,
             variables=self._variables,
         )
+        self._dependency_metas[f"var:{imp.name}"] = meta
         entry = VariablesEntry(
             name=library_doc.name,
             import_name=imp.name,

robotcode/robot/diagnostics/imports_manager.py

@@ -2,6 +2,7 @@ import ast
 import multiprocessing as mp
 import os
 import threading
+import time
 import weakref
 from abc import ABC, abstractmethod
 from concurrent.futures import ProcessPoolExecutor, TimeoutError
@@ -42,7 +43,13 @@ from robotcode.core.uri import Uri
 from robotcode.core.utils.caching import SimpleLRUCache
 from robotcode.core.utils.glob_path import Pattern
 from robotcode.core.utils.logging import LoggingDescriptor
-from robotcode.core.utils.path import normalized_path, path_is_relative_to
+from robotcode.core.utils.path import (
+    DiskInfo,
+    disk_info_from_stat,
+    normalized_path,
+    path_is_relative_to,
+    probe_disk_info,
+)
 
 from ..__version__ import __version__
 from ..utils import RF_VERSION
@@ -272,14 +279,23 @@ class _LibrariesEntry(_ImportEntry):
         with self._lock:
             return self._lib_doc is not None
 
-    def get_libdoc(self) -> LibraryDoc:
+    def get_libdoc_with_meta(self) -> Tuple[LibraryDoc, Optional["LibraryMetaData"]]:
+        """Return the LibraryDoc together with the meta of the state it was built from.
+
+        Doc and meta are taken under the entry lock so they always belong to
+        the same state — reading ``get_libdoc()`` and ``meta`` separately can
+        interleave with an invalidation and pair a doc with a newer meta.
+        """
         with self._lock:
             if self._lib_doc is None:
                 self._update()
 
             assert self._lib_doc is not None
 
-            return self._lib_doc
+            return self._lib_doc, self._meta
+
+    def get_libdoc(self) -> LibraryDoc:
+        return self.get_libdoc_with_meta()[0]
 
 
 @dataclass(frozen=True, slots=True)
@@ -343,7 +359,11 @@ class _ResourcesEntry(_ImportEntry):
             )
 
         self._document = self.parent.documents_manager.get_or_open_document(self.source_path)
-        self._meta = ImportsManager.get_resource_meta(str(self.source_path))
+        # Bind the meta to the document's disk state instead of a fresh stat, so
+        # it describes exactly the content this entry's ResourceDoc is built
+        # from. A dirty/editor-open document yields no meta — its state must
+        # never be persisted.
+        self._meta = RobotFileMeta.from_document(self._document)
 
         if self._document._version is None:
             self.file_watchers.append(
@@ -390,15 +410,21 @@ class _ResourcesEntry(_ImportEntry):
     def _get_namespace(self) -> "Namespace":
         return self.parent.get_namespace_for_resource(self._get_document())
 
-    def get_resource_doc(self) -> ResourceDoc:
+    def get_resource_doc_with_meta(self) -> Tuple[ResourceDoc, Optional["RobotFileMeta"]]:
+        """Return the ResourceDoc together with the meta of the content it was built from.
+
+        Doc and meta are taken under the entry lock so they always belong to
+        the same state — reading ``get_libdoc()`` and ``meta`` separately can
+        interleave with an invalidation and pair a doc with a newer meta.
+        """
         with self._lock:
             if self._lib_doc is None:
                 self._lib_doc = self.parent.get_resource_doc_from_document(self._get_document())
 
-            return self._lib_doc
+            return self._lib_doc, self._meta
 
     def get_libdoc(self) -> ResourceDoc:
-        return self.get_resource_doc()
+        return self.get_resource_doc_with_meta()[0]
 
 
 @dataclass(frozen=True, slots=True)
@@ -495,14 +521,22 @@ class _VariablesEntry(_ImportEntry):
         with self._lock:
             return self._lib_doc is not None
 
-    def get_libdoc(self) -> VariablesDoc:
+    def get_libdoc_with_meta(self) -> Tuple[VariablesDoc, Optional["LibraryMetaData"]]:
+        """Return the VariablesDoc together with the meta of the state it was built from.
+
+        Doc and meta are taken under the entry lock so they always belong to
+        the same state (see ``_LibrariesEntry.get_libdoc_with_meta``).
+        """
         with self._lock:
             if self._lib_doc is None:
                 self._update()
 
             assert self._lib_doc is not None
 
-            return self._lib_doc
+            return self._lib_doc, self._meta
+
+    def get_libdoc(self) -> VariablesDoc:
+        return self.get_libdoc_with_meta()[0]
 
 
 @dataclass(slots=True)
@@ -513,7 +547,7 @@ class LibraryMetaData:
     submodule_search_locations: Optional[List[str]]
     by_path: bool
 
-    mtimes: Optional[Dict[str, int]] = None
+    file_infos: Optional[Dict[str, DiskInfo]] = None
 
     has_errors: bool = False
 
@@ -528,16 +562,34 @@ class LibraryMetaData:
 
         raise ValueError("Cannot determine cache key.")
 
+    @property
+    def trusted(self) -> bool:
+        return self.file_infos is None or all(info.trusted for info in self.file_infos.values())
+
+
+def _stat_library_file(path: str) -> os.stat_result:
+    # Follow symlinks so target changes behind an unchanged link are detected
+    # (editable installs); for a broken link fall back to the link's own state
+    # so a single dangling .py file doesn't make the whole library uncacheable.
+    try:
+        return os.stat(path)
+    except OSError:
+        return os.stat(path, follow_symlinks=False)
 
-def _collect_library_mtimes(
+
+def _collect_library_file_infos(
     origin: Optional[str],
     submodule_search_locations: Optional[List[str]],
-) -> Optional[Dict[str, int]]:
-    """Collect mtimes from origin and submodule_search_locations."""
-    mtimes: Dict[str, int] = {}
+) -> Optional[Dict[str, DiskInfo]]:
+    """Collect DiskInfo snapshots from origin and submodule_search_locations."""
+    file_infos: Dict[str, DiskInfo] = {}
+
+    # one capture moment for the whole collection, so all snapshots share the
+    # same racy-mtime reference point
+    now_ns = time.time_ns()
 
     if origin is not None:
-        mtimes[origin] = os.stat(origin, follow_symlinks=False).st_mtime_ns
+        file_infos[origin] = disk_info_from_stat(_stat_library_file(origin), now_ns)
 
     if submodule_search_locations:
         for loc in submodule_search_locations:
@@ -545,9 +597,9 @@ def _collect_library_mtimes(
                 for filename in filenames:
                     if filename.endswith(".py"):
                         filepath = os.path.join(dirpath, filename)
-                        mtimes[filepath] = os.stat(filepath, follow_symlinks=False).st_mtime_ns
+                        file_infos[filepath] = disk_info_from_stat(_stat_library_file(filepath), now_ns)
 
-    return mtimes or None
+    return file_infos or None
 
 
 def _matches_any_pattern(
@@ -564,7 +616,23 @@ def _matches_any_pattern(
 @dataclass(slots=True)
 class RobotFileMeta:
     source: str
-    mtime_ns: int
+    info: DiskInfo
+
+    @property
+    def trusted(self) -> bool:
+        return self.info.trusted
+
+    @classmethod
+    def from_document(cls, document: TextDocument) -> Optional["RobotFileMeta"]:
+        """Meta describing exactly the disk state the document's text was read from.
+
+        ``None`` when the document has no disk info, i.e. its text is not known
+        to match any on-disk state (editor buffer, read race).
+        """
+        info = document.disk_info
+        if info is None:
+            return None
+        return cls(str(normalized_path(document.uri.to_path())), info)
 
 
 @dataclass(slots=True)
@@ -576,7 +644,7 @@ class NamespaceMetaData:
     """
 
     source: str
-    source_mtime_ns: int
+    source_info: DiskInfo
     config_fingerprint: Any
     dependency_fingerprints: Dict[str, Any] = field(default_factory=dict)
     semantic_model_enabled: bool = False
@@ -761,101 +829,76 @@ class ImportsManager:
         """
         return self._config_fingerprint
 
-    def compute_dependency_fingerprints(self, namespace: "Namespace") -> Dict[str, Any]:
-        """Collect current metadata for all dependencies of a namespace.
-
-        Each value is the metadata object itself (LibraryMetaData, RobotFileMeta,
-        or an mtime int). Changes are detected via direct ``==`` comparison
-        against the saved metadata — no hashing needed.
+    @staticmethod
+    def _is_dependency_meta_trusted(value: Any) -> bool:
+        # fail closed: a meta type this dispatch does not know must never be
+        # persisted — silently treating it as trusted is the exact failure
+        # class the freshness system exists to prevent
+        return isinstance(value, (RobotFileMeta, LibraryMetaData)) and value.trusted
 
-        Uses already-cached metadata from the internal import cache to avoid
-        expensive module resolution (find_library / get_module_spec).
-        Falls back to the full get_*_meta methods when no cached entry exists.
+    def build_namespace_meta(
+        self,
+        source: str,
+        namespace: "Namespace",
+        disk_info: DiskInfo,
+        *,
+        semantic_model_enabled: bool = False,
+    ) -> Optional[NamespaceMetaData]:
+        """Build a NamespaceMetaData for the given namespace and its dependencies.
+
+        ``disk_info`` must be the snapshot of the content the namespace was
+        built from; the dependency fingerprints are the metas recorded during
+        import resolution. Returns ``None`` when any of that state is missing
+        or untrusted — such a namespace must not be persisted, because its
+        fingerprints could describe newer file states than the analyzed
+        content and would validate as fresh forever.
         """
-        fingerprints: Dict[str, Any] = {}
-
-        for entry in namespace.libraries.values():
-            try:
-                lib_meta = self.get_cached_library_meta(entry.import_name, entry.args)
-                if lib_meta is None:
-                    lib_meta, _, _ = self.get_library_meta(entry.import_name)
-                if lib_meta is not None:
-                    fingerprints[f"lib:{entry.import_name}"] = lib_meta
-            except (SystemExit, KeyboardInterrupt):
-                raise
-            except BaseException:
-                pass
-
-        for entry in namespace.resources.values():
-            source = entry.library_doc.source
-            if source:
-                try:
-                    res_meta = self.get_cached_resource_meta(source)
-                    if res_meta is None:
-                        res_meta = self.get_resource_meta(source)
-                    if res_meta is not None:
-                        fingerprints[f"res:{source}"] = res_meta
-                    else:
-                        mtime = os.stat(source, follow_symlinks=False).st_mtime_ns
-                        fingerprints[f"res:{source}"] = mtime
-                except OSError:
-                    pass
-
-        for entry in namespace.variables_imports.values():
-            try:
-                var_meta = self.get_cached_variables_meta(entry.import_name, entry.args)
-                if var_meta is None:
-                    var_meta, _ = self.get_variables_meta(entry.import_name)
-                if var_meta is not None:
-                    fingerprints[f"var:{entry.import_name}"] = var_meta
-            except (SystemExit, KeyboardInterrupt):
-                raise
-            except BaseException:
-                pass
+        if not disk_info.trusted:
+            return None
 
-        return fingerprints
+        dependency_metas = namespace.dependency_metas
+        if dependency_metas is None:
+            return None
 
-    def build_namespace_meta(
-        self, source: str, namespace: "Namespace", *, semantic_model_enabled: bool = False
-    ) -> NamespaceMetaData:
-        """Build a NamespaceMetaData for the given namespace and its dependencies."""
-        try:
-            source_mtime_ns = os.stat(source, follow_symlinks=False).st_mtime_ns
-        except OSError:
-            source_mtime_ns = 0
+        for value in dependency_metas.values():
+            if value is None or not self._is_dependency_meta_trusted(value):
+                return None
 
         return NamespaceMetaData(
             source=source,
-            source_mtime_ns=source_mtime_ns,
+            source_info=disk_info,
             config_fingerprint=self.config_fingerprint,
-            dependency_fingerprints=self.compute_dependency_fingerprints(namespace),
+            dependency_fingerprints=dict(dependency_metas),
             semantic_model_enabled=semantic_model_enabled,
         )
 
-    def validate_namespace_meta(self, meta: NamespaceMetaData) -> bool:
-        """Check whether a cached NamespaceMetaData is still fresh.
+    def validate_namespace_meta(self, meta: NamespaceMetaData, source_disk_info: Optional[DiskInfo]) -> bool:
+        """Check whether a cached NamespaceMetaData is fresh for the given content.
 
         Performs a 2-level validation:
-        Level 1 (fast): source_mtime_ns, config_fingerprint
+        Level 1 (fast): source_disk_info, config_fingerprint
         Level 2 (dependency check): each dependency fingerprint
+
+        Validation is against the *effective* content: the source is compared
+        to the snapshot of the document the namespace would represent, and
+        resource dependencies are checked document-first — a dirty editor
+        buffer fails validation so the namespace is rebuilt against the buffer
+        instead of being served from disk state.
         """
         source = meta.source
 
         # Level 1: fast checks
-        try:
-            current_mtime = os.stat(source, follow_symlinks=False).st_mtime_ns
-        except OSError:
+        if source_disk_info is None:
             self._logger.debug(
-                lambda: f"Cache miss for {source}: source file no longer exists",
+                lambda: f"Cache miss for {source}: source has no trustworthy disk state",
                 context_name="cache",
             )
             return False
 
-        if meta.source_mtime_ns != current_mtime:
+        if meta.source_info != source_disk_info:
             self._logger.debug(
                 lambda: (
-                    f"Cache miss for {source}: source mtime changed"
-                    f" (cached={meta.source_mtime_ns}, current={current_mtime})"
+                    f"Cache miss for {source}: source changed (cached={meta.source_info}, current={source_disk_info})"
                 ),
                 context_name="cache",
             )
@@ -874,7 +917,7 @@ class ImportsManager:
             if key.startswith("lib:"):
                 lib_name = key[4:]
                 try:
-                    lib_meta = self.get_cached_library_meta(lib_name)
+                    lib_meta = self.get_cached_library_meta(lib_name, args=None)
                     if lib_meta is None:
                         lib_meta, _, _ = self.get_library_meta(lib_name, base_dir=base_dir)
                     if lib_meta is None or lib_meta != saved_value:
@@ -898,8 +941,15 @@ class ImportsManager:
             elif key.startswith("res:"):
                 res_source = key[4:]
                 try:
-                    res_meta = self.get_cached_resource_meta(res_source)
-                    if res_meta is None:
+                    # Document-first: an open document is the effective content
+                    # of this dependency. A dirty buffer (no disk snapshot)
+                    # must fail validation so dependents are rebuilt against
+                    # the buffer instead of being served from cached disk
+                    # state. Only unopened resources are probed on disk.
+                    res_document = self.documents_manager.get(Uri.from_path(res_source))
+                    if res_document is not None:
+                        res_meta = RobotFileMeta.from_document(res_document)
+                    else:
                         res_meta = self.get_resource_meta(res_source)
                     if res_meta is None or res_meta != saved_value:
                         self._logger.debug(
@@ -922,7 +972,7 @@ class ImportsManager:
             elif key.startswith("var:"):
                 var_name = key[4:]
                 try:
-                    var_meta = self.get_cached_variables_meta(var_name)
+                    var_meta = self.get_cached_variables_meta(var_name, args=None)
                     if var_meta is None:
                         var_meta, _ = self.get_variables_meta(var_name, base_dir=base_dir)
                     if var_meta is None or var_meta != saved_value:
@@ -952,13 +1002,24 @@ class ImportsManager:
     def get_resource_doc_from_document(self, document: TextDocument) -> ResourceDoc:
         source = str(document.uri.to_path())
 
-        if not self._is_document_loaded(source):
-            cached, _meta = self._get_model_doc_cached(source)
+        # Capture the meta before parsing, so it can only be older than the
+        # parsed content, never newer (stale metas cause a harmless cache
+        # miss, newer ones would poison the cache).
+        meta = RobotFileMeta.from_document(document)
+
+        if meta is not None and meta.trusted:
+            cached = self._get_model_doc_cached(source, meta)
             if cached is not None:
                 return cached
 
         model = self.document_cache_helper.get_resource_model(document)
-        return self.get_libdoc_from_model(model, source)
+
+        # The document may have been re-read from disk while parsing; in that
+        # case the model does not necessarily belong to the captured meta.
+        if meta is not None and document.disk_info != meta.info:
+            meta = None
+
+        return self.get_libdoc_from_model(model, source, meta)
 
     def clear_cache(self) -> None:
         count = self.data_cache.clear_all()
@@ -1302,7 +1363,7 @@ class ImportsManager:
                         import_name,
                         None,
                         True,
-                        mtimes=_collect_library_mtimes(import_name, None),
+                        file_infos=_collect_library_file_infos(import_name, None),
                     )
             else:
                 module_spec = self._get_module_spec_cached(import_name)
@@ -1313,7 +1374,9 @@ class ImportsManager:
                         module_spec.origin,
                         module_spec.submodule_search_locations,
                         False,
-                        mtimes=_collect_library_mtimes(module_spec.origin, module_spec.submodule_search_locations),
+                        file_infos=_collect_library_file_infos(
+                            module_spec.origin, module_spec.submodule_search_locations
+                        ),
                     )
 
             if result is not None:
@@ -1367,7 +1430,7 @@ class ImportsManager:
                         import_name,
                         None,
                         True,
-                        mtimes=_collect_library_mtimes(import_name, None),
+                        file_infos=_collect_library_file_infos(import_name, None),
                     )
             else:
                 module_spec = self._get_module_spec_cached(import_name)
@@ -1378,7 +1441,9 @@ class ImportsManager:
                         module_spec.origin,
                         module_spec.submodule_search_locations,
                         False,
-                        mtimes=_collect_library_mtimes(module_spec.origin, module_spec.submodule_search_locations),
+                        file_infos=_collect_library_file_infos(
+                            module_spec.origin, module_spec.submodule_search_locations
+                        ),
                     )
 
             if result is not None:
@@ -1399,36 +1464,44 @@ class ImportsManager:
 
         return None, name
 
-    def get_cached_library_meta(self, import_name: str, args: Tuple[Any, ...] = ()) -> Optional[LibraryMetaData]:
+    def get_cached_library_meta(
+        self, import_name: str, args: Optional[Tuple[Any, ...]] = ()
+    ) -> Optional[LibraryMetaData]:
         """Return already-computed LibraryMetaData from the internal cache, or None.
 
-        Matches by import name and args to find the correct entry, since
-        the same library with different args may produce different keywords.
+        Matches by import name and args to find the correct entry, since the
+        same library with different args may produce different keywords.
+        ``args=None`` matches by name only — the metadata describes the
+        library's module files and is the same regardless of the arguments.
         """
         with self._libaries_lock:
             for entry in self._libaries.values():
-                if entry.name == import_name and entry.args == args:
+                if entry.name != import_name:
+                    continue
+                if args is not None:
+                    if entry.args == args:
+                        return entry.meta
+                elif entry.meta is not None:
                     return entry.meta
         return None
 
-    def get_cached_resource_meta(self, source: str) -> Optional[RobotFileMeta]:
-        """Return already-computed RobotFileMeta from the internal cache, or None."""
-        entry_key = _ResourcesEntryKey(str(normalized_path(Path(source))))
-        with self._resources_lock:
-            entry = self._resources.get(entry_key)
-            if entry is not None:
-                return entry.meta
-        return None
-
-    def get_cached_variables_meta(self, import_name: str, args: Tuple[Any, ...] = ()) -> Optional[LibraryMetaData]:
+    def get_cached_variables_meta(
+        self, import_name: str, args: Optional[Tuple[Any, ...]] = ()
+    ) -> Optional[LibraryMetaData]:
         """Return already-computed LibraryMetaData for a variables import, or None.
 
         Matches by import name and args, since variable files can return
-        different content depending on the arguments.
+        different content depending on the arguments. ``args=None`` matches by
+        name only (see ``get_cached_library_meta``).
         """
         with self._variables_lock:
             for entry in self._variables.values():
-                if entry.name == import_name and entry.args == args:
+                if entry.name != import_name:
+                    continue
+                if args is not None:
+                    if entry.args == args:
+                        return entry.meta
+                elif entry.meta is not None:
                     return entry.meta
         return None
 
@@ -1601,7 +1674,12 @@ class ImportsManager:
     ) -> None:
         """Save an import result to the disk cache, or log skip if no meta."""
         try:
-            if meta is not None:
+            if meta is not None and not meta.trusted:
+                self._logger.debug(
+                    lambda: f"Skip caching {kind} {name}{args!r}: file state too fresh to trust",
+                    context_name="import",
+                )
+            elif meta is not None:
                 try:
                     self.data_cache.save_entry(section, meta.cache_key, meta, result)
                 except (SystemExit, KeyboardInterrupt):
@@ -1665,14 +1743,14 @@ class ImportsManager:
         return result, meta
 
     @_logger.call
-    def get_libdoc_for_library_import(
+    def get_libdoc_for_library_import_with_meta(
         self,
         name: str,
         args: Tuple[Any, ...],
         base_dir: str,
         sentinel: Any = None,
         variables: Optional[Dict[str, Any]] = None,
-    ) -> LibraryDoc:
+    ) -> Tuple[LibraryDoc, Optional[LibraryMetaData]]:
         with self._logger.measure_time(lambda: f"loading library {name}{args!r}", context_name="import"):
             source = self.find_library(name, base_dir, variables)
 
@@ -1704,36 +1782,45 @@ class ImportsManager:
                     fin.atexit = False  # type: ignore[misc]
                     entry.references.add(sentinel)
 
-            return entry.get_libdoc()
+            return entry.get_libdoc_with_meta()
 
-    def _is_document_loaded(self, source: str) -> bool:
-        doc = self.documents_manager.get(Uri.from_path(source))
-        return doc is not None and doc.version is not None
+    def get_libdoc_for_library_import(
+        self,
+        name: str,
+        args: Tuple[Any, ...],
+        base_dir: str,
+        sentinel: Any = None,
+        variables: Optional[Dict[str, Any]] = None,
+    ) -> LibraryDoc:
+        return self.get_libdoc_for_library_import_with_meta(name, args, base_dir, sentinel, variables)[0]
 
     @_logger.call
     def get_libdoc_from_model(
         self,
         model: ast.AST,
         source: str,
+        meta: Optional[RobotFileMeta] = None,
     ) -> ResourceDoc:
-
+        """Build (or load from cache) the ResourceDoc for a parsed model.
+
+        ``meta`` must describe the disk state of exactly the content the model
+        was parsed from; the disk cache is only consulted and written when such
+        a trusted meta is available. There is deliberately no fallback to a
+        fresh stat here — the file may have changed since the model's text was
+        read, and labeling old content with a newer state would make the cache
+        entry validate as fresh forever.
+        """
         entry = self._resource_libdoc_cache.get(model)
         if entry is not None and source in entry:
             return entry[source]
 
-        use_disk_cache = not self._is_document_loaded(source)
-
-        result: Optional[ResourceDoc] = None
-        meta: Optional[RobotFileMeta] = None
-        if use_disk_cache:
-            result, meta = self._get_model_doc_cached(source)
-        if result is None:
+        if meta is not None and meta.trusted:
+            result = self._get_model_doc_cached(source, meta)
+            if result is None:
+                result = get_model_doc(model=model, source=source)
+                self._save_model_doc_cache(source, result, meta)
+        else:
             result = get_model_doc(model=model, source=source)
-            if use_disk_cache:
-                if meta is None:
-                    meta = self.get_resource_meta(source)
-                if meta is not None:
-                    self._save_model_doc_cache(source, result, meta)
 
         if entry is None:
             entry = {}
@@ -1745,22 +1832,17 @@ class ImportsManager:
 
     @staticmethod
     def get_resource_meta(source: str) -> Optional[RobotFileMeta]:
-        try:
-            normalized = str(normalized_path(source))
-            mtime_ns = os.stat(normalized, follow_symlinks=False).st_mtime_ns
-            return RobotFileMeta(normalized, mtime_ns)
-        except OSError:
+        normalized = str(normalized_path(source))
+        info = probe_disk_info(normalized)
+        if info is None:
             return None
+        return RobotFileMeta(normalized, info)
 
-    def _get_model_doc_cached(self, source: str) -> Tuple[Optional[ResourceDoc], Optional["RobotFileMeta"]]:
-        meta = self.get_resource_meta(source)
-        if meta is None:
-            return None, None
-
+    def _get_model_doc_cached(self, source: str, meta: RobotFileMeta) -> Optional[ResourceDoc]:
         try:
             entry = self.data_cache.read_entry(CacheSection.RESOURCE, meta.source, RobotFileMeta, ResourceDoc)
             if entry is not None and entry.meta == meta:
-                return entry.data, meta
+                return entry.data
         except (SystemExit, KeyboardInterrupt):
             raise
         except BaseException as e:
@@ -1770,7 +1852,7 @@ class ImportsManager:
                 context_name="import",
             )
 
-        return None, meta
+        return None
 
     def _save_model_doc_cache(self, source: str, result: ResourceDoc, meta: "RobotFileMeta") -> None:
 
@@ -1833,7 +1915,7 @@ class ImportsManager:
         return result, meta
 
     @_logger.call
-    def get_libdoc_for_variables_import(
+    def get_libdoc_for_variables_import_with_meta(
         self,
         name: str,
         args: Tuple[Any, ...],
@@ -1842,7 +1924,7 @@ class ImportsManager:
         variables: Optional[Dict[str, Any]] = None,
         resolve_variables: bool = True,
         resolve_command_line_vars: bool = True,
-    ) -> VariablesDoc:
+    ) -> Tuple[VariablesDoc, Optional[LibraryMetaData]]:
         with self._logger.measure_time(lambda: f"getting libdoc for variables import {name}", context_name="import"):
             source = self.find_variables(name, base_dir, variables, resolve_variables, resolve_command_line_vars)
 
@@ -1879,7 +1961,27 @@ class ImportsManager:
                     fin = weakref.finalize(sentinel, self.__remove_variables_entry, entry_key, entry)
                     fin.atexit = False  # type: ignore[misc]
 
-            return entry.get_libdoc()
+            return entry.get_libdoc_with_meta()
+
+    def get_libdoc_for_variables_import(
+        self,
+        name: str,
+        args: Tuple[Any, ...],
+        base_dir: str,
+        sentinel: Any = None,
+        variables: Optional[Dict[str, Any]] = None,
+        resolve_variables: bool = True,
+        resolve_command_line_vars: bool = True,
+    ) -> VariablesDoc:
+        return self.get_libdoc_for_variables_import_with_meta(
+            name,
+            args,
+            base_dir,
+            sentinel,
+            variables,
+            resolve_variables,
+            resolve_command_line_vars,
+        )[0]
 
     @_logger.call
     def _get_entry_for_resource_import(
@@ -1929,7 +2031,7 @@ class ImportsManager:
 
             return namespace, libdoc
 
-    def get_resource_doc_for_resource_import(
+    def get_resource_doc_for_resource_import_with_meta(
         self,
         name: str,
         base_dir: str,
@@ -1937,11 +2039,24 @@ class ImportsManager:
         variables: Optional[Dict[str, Any]] = None,
         *,
         source: Optional[str] = None,
-    ) -> ResourceDoc:
+    ) -> Tuple[ResourceDoc, Optional[RobotFileMeta]]:
         with self._logger.measure_time(lambda: f"getting resource doc for {name}", context_name="import"):
             entry = self._get_entry_for_resource_import(name, base_dir, sentinel, variables, source=source)
 
-            return entry.get_resource_doc()
+            return entry.get_resource_doc_with_meta()
+
+    def get_resource_doc_for_resource_import(
+        self,
+        name: str,
+        base_dir: str,
+        sentinel: Any = None,
+        variables: Optional[Dict[str, Any]] = None,
+        *,
+        source: Optional[str] = None,
+    ) -> ResourceDoc:
+        return self.get_resource_doc_for_resource_import_with_meta(name, base_dir, sentinel, variables, source=source)[
+            0
+        ]
 
     def complete_library_import(
         self,

robotcode/robot/diagnostics/namespace.py

@@ -26,7 +26,7 @@ from robotcode.core.lsp.types import (
 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 FileId, file_id
+from robotcode.core.utils.path import DiskInfo, FileId, file_id, normalized_path
 
 from ..utils.stubs import Languages
 from ..utils.variables import (
@@ -47,7 +47,7 @@ from .entities import (
 )
 from .errors import DIAGNOSTICS_SOURCE_NAME
 from .import_resolver import ImportResolver
-from .imports_manager import ImportsManager
+from .imports_manager import ImportsManager, RobotFileMeta
 from .keyword_finder import KeywordFinder
 from .library_doc import (
     KeywordDoc,
@@ -184,6 +184,7 @@ class Namespace:
         finder: KeywordFinder,
         sentinel: object,
         semantic_model: Optional["SemanticModel"] = None,
+        dependency_metas: Optional[Dict[str, Optional[Any]]] = None,
     ) -> None:
         self.imports_manager = imports_manager
         self.source = source
@@ -211,6 +212,7 @@ class Namespace:
         self._finder: KeywordFinder = finder
         self._sentinel = sentinel  # prevent GC — ref-counted by imports_manager
         self._semantic_model = semantic_model
+        self._dependency_metas = dependency_metas
 
         # Lazy-computed caches
         self._namespaces: Optional[Dict[KeywordMatcher, List[LibraryEntry]]] = None
@@ -222,6 +224,15 @@ class Namespace:
         imports_manager.resources_changed.add(self._on_resources_changed)
         imports_manager.variables_changed.add(self._on_variables_changed)
 
+    @property
+    def dependency_metas(self) -> Optional[Dict[str, Optional[Any]]]:
+        """Metadata of the dependencies captured while this namespace was resolved.
+
+        ``None`` when the namespace was built by a path that did not record
+        them — such a namespace must never be persisted to the disk cache.
+        """
+        return self._dependency_metas
+
     @property
     def document(self) -> Optional[TextDocument]:
         return self._document() if self._document is not None else None
@@ -702,6 +713,7 @@ class Namespace:
             finder=finder,
             sentinel=sentinel,
             semantic_model=semantic_model,
+            dependency_metas=resolved.dependency_metas,
         )
 
 
@@ -723,6 +735,8 @@ class NamespaceBuilder:
         document_type: Optional[DocumentType] = None,
         languages: Optional[Languages] = None,
         workspace_languages: Optional[Languages] = None,
+        *,
+        disk_info: Optional[DiskInfo] = None,
     ) -> None:
         self._imports_manager = imports_manager
         self._model = model
@@ -732,6 +746,7 @@ class NamespaceBuilder:
         self._document_type = document_type
         self._languages = languages
         self._workspace_languages = workspace_languages
+        self._disk_info = disk_info
         self._enable_semantic_model = False
 
     def set_semantic_model_enabled(self, enabled: bool) -> None:
@@ -747,7 +762,12 @@ class NamespaceBuilder:
         from .semantic_analyzer.analyzer import SemanticAnalyzer
 
         with self._logger.measure_time(lambda: f"Build Namespace for {self._source}", context_name="import"):
-            library_doc = self._imports_manager.get_libdoc_from_model(self._model, self._source)
+            source_meta = (
+                RobotFileMeta(str(normalized_path(self._source)), self._disk_info)
+                if self._disk_info is not None
+                else None
+            )
+            library_doc = self._imports_manager.get_libdoc_from_model(self._model, self._source, source_meta)
             document_uri = (
                 self._document.document_uri if self._document is not None else str(Uri.from_path(self._source))
             )
@@ -839,4 +859,5 @@ class NamespaceBuilder:
                 finder=finder,
                 sentinel=sentinel,
                 semantic_model=analyzer_result.semantic_model,
+                dependency_metas=resolved.dependency_metas,
             )

{robotcode_robot-2.6.2.dist-info → robotcode_robot-2.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotcode-robot
-Version: 2.6.2
+Version: 2.7.0
 Summary: Support classes for RobotCode for handling Robot Framework projects.
 Project-URL: Homepage, https://robotcode.io
 Project-URL: Donate, https://opencollective.com/robotcode
@@ -26,7 +26,7 @@ Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Requires-Dist: platformdirs>=4.3
-Requires-Dist: robotcode-core==2.6.2
+Requires-Dist: robotcode-core==2.7.0
 Requires-Dist: robotframework>=5.0.0
 Requires-Dist: tomli>=1.1.0; python_version < '3.11'
 Description-Content-Type: text/markdown

{robotcode_robot-2.6.2.dist-info → robotcode_robot-2.7.0.dist-info}/RECORD

@@ -1,24 +1,24 @@
 robotcode/robot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-robotcode/robot/__version__.py,sha256=53Sii4w6BIWn-1RhaTyqUO46gDe4nDCRQDAcpsWFH24,22
+robotcode/robot/__version__.py,sha256=EtKWW0Hnl5oWglRNH0HZigvcDT2FEs58ek8buJdwW1E,22
 robotcode/robot/py.typed,sha256=bWew9mHgMy8LqMu7RuqQXFXLBxh2CRx0dUbSx-3wE48,27
 robotcode/robot/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 robotcode/robot/config/loader.py,sha256=qrP810HNMDpqhXopWa0dOa0Wq_zQfVctsNYKY6sLKGI,8654
-robotcode/robot/config/model.py,sha256=nwXBBub17eHvng0UJUCvEgdIeZnk5Ciga-ux7bQNYUQ,103582
+robotcode/robot/config/model.py,sha256=WjaAKyhPzjQvjI2iDW19y0GxRY4JiSJKTtWs4fAgtFQ,104628
 robotcode/robot/config/utils.py,sha256=A8gD5IItxuC7AY5Olcc8tmsSbqCCi_vZPVoK3BqWt_8,4070
 robotcode/robot/diagnostics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 robotcode/robot/diagnostics/analyzer_result.py,sha256=hcakb6YE8zVDKPXsUeaxOldW3dAThOk7Z4w-IRejKoY,1012
 robotcode/robot/diagnostics/data_cache.py,sha256=KmSKbGPPqL-uU1lHwd_tWIyTKnVTPTNJzJZGZB8_Vdw,17720
 robotcode/robot/diagnostics/diagnostic_rules.py,sha256=nhtkLFZP0hzFRj9-i7Zz7klO1mRz3aNBs1PrvurbSrc,408
 robotcode/robot/diagnostics/diagnostics_modifier.py,sha256=7SGr9Knh41bacGPTwn2VDg5cgXVILBeRB6FN_jyjvVk,9945
-robotcode/robot/diagnostics/document_cache_helper.py,sha256=oOKYQazT-b9VEt7rP3PZ4CNGZAEqvUo0lypCWfBgivU,28008
+robotcode/robot/diagnostics/document_cache_helper.py,sha256=3Hb43euh_QSTlG934DmAnk68c-QkavqKLexj1VjMI9o,31604
 robotcode/robot/diagnostics/entities.py,sha256=P1R1kJPvXNGjjah7c6TVfltCF_u1NAKGpzFnPthw3F8,11215
 robotcode/robot/diagnostics/errors.py,sha256=n14np0VmXLMT5Y6R9Dw6tfhreHV_xvPXSPz-a5-OTMM,2363
-robotcode/robot/diagnostics/import_resolver.py,sha256=qqF6dvwLBFljmPOVnDR07iew0_WEc7tetg-wBsJ5uQs,25647
-robotcode/robot/diagnostics/imports_manager.py,sha256=nZ9Vc8rLtl5GkK0u8-nfBNse_e-6Dz5BPQCGV7-dOc4,75294
+robotcode/robot/diagnostics/import_resolver.py,sha256=hoxtMPSMXD_hX8JxJ97nO7LUnaL8QGwqQ9-aw7i1AF8,26675
+robotcode/robot/diagnostics/imports_manager.py,sha256=y7RJ82ftqX6MAQS7xmSMddMf6QHEcG1AnI6Kf2AzZCU,80282
 robotcode/robot/diagnostics/keyword_finder.py,sha256=nwTmjvhyu5H7HHzyk8gt-pny2K2xdH2qCNyKXwwXRnk,18998
 robotcode/robot/diagnostics/library_doc.py,sha256=wGJ1eQtfu3GwC1tvkOFpM60uCF1Z-GwbKbUV5epH-WM,121608
 robotcode/robot/diagnostics/model_helper.py,sha256=_ySXwerkK5xvjWa82T0DFy8jpxRzcaavTJiAHnk2lXQ,29740
-robotcode/robot/diagnostics/namespace.py,sha256=8QuKEVqkIP04fnLxkkgYDlPJBCgPy6eTxZOx7QTvobQ,32770
+robotcode/robot/diagnostics/namespace.py,sha256=OV7aYNTb7pMsJLc8QDl-oI49Zdhd3EXsw8UPi_LdpqU,33724
 robotcode/robot/diagnostics/namespace_analyzer.py,sha256=QVGm9AjukAGDul7WjNuxcbLDpgdEtfze2sa5_ni1Eac,100143
 robotcode/robot/diagnostics/project_index.py,sha256=nOBvfAxLS9KoKjye9_4YWmHPuJoZqspCQ1PLHieZKuc,7209
 robotcode/robot/diagnostics/scope_tree.py,sha256=2Ev4BhzTbVSsXku0p8naftbTWQXbGqCiEMBUrtiVicI,8337
@@ -41,6 +41,6 @@ robotcode/robot/utils/robot_path.py,sha256=ObLP8PqamTZAz5oi0eDXE_dnyZwAPXp4TJYm6
 robotcode/robot/utils/stubs.py,sha256=umugZYAyneFNgqRJBRMJPzm0u0B_TH8Sx_y-ykXnxpw,351
 robotcode/robot/utils/variables.py,sha256=q4lcigv9_NxiSgIrxvzmfmjKoKj_o_qMjWwnSKRH71k,9309
 robotcode/robot/utils/visitor.py,sha256=nP3O0qh3YYuxR6S8wYJRBFfNwIVgsgohURBlrnFkRYQ,2299
-robotcode_robot-2.6.2.dist-info/METADATA,sha256=YJYk6RH0dDmtMBNElnSOBh38WqxKZ_VQyjA6HrB8o5Q,2893
-robotcode_robot-2.6.2.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-robotcode_robot-2.6.2.dist-info/RECORD,,
+robotcode_robot-2.7.0.dist-info/METADATA,sha256=UJBll3gAP1xot1Ffu-iiB0fOVGrNB-7hCw4IuZ2x-2c,2893
+robotcode_robot-2.7.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+robotcode_robot-2.7.0.dist-info/RECORD,,

{robotcode_robot-2.6.2.dist-info → robotcode_robot-2.7.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.30.1
+Generator: hatchling 1.31.0
 Root-Is-Purelib: true
 Tag: py3-none-any