robotcode-robot 2.8.0.dev670__py3-none-any.whl → 2.9.0.dev51__py3-none-any.whl

robotcode/robot/__version__.py

@@ -1 +1 @@
-__version__ = "2.8.0-dev.670"
+__version__ = "2.9.0-dev.51"

robotcode/robot/config/model.py

@@ -3222,6 +3222,42 @@ class RobotProfile(RobotExtendBaseProfile):
     )
 
 
+@dataclass(frozen=True)
+class UnknownProfile:
+    """A profile name or pattern that selects no profile, and where it comes from."""
+
+    name: str
+    # the profile whose `inherits` names it; None for a name of the selection or of `default-profiles`
+    inherited_by: Optional[str] = None
+    # whether it comes from `default-profiles`
+    default: bool = False
+
+    @property
+    def selected(self) -> bool:
+        """Whether the name comes from the selection: `-p`, `ROBOTCODE_PROFILES` or an editor."""
+        return self.inherited_by is None and not self.default
+
+    @property
+    def message(self) -> str:
+        return f"No profile matches '{self.name}'."
+
+
+class ProfileNotFoundError(ValueError):
+    """A profile name or pattern that selects no profile."""
+
+    def __init__(self, unknown: UnknownProfile) -> None:
+        super().__init__(unknown.message)
+        self.unknown = unknown
+
+
+class ProfileInheritanceError(ValueError):
+    """A profile that inherits itself, directly or through other profiles."""
+
+    def __init__(self, path: Tuple[str, ...]) -> None:
+        super().__init__(f"The profile '{path[0]}' inherits itself: {' -> '.join(path)}.")
+        self.path = path
+
+
 @dataclass
 class RobotConfig(RobotExtendBaseProfile):
     """Robot Framework configuration."""
@@ -3288,11 +3324,13 @@ class RobotConfig(RobotExtendBaseProfile):
         *names: str,
         verbose_callback: Optional[Callable[[Union[str, Callable[[], Any]]], None]] = None,
         error_callback: Optional[Callable[[Union[str, Callable[[], Any]]], None]] = None,
+        unknown_profile_callback: Optional[Callable[[UnknownProfile], None]] = None,
     ) -> Dict[str, Tuple[RobotProfile, Optional[Set[Tuple[str, RobotProfile]]]]]:
         result: Dict[str, Tuple[RobotProfile, Optional[Set[Tuple[str, RobotProfile]]]]] = {}
 
         profiles = self.profiles or {}
 
+        from_default_profiles = not names
         if not names:
             if verbose_callback:
                 verbose_callback("No profiles given, try to check if there are default profiles specified.")
@@ -3306,40 +3344,65 @@ class RobotConfig(RobotExtendBaseProfile):
 
             names = (*(default_profile or ()),)
 
-        def select(name: str, parent_profiles: Optional[Set[Tuple[str, RobotProfile]]] = None) -> None:
+        # each name that selects no profile is reported once for each place it comes from
+        reported: Set[UnknownProfile] = set()
+
+        def report(unknown: UnknownProfile) -> None:
+            if unknown in reported:
+                return
+            reported.add(unknown)
+
+            # a name that selects no profile is an error of the configuration; only callers that must go on, such as
+            # the language server, take it and go on without it
+            if unknown_profile_callback is not None:
+                unknown_profile_callback(unknown)
+            # a name of `default-profiles` is only reported: the `default-profiles` of the user configuration can name
+            # a profile of that file, which the `[profiles]` of a project replace
+            elif unknown.default and error_callback is not None:
+                error_callback(unknown.message)
+            else:
+                raise ProfileNotFoundError(unknown)
+
+        # `path` holds the profiles whose `inherits` lead to the name; the last one names it
+        def select(name: str, path: Tuple[str, ...] = ()) -> None:
             if not name:
                 return
 
             nonlocal result
 
+            parent = path[-1] if path else None
+
             if verbose_callback:
-                if parent_profiles is not None:
-                    verbose_callback(
-                        f"Selecting profiles matching '{name}'"
-                        f" for parent profile '{next(f for f in parent_profiles)[0]}'."
-                    )
+                if parent is not None:
+                    verbose_callback(f"Selecting profiles matching '{name}' for parent profile '{parent}'.")
                 else:
                     verbose_callback(f"Selecting profiles matching '{name}'.")
 
