perf(robot): speed up namespace cache loading with source hints and top-level-only imports

Add resolved_resource_sources to NamespaceData that maps import hint
keys to resolved file paths. During from_data() re-resolution, these
hints skip expensive find_resource() filesystem searches when the
cached path still exists on disk.

Also limit cached imports to top-level only (recursive imports are
re-discovered during resolution), replace Path-based normalization
with string-only os.path calls in imports_manager, and add a hint_key
property to Import for consistent key computation.

Author: d-biehl

packages/robot/src/robotcode/robot/diagnostics/entities.py

@@ -52,6 +52,10 @@ class Import(SourceEntity):
     name: Optional[str]
     name_token: Optional[Token]
 
+    @property
+    def hint_key(self) -> str:
+        return f"{self.name}\0{self.source or ''}\0{self.line_no}"
+
     @property
     def range(self) -> Range:
         return Range(

packages/robot/src/robotcode/robot/diagnostics/import_resolver.py

@@ -9,6 +9,7 @@
 containing all resolved entries and collected diagnostics.
 """
 
+import os
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, Dict, Iterable, List, Optional, Union
@@ -85,6 +86,7 @@ class ImportResolver:
         "_scope",
         "_sentinel",
         "_source",
+        "_source_hints",
         "_source_id",
         "_variables",
         "_variables_dirty",
@@ -112,9 +114,12 @@ def __init__(
         self._diagnostics: List[Diagnostic] = []
         self._variables: Dict[str, Any] = {}
         self._variables_dirty = True
+        self._source_hints: Dict[str, str] = {}
 
-    def resolve(self, imports: Iterable[Import]) -> ResolvedImports:
+    def resolve(self, imports: Iterable[Import], *, source_hints: Optional[Dict[str, str]] = None) -> ResolvedImports:
         """Resolve all imports and return the result."""
+        if source_hints:
+            self._source_hints = source_hints
         self._refresh_variables()
         self._import_default_libraries()
         self._handle_imports(imports, self._base_dir, top_level=True)
@@ -395,11 +400,19 @@ def _import_resource(
     ) -> None:
         assert imp.name is not None
 
+        # Look up cached source hint to skip find_resource() filesystem search
+        source_hint: Optional[str] = None
+        if self._source_hints:
+            hint = self._source_hints.get(imp.hint_key)
+            if hint is not None and os.path.isfile(hint):
+                source_hint = hint
+
         resource_doc = self._imports_manager.get_resource_doc_for_resource_import(
             imp.name,
             base_dir,
             sentinel=self._sentinel,
             variables=self._variables,
+            source=source_hint,
         )
         entry = ResourceEntry(
             name=resource_doc.name,

packages/robot/src/robotcode/robot/diagnostics/imports_manager.py

@@ -1852,13 +1852,13 @@ def _get_entry_for_resource_import(
         source: Optional[str] = None,
     ) -> _ResourcesEntry:
         source = source or self.find_resource(name, base_dir, variables=variables)
-        source_path = normalized_path(Path(source))
+        normalized_source = os.path.normpath(os.path.abspath(source))
 
-        entry_key = _ResourcesEntryKey(str(source_path))
+        entry_key = _ResourcesEntryKey(normalized_source)
 
         with self._resources_lock:
             if entry_key not in self._resources:
-                self._resources[entry_key] = _ResourcesEntry(name, self, source_path)
+                self._resources[entry_key] = _ResourcesEntry(name, self, Path(normalized_source))
 
             entry = self._resources[entry_key]
 

packages/robot/src/robotcode/robot/diagnostics/namespace.py

@@ -126,6 +126,12 @@ class NamespaceData:
     # --- ScopeTree (local scopes only, file_scope is reconstructed) ---
     local_scopes: List[LocalScope] = field(default_factory=list)
 
+    # --- Resolved resource import sources ---
+    # Maps (import_name\0source_file) → resolved absolute path for resources.
+    # Used as source hints in from_data() to skip find_resource() filesystem
+    # lookups during import re-resolution.
+    resolved_resource_sources: Dict[str, str] = field(default_factory=dict)
+
     # --- Authoritative variable definitions (stable_id → VariableDefinition) ---
     # Stores the exact VariableDefinition objects that were referenced during
     # analysis. Used as fallback in from_data() when the re-parsed resource doc
@@ -494,13 +500,19 @@ def to_data(self) -> NamespaceData:
             else:
                 var_assigns_merged[sid] = set(ranges)
 
+        # Build resolved resource source hints for from_data() optimization
+        resolved_res_sources: Dict[str, str] = {}
+        for imp, entry in self._import_entries.items():
+            if isinstance(entry, ResourceEntry) and entry.library_doc.source:
+                resolved_res_sources[imp.hint_key] = entry.library_doc.source
+
         return NamespaceData(
             source=self.source,
             source_id=str(self.source_id) if self.source_id else None,
             document_type=self.document_type.value if self.document_type else None,
             languages=self.languages,
             workspace_languages=self.workspace_languages,
-            imports=list(self._import_entries.keys()),
+            imports=[imp for imp in self._import_entries if imp.source is None or imp.source == self.source],
             diagnostics=list(self._diagnostics),
             test_case_definitions=list(self._test_case_definitions),
             keyword_references=kw_refs_merged,
@@ -511,6 +523,7 @@ def to_data(self) -> NamespaceData:
             testcase_tag_references={k: set(v) for k, v in self._testcase_tag_references.items()},
             metadata_references={k: set(v) for k, v in self._metadata_references.items()},
             local_scopes=list(self._scope_tree.local_scopes),
+            resolved_resource_sources=resolved_res_sources,
             variable_definitions=all_var_defs,
         )
 
@@ -542,7 +555,7 @@ def from_data(
         )
 
         resolver = ImportResolver(imports_manager, data.source, scope, sentinel=sentinel)
-        resolved = resolver.resolve(data.imports)
+        resolved = resolver.resolve(data.imports, source_hints=data.resolved_resource_sources)
 
         # Add imported variables to scope (needed for variable lookup)
         for resource_entry in resolved.resources.values():