fix(language-server): honor semantic model setting changes

Author: d-biehl

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

@@ -419,11 +419,14 @@ def __get_namespace_for_document_type(
     ) -> Namespace:
         source = str(document.uri.to_path())
         imports_manager = self.get_imports_manager(document)
+        semantic_model_enabled = self._is_semantic_model_enabled(document)
 
         # --- Try disk cache (cold-start acceleration) ---
         cache_namespaces = self.analysis_config.cache.cache_namespaces
         if cache_namespaces and document.version is None:
-            result = self._try_load_cached_namespace(source, document, document_type, imports_manager)
+            result = self._try_load_cached_namespace(
+                source, document, document_type, imports_manager, semantic_model_enabled
+            )
             if result is not None:
                 return result
 
@@ -438,8 +441,6 @@ def __get_namespace_for_document_type(
             model = self.get_model(document)
 
         languages, workspace_languages = self.build_languages_from_model(document, model)
-        experimental_config = self.workspace.get_configuration(ExperimentalConfig, document.uri)
-
         builder = NamespaceBuilder(
             imports_manager,
             model,
@@ -449,13 +450,13 @@ def __get_namespace_for_document_type(
             languages,
             workspace_languages,
         )
-        builder.set_semantic_model_enabled(self.analysis_config.semantic_model or experimental_config.semantic_model)
+        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)
+            self._save_namespace_to_cache(source, result, imports_manager, semantic_model_enabled)
 
         # Update the folder-scoped reference index
         self.get_project_index(document).update_file(result.source, result)
@@ -469,12 +470,17 @@ def __get_namespace_for_document_type(
 
         return result
 
+    def _is_semantic_model_enabled(self, document: TextDocument) -> bool:
+        experimental_config = self.workspace.get_configuration(ExperimentalConfig, document.uri)
+        return self.analysis_config.semantic_model or experimental_config.semantic_model
+
     def _try_load_cached_namespace(
         self,
         source: str,
         document: TextDocument,
         document_type: Optional[DocumentType],
         imports_manager: ImportsManager,
+        semantic_model_enabled: bool,
     ) -> Optional[Namespace]:
         """Attempt to load a Namespace from the disk cache.
 
@@ -498,14 +504,22 @@ def _try_load_cached_namespace(
             )
             return None
 
-        if entry is None or entry.meta is None:
+        meta = entry.meta if entry is not None else None
+        if entry is None or meta is None:
             self._logger.debug(
                 lambda: f"Cache miss for {source}: no cached entry found",
                 context_name="cache",
             )
             return None
 
-        if not imports_manager.validate_namespace_meta(entry.meta):
+        if getattr(meta, "semantic_model_enabled", None) != semantic_model_enabled:
+            self._logger.debug(
+                lambda: f"Cache miss for {source}: semantic model setting changed",
+                context_name="cache",
+            )
+            return None
+
+        if not imports_manager.validate_namespace_meta(meta):
             self._logger.debug(
                 lambda: f"Cache miss for {source}: cached entry is stale, re-analyzing",
                 context_name="cache",
@@ -559,10 +573,13 @@ def _save_namespace_to_cache(
         source: str,
         namespace: Namespace,
         imports_manager: ImportsManager,
+        semantic_model_enabled: bool,
     ) -> None:
         """Save a Namespace to the disk cache."""
         try:
-            meta = imports_manager.build_namespace_meta(source, namespace)
+            meta = imports_manager.build_namespace_meta(
+                source, namespace, semantic_model_enabled=semantic_model_enabled
+            )
             data = namespace.to_data()
 
             data_cache = imports_manager.data_cache

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

@@ -579,6 +579,7 @@ class NamespaceMetaData:
     source_mtime_ns: int
     config_fingerprint: Any
     dependency_fingerprints: Dict[str, Any] = field(default_factory=dict)
+    semantic_model_enabled: bool = False
 
 
 class ImportsManager:
@@ -814,7 +815,9 @@ def compute_dependency_fingerprints(self, namespace: "Namespace") -> Dict[str, A
 
         return fingerprints
 
-    def build_namespace_meta(self, source: str, namespace: "Namespace") -> NamespaceMetaData:
+    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
@@ -826,6 +829,7 @@ def build_namespace_meta(self, source: str, namespace: "Namespace") -> Namespace
             source_mtime_ns=source_mtime_ns,
             config_fingerprint=self.config_fingerprint,
             dependency_fingerprints=self.compute_dependency_fingerprints(namespace),
+            semantic_model_enabled=semantic_model_enabled,
         )
 
     def validate_namespace_meta(self, meta: NamespaceMetaData) -> bool:

tests/robotcode/robot/diagnostics/test_namespace_cache.py

@@ -138,6 +138,15 @@ def test_meta_inequality_mtime(self, mocker: MockerFixture) -> None:
         meta2 = NamespaceMetaData("/a.robot", 200, ())
         assert meta1 != meta2
 
+    def test_meta_default_semantic_model_disabled(self, mocker: MockerFixture) -> None:
+        meta = NamespaceMetaData("/a.robot", 100, ())
+        assert meta.semantic_model_enabled is False
+
+    def test_meta_inequality_semantic_model_mode(self, mocker: MockerFixture) -> None:
+        meta1 = NamespaceMetaData("/a.robot", 100, (), semantic_model_enabled=False)
+        meta2 = NamespaceMetaData("/a.robot", 100, (), semantic_model_enabled=True)
+        assert meta1 != meta2
+
 
 # ===========================================================================
 # 1e-f: Fingerprint computation
@@ -258,6 +267,17 @@ def test_builds_meta_with_correct_fields(self, tmp_path: Path, mocker: MockerFix
         assert meta.source_mtime_ns > 0
         assert isinstance(meta.config_fingerprint, tuple)
         assert isinstance(meta.dependency_fingerprints, dict)
+        assert meta.semantic_model_enabled is False
+
+    def test_builds_meta_with_semantic_model_enabled(self, tmp_path: Path, mocker: MockerFixture) -> None:
+        source = tmp_path / "test.robot"
+        source.write_text("*** Test Cases ***\n")
+
+        ns = _mock_namespace(mocker, source=str(source))
+        im = _mock_imports_manager(mocker)
+
+        meta = ImportsManager.build_namespace_meta(im, str(source), ns, semantic_model_enabled=True)
+        assert meta.semantic_model_enabled is True
 
     def test_source_set(self, tmp_path: Path, mocker: MockerFixture) -> None:
         source = tmp_path / "test.robot"

vscode-client/extension/index.ts

@@ -183,6 +183,7 @@ export async function activateAsync(context: vscode.ExtensionContext): Promise<v
         "robotcode.documentationServer",
         "robotcode.completion",
         "robotcode.inlayHints",
+        "robotcode.experimental",
         "robotcode.disableExtension",
       ]) {
         for (const ws of vscode.workspace.workspaceFolders ?? []) {