-            profile_names = [p for p in profiles.keys() if fnmatch.fnmatchcase(p, name)]
+            if name in profiles:
+                # an exact name selects its profile, also when it contains `*`, `?` or `[`
+                profile_names = [name]
+            else:
+                # a pattern in `inherits` does not match the profile that has it
+                profile_names = [p for p in profiles.keys() if p != parent and fnmatch.fnmatchcase(p, name)]
 
             if not profile_names:
-                message = f"Can't find any configuration profiles matching the pattern '{name}'."
-                if error_callback is None:
-                    raise ValueError(message)
-
-                error_callback(message)
+                report(UnknownProfile(name, inherited_by=parent, default=from_default_profiles and parent is None))
                 return
 
+            parent_profiles = {(parent, profiles[parent])} if parent is not None else None
+
             for v in profile_names:
+                if v in path:
+                    raise ProfileInheritanceError((*path[path.index(v) :], v))
+
                 p = profiles[v]
 
                 if p.inherits:
                     if isinstance(p.inherits, list):
                         for i in p.inherits:
-                            select(str(i), {(v, p)})
+                            select(str(i), (*path, v))
                     else:
-                        select(str(p.inherits), {(v, p)})
+                        select(str(p.inherits), (*path, v))
 
                 if v in result:
                     if parent_profiles is None:
@@ -3362,14 +3425,21 @@ class RobotConfig(RobotExtendBaseProfile):
         *names: str,
         verbose_callback: Optional[Callable[[Union[str, Callable[[], Any]]], None]] = None,
         error_callback: Optional[Callable[[Union[str, Callable[[], Any]]], None]] = None,
+        unknown_profile_callback: Optional[Callable[[UnknownProfile], None]] = None,
     ) -> RobotBaseProfile:
-        return self.combine_profiles_ex(*names, verbose_callback=verbose_callback, error_callback=error_callback)[0]
+        return self.combine_profiles_ex(
+            *names,
+            verbose_callback=verbose_callback,
+            error_callback=error_callback,
+            unknown_profile_callback=unknown_profile_callback,
+        )[0]
 
     def combine_profiles_ex(
         self,
         *names: str,
         verbose_callback: Optional[Callable[[Union[str, Callable[[], Any]]], None]] = None,
         error_callback: Optional[Callable[[Union[str, Callable[[], Any]]], None]] = None,
+        unknown_profile_callback: Optional[Callable[[UnknownProfile], None]] = None,
     ) -> Tuple[RobotBaseProfile, Dict[str, RobotProfile], List[str]]:
         enabled_profiles = []
         type_hints = get_type_hints(RobotBaseProfile)
@@ -3390,7 +3460,10 @@ class RobotConfig(RobotExtendBaseProfile):
         )
 
         selected_profiles = self._select_profiles(
-            *names, verbose_callback=verbose_callback, error_callback=error_callback
+            *names,
+            verbose_callback=verbose_callback,
+            error_callback=error_callback,
+            unknown_profile_callback=unknown_profile_callback,
         )
         if verbose_callback:
             if selected_profiles:

robotcode/robot/diagnostics/analyzer_result.py

@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Dict, List, Optional, Set
 
 from robotcode.core.lsp.types import Diagnostic, Location, Range
@@ -25,3 +25,7 @@ class AnalyzerResult:
     testcase_metadata_references: Dict[str, Set[Location]]
     scope_tree: ScopeTree
     semantic_model: Optional["SemanticModel"] = None
+    # the environment variables the analysis read, which the namespace cache compares when it restores the analysis:
+    # whether each one checked without a default value is set, and the hash of each one whose value the analysis used
+    environment_set: Dict[str, bool] = field(default_factory=dict)
+    environment_values: Dict[str, Optional[str]] = field(default_factory=dict)

robotcode/robot/diagnostics/document_cache_helper.py

@@ -640,6 +640,16 @@ class DocumentsCacheHelper:
             )
             return None
 
