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

robotcode/robot/diagnostics/imports_manager.py

@@ -1,21 +1,26 @@
 import ast
 import multiprocessing as mp
 import os
+import sys
 import threading
+import time
 import weakref
 from abc import ABC, abstractmethod
-from concurrent.futures import ProcessPoolExecutor, TimeoutError
-from dataclasses import dataclass, field
+from concurrent.futures import ProcessPoolExecutor
+from dataclasses import dataclass, field, replace
+from multiprocessing.connection import Connection, wait
 from pathlib import Path
 from typing import (
     TYPE_CHECKING,
     Any,
+    Callable,
     Dict,
     List,
     Mapping,
     Optional,
     Set,
     Tuple,
+    Union,
     final,
 )
 
@@ -42,21 +47,34 @@ 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
 from ..utils.robot_path import find_file_ex
+from ..utils.stubs import Languages
 from ..utils.variables import contains_variable
 from .data_cache import CACHE_DIR_NAME, CacheSection, build_cache_dir
 from .data_cache import SqliteDataCache as DefaultDataCache
 from .entities import (
     CommandLineVariableDefinition,
+    Import,
+    LibraryImport,
+    ResourceImport,
     VariableDefinition,
+    VariablesImport,
 )
+from .errors import Error as DiagnosticError
 from .library_doc import (
     ROBOT_LIBRARY_PACKAGE,
     CompleteResult,
+    Error,
     LibraryDoc,
     ModuleSpec,
     ResourceDoc,
@@ -88,12 +106,49 @@ RESOURCE_EXTENSIONS = (
     if RF_VERSION >= (6, 1)
     else {".resource", ".robot", ".txt", ".tsv", ".rst", ".rest"}
 )
+if RF_VERSION >= (7, 5):
+    RESOURCE_EXTENSIONS |= {".md", ".markdown"}
 REST_EXTENSIONS = (".rst", ".rest")
 
 
 DEFAULT_LOAD_LIBRARY_TIMEOUT: int = 10
 ENV_LOAD_LIBRARY_TIMEOUT_VAR = "ROBOTCODE_LOAD_LIBRARY_TIMEOUT"
 COMPLETE_LIBRARY_IMPORT_TIMEOUT = COMPLETE_RESOURCE_IMPORT_TIMEOUT = COMPLETE_VARIABLES_IMPORT_TIMEOUT = 5
+# waiting on a pipe takes the timeout in milliseconds as a C int on POSIX
+MAX_LOAD_WAIT_SECONDS = 2_000_000
+
+
+class LoadTimeoutError(RuntimeError):
+    """Loading a library or variable file took longer than the load library timeout."""
+
+
+class LoadExitError(RuntimeError):
+    """The import of a library or variable file ended before it finished, e.g. through sys.exit()."""
+
+
+def _run_import_worker(connection: Connection, func: Callable[..., Any], func_args: Tuple[Any, ...]) -> None:
+    """Process target of `ImportsManager._run_in_subprocess`: sends `(ok, value)` back to the parent."""
+    try:
+        result: Tuple[bool, Any] = (True, func(*func_args))
+    except Exception as e:
+        # a SystemExit ends only the worker, the parent reports its exit code
+        result = (False, e)
+
+    connection.send(result)
+    connection.close()
+
+
+def _end_process(process: mp.process.BaseProcess) -> None:
+    if process.pid is None:
+        return
+
+    if process.is_alive():
+        process.terminate()
+        process.join(1)
+        if process.is_alive():
+            process.kill()
+
+    process.join()
 
 
 @dataclass(frozen=True, slots=True)
@@ -272,14 +327,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 +407,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 +458,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)
@@ -474,7 +548,7 @@ class _VariablesEntry(_ImportEntry):
             self.resolve_command_line_vars,
         )
 