+        # from_data resolved the imports again with the current Python path and environment variables. A namespace
+        # with a failed import is never stored and the dependency keys name the files found, so a failed import or
+        # other keys mean that an import finds another file or none now.
+        if result.failed_imports or set(result.dependency_metas or {}) != set(meta.dependency_fingerprints):
+            self._logger.debug(
+                lambda: f"Cache miss for {source}: the imports find other files now, re-analyzing",
+                context_name="cache",
+            )
+            return None
+
         self._logger.debug(
             lambda: f"Loaded namespace from disk cache for {source}",
             context_name="import",

robotcode/robot/diagnostics/entities.py

@@ -52,10 +52,6 @@ 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(

robotcode/robot/diagnostics/import_resolver.py

@@ -9,7 +9,6 @@ The resolver takes imports + a VariableScope and returns ResolvedImports
 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, Tuple, Union
@@ -129,7 +128,6 @@ class ImportResolver:
         "_scope",
         "_sentinel",
         "_source",
-        "_source_hints",
         "_source_id",
         "_variables",
         "_variables_dirty",
@@ -159,14 +157,11 @@ class ImportResolver:
         self._diagnostics: List[Diagnostic] = []
         self._variables: Dict[str, Any] = {}
         self._variables_dirty = True
-        self._source_hints: Dict[str, str] = {}
         self._dependency_metas: Dict[str, Optional[Any]] = {}
         self._failed_imports: List[FailedImport] = []
 
-    def resolve(self, imports: Iterable[Import], *, source_hints: Optional[Dict[str, str]] = None) -> ResolvedImports:
+    def resolve(self, imports: Iterable[Import]) -> 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)
@@ -542,19 +537,11 @@ class ImportResolver:
     ) -> 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, 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

robotcode/robot/diagnostics/imports_manager.py

@@ -59,7 +59,7 @@ 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 ..utils.variables import contains_variable, environment_value_hash
 from .data_cache import CACHE_DIR_NAME, CacheSection, build_cache_dir
 from .data_cache import SqliteDataCache as DefaultDataCache
 from .entities import (
@@ -722,6 +722,10 @@ class NamespaceMetaData:
     config_fingerprint: Any
     dependency_fingerprints: Dict[str, Any] = field(default_factory=dict)
     semantic_model_enabled: bool = False
+    # the environment variables the analysis read: whether each one checked without a default value was set, and the
+    # hash of each one whose value it used (see environment_value_hash)
+    environment_set: Dict[str, bool] = field(default_factory=dict)
+    environment_values: Dict[str, Optional[str]] = field(default_factory=dict)
 
 
 class ImportsManager:
@@ -808,7 +812,6 @@ class ImportsManager:
         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),
             self._languages_fingerprint,
         )
@@ -895,8 +898,9 @@ class ImportsManager:
         """Cached configuration snapshot.
 
         Computed once at init from cmd_variables, cmd_variable_files,
-        environment, and global_library_search_order. Changes are
-        detected via direct ``==`` comparison.
+        global_library_search_order and the language settings. Changes are
+        detected via direct ``==`` comparison. Environment variables are
+        not part of it: each namespace keeps the ones its analysis read.
         """
         return self._config_fingerprint
 
@@ -949,13 +953,15 @@ class ImportsManager:
             config_fingerprint=self.config_fingerprint,
             dependency_fingerprints=dict(dependency_metas),
             semantic_model_enabled=semantic_model_enabled,
+            environment_set=dict(namespace.environment_set),
+            environment_values=dict(namespace.environment_values),
         )
 
     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_disk_info, config_fingerprint
+        Level 1 (fast): source_disk_info, config_fingerprint, the environment variables the analysis read
         Level 2 (dependency check): each dependency fingerprint
 
         Validation is against the *effective* content: the source is compared
@@ -990,6 +996,25 @@ class ImportsManager:
             )
             return False
 
+        # the analysis reads os.environ itself, so it does not matter where a variable was set
+        for env_name, was_set in meta.environment_set.items():
+            if (os.environ.get(env_name) is not None) != was_set:
+                name = env_name
+                self._logger.debug(
+                    lambda: f"Cache miss for {source}: environment variable {name!r} was set or unset",
+                    context_name="cache",
+                )
+                return False
+
+        for env_name, value_hash in meta.environment_values.items():
+            if environment_value_hash(os.environ.get(env_name)) != value_hash:
+                name = env_name
+                self._logger.debug(
+                    lambda: f"Cache miss for {source}: environment variable {name!r} changed",
+                    context_name="cache",
+                )
+                return False
+
         # Level 2: dependency checks — direct comparison, no hashing
         for key, saved_value in meta.dependency_fingerprints.items():
             if key.startswith("lib:"):
@@ -2211,10 +2236,8 @@ class ImportsManager:
         base_dir: str,
         sentinel: Any = None,
         variables: Optional[Dict[str, Any]] = None,
-        *,
-        source: Optional[str] = None,
     ) -> _ResourcesEntry:
-        source = source or self.find_resource(name, base_dir, variables=variables)
+        source = self.find_resource(name, base_dir, variables=variables)
         normalized_source = os.path.normpath(os.path.abspath(source))
 
         entry_key = _ResourcesEntryKey(normalized_source)
@@ -2238,12 +2261,10 @@ class ImportsManager:
         base_dir: str,
         sentinel: Any = None,
         variables: Optional[Dict[str, Any]] = None,
-        *,
-        source: Optional[str] = None,
     ) -> Tuple["Namespace", LibraryDoc]:
         with self._logger.measure_time(lambda: f"getting namespace and libdoc for {name}", context_name="import"):
             with self._logger.measure_time(lambda: f"getting resource entry {name}", context_name="import"):
-                entry = self._get_entry_for_resource_import(name, base_dir, sentinel, variables, source=source)
+                entry = self._get_entry_for_resource_import(name, base_dir, sentinel, variables)
 
             with self._logger.measure_time(lambda: f"getting namespace {name}", context_name="import"):
                 namespace = entry.get_namespace()
@@ -2258,11 +2279,9 @@ class ImportsManager:
         base_dir: str,
         sentinel: Any = None,
         variables: Optional[Dict[str, Any]] = None,
-        *,
-        source: Optional[str] = None,
     ) -> 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)
+            entry = self._get_entry_for_resource_import(name, base_dir, sentinel, variables)
 
             return entry.get_resource_doc_with_meta()
 
@@ -2272,12 +2291,8 @@ class ImportsManager:
         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
-        ]
+        return self.get_resource_doc_for_resource_import_with_meta(name, base_dir, sentinel, variables)[0]
 
     def complete_library_import(
         self,

robotcode/robot/diagnostics/library_doc.py

@@ -2728,7 +2728,7 @@ class _Logger(AbstractLogger):
 
 def _import_test_library(name: str) -> Union[Any, Tuple[Any, str]]:
     with OutputCapturer(library_import=True):
-        importer = Importer("test library", LOGGER)
+        importer = Importer("library", LOGGER)
         return importer.import_class_or_module(name, return_source=True)
 
 

robotcode/robot/diagnostics/namespace.py

@@ -133,12 +133,6 @@ 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
@@ -189,6 +183,8 @@ class Namespace:
         semantic_model: Optional["SemanticModel"] = None,
         dependency_metas: Optional[Dict[str, Optional[Any]]] = None,
         failed_imports: Optional[List[FailedImport]] = None,
+        environment_set: Optional[Dict[str, bool]] = None,
+        environment_values: Optional[Dict[str, Optional[str]]] = None,
     ) -> None:
         self.imports_manager = imports_manager
         self.source = source
@@ -219,6 +215,8 @@ class Namespace:
         self._semantic_model = semantic_model
         self._dependency_metas = dependency_metas
         self._failed_imports = failed_imports or []
+        self._environment_set = environment_set or {}
+        self._environment_values = environment_values or {}
 
         # Lazy-computed caches
         self._namespaces: Optional[Dict[KeywordMatcher, List[LibraryEntry]]] = None
@@ -244,6 +242,16 @@ class Namespace:
         """The imports whose resolution raised or whose library or variables documentation has errors."""
         return self._failed_imports
 
+    @property
+    def environment_set(self) -> Dict[str, bool]:
+        """Whether each environment variable the analysis checked without a default value was set."""
+        return self._environment_set
+
+    @property
+    def environment_values(self) -> Dict[str, Optional[str]]:
+        """The hash of each environment variable whose value the analysis used, see `environment_value_hash`."""
+        return self._environment_values
+
     @property
     def document(self) -> Optional[TextDocument]:
         return self._document() if self._document is not None else None
@@ -538,12 +546,6 @@ class Namespace:
             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,
@@ -563,7 +565,6 @@ class Namespace:
             metadata_references={k: set(v) for k, v in self._metadata_references.items()},
             testcase_metadata_references={k: set(v) for k, v in self._testcase_metadata_references.items()},
             local_scopes=list(self._scope_tree.local_scopes),
-            resolved_resource_sources=resolved_res_sources,
             variable_definitions=all_var_defs,
         )
 