-        if self._lib_doc is not None:
+        if self._lib_doc is not None and self._lib_doc.source:
             self.file_watchers.append(
                 self.parent.file_watcher_manager.add_file_watchers(
                     self.parent.did_change_watched_files,
@@ -495,14 +569,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 +595,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 +610,38 @@ class LibraryMetaData:
 
         raise ValueError("Cannot determine cache key.")
 
+    def cache_key_for_args(self, args: Tuple[Any, ...]) -> str:
+        # the documentation can depend on the import arguments, so each argument set gets its own entry
+        return f"{self.cache_key}\n{args!r}" if args else self.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 +649,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 +668,45 @@ def _matches_any_pattern(
 @dataclass(slots=True)
 class RobotFileMeta:
     source: str
-    mtime_ns: int
+    info: DiskInfo
+    # the language settings the file was parsed with; only the cached docs of files carry them
+    languages: Any = None
+
+    @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)
+
+
+def _languages_fingerprint(languages: Optional[Languages]) -> Any:
+    """What the parsing of a Robot Framework file takes from the language settings, comparable and picklable."""
+    if languages is None:
+        return None
+    return (
+        tuple(sorted(languages.bdd_prefixes)),
+        tuple(sorted(languages.headers.items())),
+        tuple(sorted(languages.settings.items())),
+        tuple(sorted(languages.true_strings)),
+        tuple(sorted(languages.false_strings)),
+    )
+
+
+def _has_cache_key(meta: LibraryMetaData, cache_key: str) -> bool:
+    try:
+        return meta.cache_key == cache_key
+    except ValueError:
+        return False
 
 
 @dataclass(slots=True)
@@ -576,7 +718,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
@@ -585,6 +727,9 @@ class NamespaceMetaData:
 class ImportsManager:
     _logger = LoggingDescriptor()
 
+    # Seconds that changes of resource documents are gathered before their importers are analyzed again.
+    _resource_document_changed_timer_interval: float = 1
+
     def __init__(
         self,
         documents_manager: DocumentsManager,
@@ -656,24 +801,16 @@ class ImportsManager:
         if environment:
             self._environment.update(environment)
 
-        workspace_langs = self.document_cache_helper.get_languages_for_document(Uri.from_path(self.root_folder))
-        if workspace_langs is not None:
-            languages_fingerprint: Any = (
-                tuple(sorted(workspace_langs.bdd_prefixes)),
-                tuple(sorted(workspace_langs.headers.items())),
-                tuple(sorted(workspace_langs.settings.items())),
-                tuple(sorted(workspace_langs.true_strings)),
-                tuple(sorted(workspace_langs.false_strings)),
-            )
-        else:
-            languages_fingerprint = None
+        self._languages_fingerprint = _languages_fingerprint(
+            self.document_cache_helper.get_languages_for_document(Uri.from_path(self.root_folder))
+        )
 
         self._config_fingerprint: Any = (
             tuple(sorted(self.cmd_variables.items())),
             tuple(self.cmd_variable_files),
             tuple(sorted((k, v) for k, v in self._environment.items() if k not in os.environ)),
             tuple(self.global_library_search_order),
-            languages_fingerprint,
+            self._languages_fingerprint,
         )
 
         self._library_files_cache = SimpleLRUCache(2048)
@@ -688,12 +825,14 @@ class ImportsManager:
             default_timeout=120, name="ImportsManager._resource_document_changed_timer_lock"
         )
         self._resource_document_changed_timer: Optional[threading.Timer] = None
-        self._resource_document_changed_timer_interval = 1
         self._resource_document_changed_documents: Set[TextDocument] = set()
 
         self._resource_libdoc_cache: "weakref.WeakKeyDictionary[ast.AST, Dict[str, ResourceDoc]]" = (
             weakref.WeakKeyDictionary()
         )
+        # the doc of each file with the disk state it was read at: while the file keeps that state, analyzing it
+        # again gets the same doc instead of a new copy from the disk cache
+        self._model_docs_by_source: Dict[str, Tuple[RobotFileMeta, ResourceDoc]] = {}
 
         self._diagnostics: List[Diagnostic] = []
 
@@ -761,101 +900,84 @@ 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.
+
+        A namespace with failed imports is not persisted either: the validation
+        cannot tell that a missing file appeared since, or that a library that
+        failed to load would load now, and the cached diagnostics would keep
+        reporting the old error.
         """
-        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
+        if not disk_info.trusted:
+            return None
 
-        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 namespace.failed_imports:
+            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",
             )
@@ -869,14 +991,14 @@ class ImportsManager:
             return False
 
         # Level 2: dependency checks — direct comparison, no hashing
-        base_dir = os.path.dirname(source)
         for key, saved_value in meta.dependency_fingerprints.items():
             if key.startswith("lib:"):
+                # the cache key of the library's meta: its file, or its module name
                 lib_name = key[4:]
                 try:
                     lib_meta = self.get_cached_library_meta(lib_name)
                     if lib_meta is None:
-                        lib_meta, _, _ = self.get_library_meta(lib_name, base_dir=base_dir)
+                        lib_meta, _, _ = self.get_library_meta(lib_name)
                     if lib_meta is None or lib_meta != saved_value:
                         self._logger.debug(
                             lambda: (
@@ -898,8 +1020,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).normalized())
+                    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(
@@ -920,11 +1049,12 @@ class ImportsManager:
                     )
                     return False
             elif key.startswith("var:"):
+                # the cache key of the variable file's meta: its file, or its module name
                 var_name = key[4:]
                 try:
                     var_meta = self.get_cached_variables_meta(var_name)
                     if var_meta is None:
-                        var_meta, _ = self.get_variables_meta(var_name, base_dir=base_dir)
+                        var_meta, _ = self.get_variables_meta(var_name)
                     if var_meta is None or var_meta != saved_value:
                         self._logger.debug(
                             lambda: (
@@ -952,18 +1082,39 @@ 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:
+        self._model_docs_by_source.clear()
         count = self.data_cache.clear_all()
         self._logger.debug(lambda: f"Cleared {count} cache entries from {self.cache_path}")
 
+    def remove_cached_resource_docs(self, sources: List[str]) -> None:
+        """Remove the docs of deleted files from the analysis cache and from memory.
+
+        ``sources`` are normalized paths, as the entries of the cache name them.
+        """
+        for source in sources:
+            self._model_docs_by_source.pop(source, None)
+        self.data_cache.remove_entries(CacheSection.RESOURCE, sources)
+
     @_logger.call
     def get_command_line_variables(self) -> List[VariableDefinition]:
         with self._command_line_variables_lock:
@@ -1153,6 +1304,23 @@ class ImportsManager:
         if resource_changed:
             self.resources_changed(self, resource_changed)
 
+    def changed_import_files(self) -> List[str]:
+        """The files of the loaded libraries and variable files that changed since they were loaded."""
+        with self._libaries_lock:
+            entries: List[Union[_LibrariesEntry, _VariablesEntry]] = list(self._libaries.values())
+        with self._variables_lock:
+            entries.extend(self._variables.values())
+
+        result: List[str] = []
+        for entry in entries:
+            meta = entry.meta
+            if meta is None or not meta.file_infos:
+                continue
+            for path, info in meta.file_infos.items():
+                if path not in result and probe_disk_info(path) != info:
+                    result.append(path)
+        return result
+
     @_logger.call
     def did_change_watched_files(self, sender: Any, changes: List[FileEvent]) -> None:
         libraries_changed: List[Tuple[_LibrariesEntryKey, FileChangeType, Optional[LibraryDoc]]] = []
@@ -1302,7 +1470,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 +1481,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 +1537,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 +1548,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,38 +1571,28 @@ class ImportsManager:
 
         return None, name
 
-    def get_cached_library_meta(self, import_name: str, args: Tuple[Any, ...] = ()) -> Optional[LibraryMetaData]:
-        """Return already-computed LibraryMetaData from the internal cache, or None.
+    def get_cached_library_meta(self, cache_key: str) -> Optional[LibraryMetaData]:
+        """Return the meta of a loaded library whose meta has the cache key `cache_key`, or None.
 
-        Matches by import name and args to find the correct entry, since
-        the same library with different args may produce different keywords.
+        The cache key names the library's file (or module), so a library with
+        the same import name from another folder is not found.
         """
         with self._libaries_lock:
-            for entry in self._libaries.values():
-                if entry.name == import_name and entry.args == args:
-                    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
+            return next(
+                (e.meta for e in self._libaries.values() if e.meta is not None and _has_cache_key(e.meta, cache_key)),
+                None,
+            )
 
-    def get_cached_variables_meta(self, import_name: str, args: Tuple[Any, ...] = ()) -> Optional[LibraryMetaData]:
-        """Return already-computed LibraryMetaData for a variables import, or None.
+    def get_cached_variables_meta(self, cache_key: str) -> Optional[LibraryMetaData]:
+        """Return the meta of a loaded variable file whose meta has the cache key `cache_key`, or None.
 
-        Matches by import name and args, since variable files can return
-        different content depending on the arguments.
+        See ``get_cached_library_meta``.
         """
         with self._variables_lock:
-            for entry in self._variables.values():
-                if entry.name == import_name and entry.args == args:
-                    return entry.meta
-        return None
+            return next(
+                (e.meta for e in self._variables.values() if e.meta is not None and _has_cache_key(e.meta, cache_key)),
+                None,
+            )
 
     def find_library(
         self,
@@ -1554,6 +1716,41 @@ class ImportsManager:
 
         return name
 
+    def find_import_source(
+        self, imp: Import, base_dir: str, variables: Optional[Dict[str, Any]] = None
+    ) -> Optional[str]:
+        """The file an import refers to, or `None` when its file or module is not found. Nothing is loaded."""
+        if imp.name is None:
+            return None
+
+        try:
+            if isinstance(imp, ResourceImport):
+                return self.find_resource(imp.name, base_dir, variables=variables)
+
+            if isinstance(imp, LibraryImport):
+                name = self.find_library(imp.name, base_dir, variables)
+                by_path = is_library_by_path(name)
+            elif isinstance(imp, VariablesImport):
+                name = self.find_variables(imp.name, base_dir, variables)
+                by_path = is_variables_by_path(name)
+            else:
+                return None
+
+            # a file imported by path is looked up with its name, and the lookup fails when it is missing
+            if by_path:
+                return name
+
+            module_spec = self._get_module_spec_cached(name)
+            if module_spec is None:
+                return None
+            if module_spec.origin is not None:
+                return module_spec.origin
+            return module_spec.submodule_search_locations[0] if module_spec.submodule_search_locations else None
+        except (SystemExit, KeyboardInterrupt):
+            raise
+        except BaseException:
+            return None
+
     @property
     def executor(self) -> ProcessPoolExecutor:
         with self._executor_lock:
@@ -1569,26 +1766,61 @@ class ImportsManager:
         A fresh process per import is intentional: libraries and variable files
         can pollute the interpreter (e.g. via sys.modules, global state, native
         extensions) and cannot be safely re-imported after on-disk changes.
+
+        The process is ended when the load library timeout expires, so a library
+        that blocks cannot hold up the caller beyond the timeout.
         """
-        executor = ProcessPoolExecutor(max_workers=1, mp_context=mp.get_context("spawn"))
+        context = mp.get_context("spawn")
+        receiver, sender = context.Pipe(duplex=False)
+        process = context.Process(target=_run_import_worker, args=(sender, func, func_args))
         try:
             try:
-                return executor.submit(func, *func_args).result(self.load_library_timeout)
-            except TimeoutError as e:
-                raise RuntimeError(
+                process.start()
+            finally:
+                # the worker keeps the sending end (on Windows once it has unpickled its arguments)
+                sender.close()
+
+            # the sentinel also reports a worker that ends before it has taken over the sending end
+            if not wait([receiver, process.sentinel], min(self.load_library_timeout, MAX_LOAD_WAIT_SECONDS)):
+                raise LoadTimeoutError(
                     f"{timeout_msg} "
-                    f"timed out after {self.load_library_timeout} seconds. "
+                    f"timed out after {self.load_library_timeout} "
+                    f"{'second' if self.load_library_timeout == 1 else 'seconds'}. "
                     "The import may be slow or blocked. "
                     "If required, increase the timeout by setting the ROBOTCODE_LOAD_LIBRARY_TIMEOUT "
                     "environment variable."
+                )
+
+            try:
+                if not receiver.poll(0):
+                    # only the sentinel is ready: the worker ended before it took over the sending end
+                    raise EOFError
+                ok, value = receiver.recv()
+            except (EOFError, BrokenPipeError) as e:
+                process.join(1)
+                raise LoadExitError(
+                    f"{timeout_msg} failed: the import ended with exit code {process.exitcode} before it finished, "
+                    "for example through sys.exit() or a crash in the imported code."
                 ) from e
+
+            # give the worker the chance to end on its own, the finally block ends it otherwise
+            process.join(1)
+
+            if not ok:
+                raise value
+
+            return value
         except (SystemExit, KeyboardInterrupt):
             raise
+        except (LoadTimeoutError, LoadExitError):
+            # the caller reports a timeout or an import that ended early as a diagnostic, so no traceback
+            raise
         except BaseException as e:
             self._logger.exception(e)
             raise
         finally:
-            executor.shutdown(wait=True)
+            receiver.close()
+            _end_process(process)
 
     def _save_import_cache(
         self,
@@ -1599,11 +1831,16 @@ class ImportsManager:
         name: str,
         args: Tuple[Any, ...],
     ) -> None:
-        """Save an import result to the disk cache, or log skip if no meta."""
+        """Save an import result to the disk cache under its argument set, 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)
+                    self.data_cache.save_entry(section, meta.cache_key_for_args(args), meta, result)
                 except (SystemExit, KeyboardInterrupt):
                     raise
                 except BaseException as e:
@@ -1623,11 +1860,18 @@ class ImportsManager:
         base_dir: str,
         variables: Optional[Dict[str, Any]] = None,
     ) -> Tuple[LibraryDoc, Optional[LibraryMetaData]]:
-        meta, _source, ignore_arguments = self.get_library_meta(name, base_dir, variables)
+        meta, import_name, ignore_arguments = self.get_library_meta(name, base_dir, variables)
+        cache_args = (
+            ()
+            if ignore_arguments
+            else resolve_args(args, working_dir, base_dir, self.get_resolvable_command_line_variables(), variables)
+        )
 
         if meta is not None and not meta.has_errors:
             try:
-                entry = self.data_cache.read_entry(CacheSection.LIBRARY, meta.cache_key, LibraryMetaData, LibraryDoc)
+                entry = self.data_cache.read_entry(
+                    CacheSection.LIBRARY, meta.cache_key_for_args(cache_args), LibraryMetaData, LibraryDoc
+                )
                 if entry is not None and entry.meta is not None:
                     if entry.meta.has_errors:
                         self._logger.debug(
@@ -1644,35 +1888,59 @@ class ImportsManager:
 
         self._logger.debug(lambda: f"Load library in process {name}{args!r}", context_name="import")
 
-        result = self._run_in_subprocess(
-            get_library_doc,
-            (
-                name,
-                args if not ignore_arguments else (),
-                working_dir,
-                base_dir,
-                self.get_resolvable_command_line_variables(),
-                variables,
-            ),
-            f"Loading library {name!r} with args {args!r} (working_dir={working_dir!r}, base_dir={base_dir!r})",
-        )
+        try:
+            result = self._run_in_subprocess(
+                get_library_doc,
+                (
+                    name,
+                    args if not ignore_arguments else (),
+                    working_dir,
+                    base_dir,
+                    self.get_resolvable_command_line_variables(),
+                    variables,
+                ),
+                f"Loading library {name!r} with args {args!r}",
+            )
+        except (LoadTimeoutError, LoadExitError) as e:
+            # kept by the import entry until a file changes, but neither written to the disk cache
+            # nor usable as a namespace dependency
+            return (
+                LibraryDoc(
+                    name=name,
+                    source=(
+                        meta.origin if meta is not None else import_name if is_library_by_path(import_name) else None
+                    ),
+                    errors=[
+                        Error(
+                            message=str(e),
+                            type_name=(
+                                DiagnosticError.LIBRARY_TIMEOUT_ERROR
+                                if isinstance(e, LoadTimeoutError)
+                                else DiagnosticError.LIBRARY_EXIT_ERROR
+                            ),
+                        )
+                    ],
+                    python_path=list(sys.path),
+                ),
+                None,
+            )
 
         if meta is not None:
             meta.has_errors = bool(result.errors)
 
-        self._save_import_cache(CacheSection.LIBRARY, meta, result, "library", name, args)
+        self._save_import_cache(CacheSection.LIBRARY, meta, result, "library", name, cache_args)
 
         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)
 
@@ -1701,39 +1969,48 @@ class ImportsManager:
 
                 if not entry.ignore_reference and sentinel is not None and sentinel not in entry.references:
                     fin = weakref.finalize(sentinel, self.__remove_library_entry, entry_key, entry)
-                    fin.atexit = False  # type: ignore[misc]
+                    fin.atexit = False
                     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 +2022,23 @@ 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]:
+        known = self._model_docs_by_source.get(meta.source)
+        if known is not None and known[0] == meta:
+            return known[1]
 
         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
+            # a doc read with other language settings would hold what the file defines under those settings
+            if entry is not None and entry.meta == replace(meta, languages=self._languages_fingerprint):
+                self._model_docs_by_source[meta.source] = (meta, entry.data)
+                return entry.data
         except (SystemExit, KeyboardInterrupt):
             raise
         except BaseException as e:
@@ -1770,12 +2048,15 @@ class ImportsManager:
                 context_name="import",
             )
 
-        return None, meta
+        return None
 
     def _save_model_doc_cache(self, source: str, result: ResourceDoc, meta: "RobotFileMeta") -> None:
+        self._model_docs_by_source[meta.source] = (meta, result)
 
         try:
-            self.data_cache.save_entry(CacheSection.RESOURCE, meta.source, meta, result)
+            self.data_cache.save_entry(
+                CacheSection.RESOURCE, meta.source, replace(meta, languages=self._languages_fingerprint), result
+            )
         except (SystemExit, KeyboardInterrupt):
             raise
         except BaseException as e:
@@ -1795,7 +2076,7 @@ class ImportsManager:
         resolve_variables: bool = True,
         resolve_command_line_vars: bool = True,
     ) -> Tuple[VariablesDoc, Optional[LibraryMetaData]]:
-        meta, _source = self.get_variables_meta(
+        meta, import_name = self.get_variables_meta(
             name,
             base_dir,
             variables,
@@ -1806,7 +2087,7 @@ class ImportsManager:
         if meta is not None:
             try:
                 entry = self.data_cache.read_entry(
-                    CacheSection.VARIABLES, meta.cache_key, LibraryMetaData, VariablesDoc
+                    CacheSection.VARIABLES, meta.cache_key_for_args(args), LibraryMetaData, VariablesDoc
                 )
                 if entry is not None and entry.meta == meta:
                     return entry.data, meta
@@ -1815,25 +2096,47 @@ class ImportsManager:
             except BaseException as e:
                 self._logger.exception(e)
 
-        result = self._run_in_subprocess(
-            get_variables_doc,
-            (
-                name,
-                args,
-                working_dir,
-                base_dir,
-                self.get_resolvable_command_line_variables() if resolve_command_line_vars else None,
-                variables,
-            ),
-            f"Loading variables {name!r} with args {args!r} (working_dir={working_dir!r}, base_dir={base_dir!r})",
-        )
+        try:
+            result = self._run_in_subprocess(
+                get_variables_doc,
+                (
+                    name,
+                    args,
+                    working_dir,
+                    base_dir,
+                    self.get_resolvable_command_line_variables() if resolve_command_line_vars else None,
+                    variables,
+                ),
+                f"Loading variables {name!r} with args {args!r}",
+            )
+        except (LoadTimeoutError, LoadExitError) as e:
+            # see _get_library_libdoc
+            return (
+                VariablesDoc(
+                    name=name,
+                    source=(
+                        meta.origin if meta is not None else import_name if is_variables_by_path(import_name) else None
+                    ),
+                    errors=[
+                        Error(
+                            message=str(e),
+                            type_name=(
+                                DiagnosticError.VARIABLES_TIMEOUT_ERROR
+                                if isinstance(e, LoadTimeoutError)
+                                else DiagnosticError.VARIABLES_EXIT_ERROR
+                            ),
+                        )
+                    ],
+                ),
+                None,
+            )
 
         self._save_import_cache(CacheSection.VARIABLES, meta, result, "variables", name, args)
 
         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 +2145,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)
 
@@ -1877,9 +2180,29 @@ class ImportsManager:
                 if sentinel is not None and sentinel not in entry.references:
                     entry.references.add(sentinel)
                     fin = weakref.finalize(sentinel, self.__remove_variables_entry, entry_key, entry)
-                    fin.atexit = False  # type: ignore[misc]
+                    fin.atexit = False
 
-            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(
@@ -1905,7 +2228,7 @@ class ImportsManager:
             if sentinel is not None and sentinel not in entry.references:
                 entry.references.add(sentinel)
                 fin = weakref.finalize(sentinel, self.__remove_resource_entry, entry_key, entry)
-                fin.atexit = False  # type: ignore[misc]
+                fin.atexit = False
 
         return entry
 
@@ -1929,7 +2252,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 +2260,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,