@@ -595,7 +596,7 @@ class Namespace:
         )
 
         resolver = ImportResolver(imports_manager, data.source, scope, sentinel=sentinel)
-        resolved = resolver.resolve(data.imports, source_hints=data.resolved_resource_sources)
+        resolved = resolver.resolve(data.imports)
 
         # Add imported variables to scope (needed for variable lookup)
         for resource_entry in resolved.resources.values():
@@ -893,4 +894,6 @@ class NamespaceBuilder:
                 semantic_model=analyzer_result.semantic_model,
                 dependency_metas=resolved.dependency_metas,
                 failed_imports=resolved.failed_imports,
+                environment_set=analyzer_result.environment_set,
+                environment_values=analyzer_result.environment_values,
             )

robotcode/robot/diagnostics/namespace_analyzer.py

@@ -61,6 +61,7 @@ from ..utils.variables import (
     InvalidVariableError,
     VariableMatcher,
     contains_variable,
+    environment_value_hash,
     is_number_literal,
     replace_curdir_in_variable_values,
     search_variable,
@@ -145,6 +146,8 @@ class NamespaceAnalyzer(Visitor):
         self._testcase_tag_references: Dict[str, Set[Location]] = defaultdict(set)
         self._metadata_references: Dict[str, Set[Location]] = defaultdict(set)
         self._testcase_metadata_references: Dict[str, Set[Location]] = defaultdict(set)
+        self._environment_set: Dict[str, bool] = {}
+        self._environment_values: Dict[str, Optional[str]] = {}
 
         # Phase 1+2 results (set by resolve())
         self._library_doc: ResourceDoc = cast(ResourceDoc, None)  # set by resolve()
@@ -245,6 +248,8 @@ class NamespaceAnalyzer(Visitor):
             self._metadata_references,
             self._testcase_metadata_references,
             self._scope_builder.build(self._variable_scope),
+            environment_set=self._environment_set,
+            environment_values=self._environment_values,
         )
 
     def _visit_VariableSection(self, node: VariableSection) -> None:  # noqa: N802
@@ -673,7 +678,10 @@ class NamespaceAnalyzer(Visitor):
                 and cast(EnvironmentVariableDefinition, var).default_value is None
             ):
                 env_name = var.name[2:-1]
-                if os.environ.get(env_name, None) is None:
+                # the namespace cache compares every read of the environment when it restores the analysis
+                env_value = os.environ.get(env_name, None)
+                self._environment_set[env_name] = env_value is not None
+                if env_value is None:
                     self._append_diagnostics(
                         range=range_from_token(var_token),
                         message=(
@@ -2039,7 +2047,9 @@ class NamespaceAnalyzer(Visitor):
                     return name_default
                 return False
             env_name, sep, default = env_inner.partition("=")
+            # the namespace cache compares every read of the environment when it restores the analysis
             env_val = os.environ.get(env_name)
+            self._environment_values[env_name] = environment_value_hash(env_val)
             if env_val is not None:
                 return env_val
             if sep:

robotcode/robot/diagnostics/semantic_analyzer/analyzer.py

@@ -98,6 +98,7 @@ from ...utils.variables import (
     InvalidVariableError,
     VariableMatcher,
     contains_variable,
+    environment_value_hash,
     is_number_literal,
     replace_curdir_in_variable_values,
     search_variable,
@@ -280,6 +281,8 @@ class SemanticAnalyzer(Visitor):
         self._testcase_tag_references: Dict[str, Set[Location]] = defaultdict(set)
         self._metadata_references: Dict[str, Set[Location]] = defaultdict(set)
         self._testcase_metadata_references: Dict[str, Set[Location]] = defaultdict(set)
+        self._environment_set: Dict[str, bool] = {}
+        self._environment_values: Dict[str, Optional[str]] = {}
 
         # Phase 1+2 results (set by resolve())
         self._library_doc: ResourceDoc = cast(ResourceDoc, None)
@@ -422,6 +425,8 @@ class SemanticAnalyzer(Visitor):
             self._metadata_references,
             self._testcase_metadata_references,
             self._scope_builder.build(self._variable_scope),
+            environment_set=self._environment_set,
+            environment_values=self._environment_values,
             semantic_model=self._semantic_model,
         )
 
@@ -2004,7 +2009,10 @@ class SemanticAnalyzer(Visitor):
                 and cast(EnvironmentVariableDefinition, var).default_value is None
             ):
                 env_name = var.name[2:-1]
-                if os.environ.get(env_name, None) is None:
+                # the namespace cache compares every read of the environment when it restores the analysis
+                env_value = os.environ.get(env_name, None)
+                self._environment_set[env_name] = env_value is not None
+                if env_value is None:
                     self._append_diagnostics(
                         range=range_from_token(var_token),
                         message=(
@@ -4456,7 +4464,9 @@ class SemanticAnalyzer(Visitor):
                     return name_default
                 return False
             env_name, sep, default = env_inner.partition("=")
+            # the namespace cache compares every read of the environment when it restores the analysis
             env_val = os.environ.get(env_name)
+            self._environment_values[env_name] = environment_value_hash(env_val)
             if env_val is not None:
                 return env_val
             if sep:

robotcode/robot/utils/markdownformatter.py

@@ -144,14 +144,18 @@ class LinkFormatter:
         return pre + self._get_link(url)
 
     def _get_image(self, src: str, title: Optional[str] = None) -> str:
-        return f"![{title or src}]({self._unquote_hash(src)})"
+        return f"![{title or src}]({self._target(src)})"
 
     def _get_link(self, href: str, content: Optional[str] = None) -> str:
-        return f"[{content or href}]({self._unquote_hash(href)})"
+        return f"[{content or href}]({self._target(href)})"
 
-    def _unquote_hash(self, target: str) -> str:
+    def _target(self, target: str) -> str:
         # `#` is escaped in the whole line before links are formatted, a link target needs it as it is
-        return target.replace("\\#", "#")
+        target = target.replace("\\#", "#")
+        # Markdown takes a target with spaces only in angle brackets; `<` is already escaped in the whole line
+        if " " in target:
+            return "<" + target.replace(">", "\\>") + ">"
+        return target
 
     def _quot(self, attr: str) -> str:
         return attr if '"' not in attr else attr.replace('"', "&quot;")

robotcode/robot/utils/variables.py

@@ -1,4 +1,5 @@
 import functools
+import hashlib
 from pathlib import Path
 from typing import Any, Optional, Sequence, Tuple, cast
 
@@ -275,3 +276,11 @@ def replace_curdir_in_variable_values(values: Sequence[str], source: str) -> Tup
     """Replace ${CURDIR} in variable values with the escaped parent directory of source."""
     curdir = str(Path(source).parent).replace("\\", "\\\\")
     return tuple(s.replace("${CURDIR}", curdir) for s in values)
+
+
+def environment_value_hash(value: Optional[str]) -> Optional[str]:
+    """The SHA-256 of the value of an environment variable, or None when it is not set.
+
+    What the analysis cache keeps instead of the value, so that no value of the environment ends up in it.
+    """
+    return hashlib.sha256(value.encode("utf-8", "surrogateescape")).hexdigest() if value is not None else None

{robotcode_robot-2.8.0.dev670.dist-info → robotcode_robot-2.9.0.dev51.dist-info}/METADATA

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

{robotcode_robot-2.8.0.dev670.dist-info → robotcode_robot-2.9.0.dev51.dist-info}/RECORD

@@ -1,31 +1,31 @@
 robotcode/robot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-robotcode/robot/__version__.py,sha256=H0IFmU7VH6n_W0CbM7UtSwMIjNMI6OcCSdI7uBsndDU,30
+robotcode/robot/__version__.py,sha256=68lI1Ud2IVxiSKwJTXlHsfwV7s6ASsCia4CPMEdJ8Ls,29
 robotcode/robot/py.typed,sha256=bWew9mHgMy8LqMu7RuqQXFXLBxh2CRx0dUbSx-3wE48,27
 robotcode/robot/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 robotcode/robot/config/loader.py,sha256=HLbkZem8JiBuy9Q5naghZddAuMPOn8Tk6UBgN2T3Uyc,9073
-robotcode/robot/config/model.py,sha256=i8EH_n_20U7eCNY81nWa7oTFAxKj9iSH5Sxm1vr8bOQ,112151
+robotcode/robot/config/model.py,sha256=2dRKRDQV50_k1PmX-7uhqrPTX7Z6oJq4PcAG4pBDRi8,115165
 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=4LC031CMJWVtKJm_UMYKVLGosFPR81rSAgqU1xs4Adc,1071
+robotcode/robot/diagnostics/analyzer_result.py,sha256=5pHW5Yf3C3rmaDvmM7tP0y_qwqLW3YHhkeVV-qDhxtg,1459
 robotcode/robot/diagnostics/data_cache.py,sha256=Yi52oQTUBFgcPK0UF3lDAj4mRFqoD_VOtrAUyRWXnrQ,18200
 robotcode/robot/diagnostics/diagnostic_rules.py,sha256=7b4vbGTEuxCef8AHTshV4XAJe75aR4-lJ5QEDyuZtcE,3558
 robotcode/robot/diagnostics/diagnostics_modifier.py,sha256=MftxJlUEDsn9ZiOsBDApXC2N-4OjXHSZj1Y9PXXlSAg,11742
-robotcode/robot/diagnostics/document_cache_helper.py,sha256=D5X6b3-smbZrlYz7E4b0pGDmMA9hCfQ_Da7cRslhx34,34841
-robotcode/robot/diagnostics/entities.py,sha256=1djksLkdhp2JeZJAc8sJR2fIBMECX6k9RW-q34pdDAQ,12062
+robotcode/robot/diagnostics/document_cache_helper.py,sha256=llwyocHMKrSpuooXMuBalwnG6hlY6YgMTIPFq2tHFr8,35462
+robotcode/robot/diagnostics/entities.py,sha256=vE5szceIL-ANqJPnAbqIebg3kLddE9OPhxwBL9iKP-M,11949
 robotcode/robot/diagnostics/errors.py,sha256=lqHDWrMNy3ZhuEIVxeEhaU0ns8PB6pVTQBfaMqRQ8L4,2733
-robotcode/robot/diagnostics/import_resolver.py,sha256=lqbJYm3i62nK-EB1tgQ-RZoUtJ6rkB9JX6AzSN-p9t4,33126
-robotcode/robot/diagnostics/imports_manager.py,sha256=SRSidp3KyPXvT7NollGu-nhYmVKon8hw2pXoQog9SlE,89243
+robotcode/robot/diagnostics/import_resolver.py,sha256=DZjUOD3uNxFAwsVUqrCTRhColjz9DRPetAvIb_Ccufs,32588
+robotcode/robot/diagnostics/imports_manager.py,sha256=opemApuCLgPNsnqVuYc9MefqHt42g_7Ozqhrmu_osH0,90401
 robotcode/robot/diagnostics/keyword_finder.py,sha256=nwTmjvhyu5H7HHzyk8gt-pny2K2xdH2qCNyKXwwXRnk,18998
-robotcode/robot/diagnostics/library_doc.py,sha256=MYztjgnOmXAPjXn7td651oWats2qDlPrLgCkmwpdSmU,153576
+robotcode/robot/diagnostics/library_doc.py,sha256=xJCFm1uMM2OFZqn6sJNfdjGZJ2WsQjGlRmlqDHv64uA,153571
 robotcode/robot/diagnostics/model_helper.py,sha256=_ySXwerkK5xvjWa82T0DFy8jpxRzcaavTJiAHnk2lXQ,29740
-robotcode/robot/diagnostics/namespace.py,sha256=EK_HH1uZoZFd5zZwo_Hc8TyvTts8AASmvJcsuJjGPgA,35443
-robotcode/robot/diagnostics/namespace_analyzer.py,sha256=HrYdY6DM2DvR3Jh9wB-RggbxLDgez5CLk_NRSOZQRcQ,103678
+robotcode/robot/diagnostics/namespace.py,sha256=Rcmjk3V0vcY-DUkgjkRyuOdYXurKaTEqXJLc6efYrwY,35489
+robotcode/robot/diagnostics/namespace_analyzer.py,sha256=dGAEbbznPJlFBKN4dLkMDU7w9xc0mYdmRARvRS3Zlwg,104331
 robotcode/robot/diagnostics/project_index.py,sha256=Oqs7kV279PixVS6rGeigPKXGJYGqJdTDmDBjU7ODDRA,11006
 robotcode/robot/diagnostics/scope_tree.py,sha256=UREHoFG7NWh6UTWxET1M5Jxz_XBjXaQJg1GUIYPctq0,8348
 robotcode/robot/diagnostics/variable_scope.py,sha256=bge49DM-1FfQYIeqK2DtBG7JAMm25mazZ_zjh0DoMmg,3096
 robotcode/robot/diagnostics/workspace_config.py,sha256=GlsR1VnUBHoLBvIZtUXkm1dBDFPT9qoiYZzwZlurmXM,3277
 robotcode/robot/diagnostics/semantic_analyzer/__init__.py,sha256=ObbJv-S8LDgkWKZtTZjISBodXxyoLdEiOjVYp5aYbT4,1689
-robotcode/robot/diagnostics/semantic_analyzer/analyzer.py,sha256=PrWfgnA2AveDaVpXQUQ-pyx5aDeIcQwA7q2b7K39_Uo,205496
+robotcode/robot/diagnostics/semantic_analyzer/analyzer.py,sha256=CkROVL_B3QsSULXkHkRDTddLCR0sswVVxEKCQUYk_qs,206149
 robotcode/robot/diagnostics/semantic_analyzer/enums.py,sha256=FIf3bHHqYY2etzpNrZTpZxGFsdtBE15lTssI1g8T2ro,8668
 robotcode/robot/diagnostics/semantic_analyzer/json_dump.py,sha256=2Yq3CLAKF5IEqKeFDoIYn-Ize_1Ucgz82ORkx3wAguY,13836
 robotcode/robot/diagnostics/semantic_analyzer/model.py,sha256=TTsrU_aDSC4JwbdypxSaGR79iCN071Y5VUMO8vGm5IE,20476
@@ -36,13 +36,13 @@ robotcode/robot/diagnostics/semantic_analyzer/variable_tokenizer.py,sha256=vBor3
 robotcode/robot/utils/__init__.py,sha256=-A0YeHv7e7WK1SId7Er7Vu6frrDYWopUrcyFlyxLmPY,396
 robotcode/robot/utils/ast.py,sha256=S9xyiJZee4Y5VcroNrGIIWp8f9sutb_1o4blAlCqzdg,11218
 robotcode/robot/utils/markdown_docs.py,sha256=jY3jT919TicVRMhcYo03dR0NzhGq0kEnDolBSPc-lNI,29548
-robotcode/robot/utils/markdownformatter.py,sha256=hThVK-L7_0-xcAtNNXvFeAaSzbNix0hP73t_BO_JCsc,14122
+robotcode/robot/utils/markdownformatter.py,sha256=hHilBaj1DzBV1tlNHyNfMvM3h92Six-15guhQy6edgU,14323
 robotcode/robot/utils/match.py,sha256=KgA6o6TbnQpOT1eAzEjhl_-FZ2XO07xiV0L7IYRzyzE,1125
 robotcode/robot/utils/robot_patching.py,sha256=jXHhnPvZx8hCQq4B_2uwX9j51Be_toWpUoTYYe8HjPo,1463
 robotcode/robot/utils/robot_path.py,sha256=ObLP8PqamTZAz5oi0eDXE_dnyZwAPXp4TJYm6ugeENs,2185
 robotcode/robot/utils/stubs.py,sha256=umugZYAyneFNgqRJBRMJPzm0u0B_TH8Sx_y-ykXnxpw,351
-robotcode/robot/utils/variables.py,sha256=M_JVe4DxV7ucL_iRW7VOQnSlY6I72NVhRfki4f3zMQY,9430
+robotcode/robot/utils/variables.py,sha256=9WnP3QqcHdq-zioJ_gJXJobw_2Gcto_rGPCUGmOH9YQ,9829
 robotcode/robot/utils/visitor.py,sha256=nP3O0qh3YYuxR6S8wYJRBFfNwIVgsgohURBlrnFkRYQ,2299
-robotcode_robot-2.8.0.dev670.dist-info/METADATA,sha256=stGbMKy2QKUTxnaz5wGC2_o8ls7f_buhefYjKA-dvVQ,2960
-robotcode_robot-2.8.0.dev670.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-robotcode_robot-2.8.0.dev670.dist-info/RECORD,,
+robotcode_robot-2.9.0.dev51.dist-info/METADATA,sha256=RziLuNl8hmcFuiRfMnuUYgOZm7OFM-E06dYl1ZNS6yE,2958
+robotcode_robot-2.9.0.dev51.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+robotcode_robot-2.9.0.dev51.dist-info/RECORD,,

{robotcode_robot-2.8.0.dev670.dist-info → robotcode_robot-2.9.0.dev51.dist-info}/WHEEL

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