robotcode-robot 2.8.0.dev548__tar.gz → 2.8.0.dev670__tar.gz

{robotcode_robot-2.8.0.dev548 → robotcode_robot-2.8.0.dev670}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: robotcode-robot
-Version: 2.8.0-dev.548
+Version: 2.8.0-dev.670
 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.548
+Requires-Dist: robotcode-core==2.8.0-dev.670
 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.dev548 → robotcode_robot-2.8.0.dev670}/pyproject.toml

@@ -32,7 +32,7 @@ dependencies = [
   "robotframework>=5.0.0",
   "tomli>=1.1.0; python_version < '3.11'",
   "platformdirs>=4.3",
-  "robotcode-core==2.8.0-dev.548",
+  "robotcode-core==2.8.0-dev.670",
 ]
 dynamic = ["version"]
 

robotcode_robot-2.8.0.dev670/src/robotcode/robot/__version__.py

@@ -0,0 +1 @@
+__version__ = "2.8.0-dev.670"

{robotcode_robot-2.8.0.dev548 → robotcode_robot-2.8.0.dev670}/src/robotcode/robot/config/model.py

@@ -3398,47 +3398,54 @@ class RobotConfig(RobotExtendBaseProfile):
             else:
                 verbose_callback("No profiles selected.")
 
+        # whether a selected profile is enabled; None when its condition has an error, which is reported only once
+        enabled_states: Dict[str, Optional[bool]] = {}
+
+        def is_enabled(name: str) -> Optional[bool]:
+            if name not in enabled_states:
+                try:
+                    enabled_states[name] = selected_profiles[name][0].is_enabled()
+                except EvaluationError as e:
+                    message = f"Error evaluating 'enabled' condition for profile '{name}': {e}"
+
+                    if error_callback is None:
+                        raise ValueError(message) from e
+
+                    error_callback(message)
+                    enabled_states[name] = None
+            return enabled_states[name]
+
+        # a profile is used when it is enabled and selected itself, or when one of the profiles that inherit it is
+        # used, so that a disabled profile brings none of the profiles it inherits from along, at any depth
+        used_states: Dict[str, bool] = {}
+
+        def is_used(name: str) -> bool:
+            if name not in used_states:
+                parents = selected_profiles[name][1]
+                used_states[name] = bool(is_enabled(name)) and (
+                    parents is None or any(is_used(parent_name) for parent_name, _ in parents)
+                )
+            return used_states[name]
+
         for profile_name, (profile, parent_profiles) in sorted(
             selected_profiles.items(), key=lambda x: x[1][0].precedence or 0
         ):
-            try:
-                if not profile.is_enabled():
-                    if verbose_callback:
-                        verbose_callback(f'Skipping profile "{profile_name}" because it\'s disabled.')
-                    continue
-            except EvaluationError as e:
-                message = f"Error evaluating 'enabled' condition for profile '{profile_name}': {e}"
-
-                if error_callback is None:
-                    raise ValueError(message) from e
-
-                error_callback(message)
+            profile_enabled = is_enabled(profile_name)
+            if profile_enabled is None:
                 continue
 
-            if parent_profiles is not None:
-                disabled_profiles = []
-                skip = False
-                for parent_profile in parent_profiles:
-                    try:
-                        if not parent_profile[1].is_enabled():
-                            disabled_profiles.append(parent_profile[0])
-                    except EvaluationError as e:
-                        message = f"Error evaluating 'enabled' condition for profile '{parent_profile[0]}': {e}"
-
-                        if error_callback is None:
-                            raise ValueError(message) from e
-
-                        error_callback(message)
-                        skip = True
-                        break
+            if not profile_enabled:
+                if verbose_callback:
+                    verbose_callback(f'Skipping profile "{profile_name}" because it\'s disabled.')
+                continue
 
-                if skip or len(disabled_profiles) == len(parent_profiles):
-                    if verbose_callback:
-                        verbose_callback(
-                            f"Skipping profile inherited '{profile_name}' because no parent is enabled."
-                            f" Disabled profiles: {', '.join(disabled_profiles)}."
-                        )
-                    continue
+            if not is_used(profile_name):
+                if verbose_callback:
+                    verbose_callback(
+                        f"Skipping inherited profile '{profile_name}' because none of the profiles that inherit it"
+                        f" is used: {', '.join(sorted(name for name, _ in parent_profiles or ()))}."
+                    )
+                continue
 
             if verbose_callback:
                 verbose_callback(f'Using profile "{profile_name}".')

{robotcode_robot-2.8.0.dev548 → robotcode_robot-2.8.0.dev670}/src/robotcode/robot/diagnostics/entities.py

@@ -360,6 +360,26 @@ class VariablesEntry(LibraryEntry):
         )
 
 
+def library_entry_key(entry: LibraryEntry) -> str:
+    """The key of a library entry in the namespace disk cache: of a
+    `namespace_references` entry in `NamespaceData` and of a `lib_entry` in
+    a pickled semantic model.
+
+    Like `LibraryEntry.__hash__`, it includes the import position, so it tells
+    apart the entries of one library: the implicitly imported BuiltIn and an
+    explicit import of it, or a library imported by a resource file and the
+    same library imported directly.
+    """
+
+    def position(r: Range) -> str:
+        return f"{r.start.line}.{r.start.character}-{r.end.line}.{r.end.character}"
+
+    return (
+        f"{type(entry).__name__}:{entry.name}:{entry.import_name}:{entry.args!r}:{entry.alias or ''}"
+        f":{entry.import_source or ''}:{position(entry.import_range)}:{position(entry.alias_range)}"
+    )
+
+
 @dataclass(slots=True)
 class TestCaseDefinition(SourceEntity):
     name: str

{robotcode_robot-2.8.0.dev548 → robotcode_robot-2.8.0.dev670}/src/robotcode/robot/diagnostics/library_doc.py

@@ -1930,13 +1930,16 @@ class LibraryDoc:
     def _get_title_markdown(self, header_level: int) -> str:
         result = f"#{'#' * header_level} {(self.type.capitalize()) if self.type else 'Unknown'} *{self.name}*\n\n"
 
-        if self.version or self.scope:
+        # resource and suite files show GLOBAL, as in Libdoc; variable files have no scope in Robot Framework
+        scope = self.scope if self.type != "VARIABLES" else ""
+
+        if self.version or scope:
             result += "|  |  |\n| :--- | :--- |\n"
 
             if self.version:
                 result += f"| **Library Version:** | {self.version} |\n"
-            if self.scope:
-                result += f"| **Library Scope:** | {self.scope} |\n"
+            if scope:
+                result += f"| **Library Scope:** | {scope} |\n"
 
             result += "\n\n"
 

{robotcode_robot-2.8.0.dev548 → robotcode_robot-2.8.0.dev670}/src/robotcode/robot/diagnostics/namespace.py

@@ -44,6 +44,7 @@ from .entities import (
     VariableDefinition,
     VariablesEntry,
     VariablesImport,
+    library_entry_key,
 )
 from .errors import DIAGNOSTICS_SOURCE_NAME
 from .import_resolver import FailedImport, ImportResolver
@@ -147,24 +148,6 @@ class NamespaceData:
     variable_definitions: Dict[str, VariableDefinition] = field(default_factory=dict)
 
 
-def _namespace_reference_key(entry: LibraryEntry) -> str:
-    """The key of a `namespace_references` entry in `NamespaceData`.
-
-    Like `LibraryEntry.__hash__`, it includes the import position, so it tells
-    apart the entries of one library: the implicitly imported BuiltIn and an
-    explicit import of it, or a library imported by a resource file and the
-    same library imported directly.
-    """
-
-    def position(r: Range) -> str:
-        return f"{r.start.line}.{r.start.character}-{r.end.line}.{r.end.character}"
-
-    return (
-        f"{type(entry).__name__}:{entry.name}:{entry.import_name}:{entry.args!r}:{entry.alias or ''}"
-        f":{entry.import_source or ''}:{position(entry.import_range)}:{position(entry.alias_range)}"
-    )
-
-
 class Namespace:
     """Data container holding all results of a namespace build.
 
@@ -516,7 +499,7 @@ class Namespace:
         """
         # Build namespace_references key from LibraryEntry identity
         ns_refs: Dict[str, Set[Location]] = {
-            _namespace_reference_key(entry): locs for entry, locs in self._namespace_references.items()
+            library_entry_key(entry): locs for entry, locs in self._namespace_references.items()
         }
 
         # Collect all referenced variable definitions for stable_id → object lookup
@@ -637,6 +620,11 @@ class Namespace:
         for kw in library_doc.keywords:
             kw_by_id[kw.stable_id] = kw
 
+        # the init of a variables file, which the import statement of the semantic model refers to
+        for variables_entry in resolved.variables_imports.values():
+            for kw in variables_entry.library_doc.inits:
+                kw_by_id[kw.stable_id] = kw
+
         # Variables from scope layers (command_line, own, imported, builtin)
         for var in scope.iter_all():
             var_by_id[var.stable_id] = var
@@ -685,7 +673,7 @@ class Namespace:
         # the other maps add the implicit default libraries and the imports of
         # resource files.
         all_entries: Dict[str, LibraryEntry] = {
-            _namespace_reference_key(entry): entry
+            library_entry_key(entry): entry
             for entry in itertools.chain(
                 resolved.libraries.values(),
                 resolved.resources.values(),

{robotcode_robot-2.8.0.dev548 → robotcode_robot-2.8.0.dev670}/src/robotcode/robot/diagnostics/namespace_analyzer.py

@@ -1458,7 +1458,10 @@ class NamespaceAnalyzer(Visitor):
                     ignore_errors=True,
                 )
 
-                if not matcher.is_assign(allow_assign_mark=True, allow_nested=True) or matcher.name is None:
+                if (
+                    not matcher.is_assign(allow_assign_mark=True, allow_nested=True, allow_items=True)
+                    or matcher.name is None
+                ):
                     return
 
                 if RF_VERSION >= (7, 0) and contains_variable(matcher.base, "$@&%"):
@@ -1496,6 +1499,19 @@ class NamespaceAnalyzer(Visitor):
                 stripped_name_token = strip_variable_token(assign_token, matcher=matcher, parse_type=True)
 
                 if matcher.items:
+                    # Robot Framework resolves the variables in the index; the search without types keeps a type
+                    # in the base, so the index starts after it
+                    raw = search_variable(matcher.string, ignore_errors=True)
+                    items_start = raw.start + len(raw.identifier) + len(raw.base) + 2
+                    items_token = Token(
+                        Token.ARGUMENT,
+                        matcher.string[items_start : raw.end],
+                        assign_token.lineno,
+                        assign_token.col_offset + items_start,
+                    )
+                    for var_token, var in self._iter_variables_from_token(items_token):
+                        self._handle_find_variable_result(var_token, var)
+
                     existing_var = self._find_variable(name)
                     if existing_var is None:
                         self._handle_find_variable_result(
@@ -1611,18 +1627,21 @@ class NamespaceAnalyzer(Visitor):
                 if not matcher.is_scalar_assign():
                     return
 
-                if (
-                    next(
-                        (
-                            k
-                            for k, v in self._variables.items()
-                            if k == matcher
-                            and v.type in [VariableDefinitionType.ARGUMENT, VariableDefinitionType.LOCAL_VARIABLE]
-                        ),
-                        None,
+                existing_var = next(
+                    (
+                        v
+                        for k, v in self._variables.items()
+                        if k == matcher
+                        and v.type in [VariableDefinitionType.ARGUMENT, VariableDefinitionType.LOCAL_VARIABLE]
+                    ),
+                    None,
+                )
+                if existing_var is not None:
+                    # EXCEPT AS sets the existing variable again, like a FOR variable of that name
+                    self._variable_references[existing_var].add(
+                        Location(self._document_uri, range_from_token(strip_variable_token(variable_token)))
                     )
-                    is None
-                ):
+                else:
                     var_def = LocalVariableDefinition(
                         name=variable_token.value,
                         name_token=strip_variable_token(variable_token),

{robotcode_robot-2.8.0.dev548 → robotcode_robot-2.8.0.dev670}/src/robotcode/robot/diagnostics/semantic_analyzer/analyzer.py

@@ -405,6 +405,8 @@ class SemanticAnalyzer(Visitor):
             )
             self._logger.exception(e)
 
+        self._mark_argument_uses()
+
         # Build indexes
         self._semantic_model.build_index()
 
@@ -423,6 +425,38 @@ class SemanticAnalyzer(Visitor):
             semantic_model=self._semantic_model,
         )
 
+    def _mark_argument_uses(self) -> None:
+        """Mark every variable token whose name the analysis resolved to an argument from `[Arguments]`, the same
+        resolution Find References and Rename use; embedded arguments stay unmarked."""
+        starts = {
+            (location.range.start.line, location.range.start.character)
+            for var, locations in self._variable_references.items()
+            if isinstance(var, ArgumentDefinition) and not isinstance(var, EmbeddedArgumentDefinition)
+            for location in locations
+        }
+        if starts:
+            for stmt in self._semantic_model.statements:
+                self._mark_argument_uses_in_statement(stmt, starts)
+
+    def _mark_argument_uses_in_statement(self, stmt: SemanticStatement, starts: Set[Tuple[int, int]]) -> None:
+        for token in stmt.tokens:
+            self._mark_argument_uses_in_token(token, starts)
+        # the inner calls of a Run Keyword variant have tokens of their own
+        if isinstance(stmt, RunKeywordCallStatement):
+            for inner in stmt.inner_calls:
+                self._mark_argument_uses_in_statement(inner, starts)
+
+    def _mark_argument_uses_in_token(self, token: SemanticToken, starts: Set[Tuple[int, int]]) -> None:
+        for sub in token.sub_tokens or ():
+            self._mark_argument_uses_in_token(sub, starts)
+            # a reference covers the name of the variable, its base
+            if (
+                token.kind is TokenKind.VARIABLE
+                and sub.kind is TokenKind.VARIABLE_BASE
+                and (sub.range.start.line, sub.range.start.character) in starts
+            ):
+                token.modifiers = (token.modifiers or frozenset()) | {TokenModifier.ARGUMENT}
+
     # --- Semantic Model helpers ---
 
     # Statement kinds that act as the block-header for control-flow blocks.
@@ -3176,7 +3210,10 @@ class SemanticAnalyzer(Visitor):
                     ignore_errors=True,
                 )
 
-                if not matcher.is_assign(allow_assign_mark=True, allow_nested=True) or matcher.name is None:
+                if (
+                    not matcher.is_assign(allow_assign_mark=True, allow_nested=True, allow_items=True)
+                    or matcher.name is None
+                ):
                     return
 
                 if RF_VERSION >= (7, 0) and contains_variable(matcher.base, "$@&%"):
@@ -3220,6 +3257,19 @@ class SemanticAnalyzer(Visitor):
                 stripped_name_token = strip_variable_token(assign_token, matcher=matcher, parse_type=True)
 
                 if matcher.items:
+                    # Robot Framework resolves the variables in the index; the search without types keeps a type
+                    # in the base, so the index starts after it
+                    raw = search_variable(matcher.string, ignore_errors=True)
+                    items_start = raw.start + len(raw.identifier) + len(raw.base) + 2
+                    items_token = Token(
+                        Token.ARGUMENT,
+                        matcher.string[items_start : raw.end],
+                        assign_token.lineno,
+                        assign_token.col_offset + items_start,
+                    )
+                    for var_token, var in self._iter_variables_from_token(items_token):
+                        self._handle_find_variable_result(var_token, var)
+
                     existing_var = self._find_variable(name)
                     if existing_var is None:
                         self._handle_find_variable_result(
@@ -3468,18 +3518,21 @@ class SemanticAnalyzer(Visitor):
                 if not matcher.is_scalar_assign():
                     return
 
-                if (
-                    next(
-                        (
-                            k
-                            for k, v in self._variables.items()
-                            if k == matcher
-                            and v.type in [VariableDefinitionType.ARGUMENT, VariableDefinitionType.LOCAL_VARIABLE]
-                        ),
-                        None,
+                existing_var = next(
+                    (
+                        v
+                        for k, v in self._variables.items()
+                        if k == matcher
+                        and v.type in [VariableDefinitionType.ARGUMENT, VariableDefinitionType.LOCAL_VARIABLE]
+                    ),
+                    None,
+                )
+                if existing_var is not None:
+                    # EXCEPT AS sets the existing variable again, like a FOR variable of that name
+                    self._variable_references[existing_var].add(
+                        Location(self._document_uri, range_from_token(strip_variable_token(variable_token)))
                     )
-                    is None
-                ):
+                else:
                     var_def = LocalVariableDefinition(
                         name=variable_token.value,
                         name_token=strip_variable_token(variable_token),

{robotcode_robot-2.8.0.dev548 → robotcode_robot-2.8.0.dev670}/src/robotcode/robot/diagnostics/semantic_analyzer/enums.py

@@ -194,6 +194,7 @@ class TokenModifier(Enum):
     EMBEDDED = "embedded"
     DECLARATION = "declaration"
     DOCUMENTATION = "documentation"
+    ARGUMENT = "argument"  # a variable that names an argument from the keyword's [Arguments], not an embedded one
 
 
 class ForFlavor(Enum):

{robotcode_robot-2.8.0.dev548 → robotcode_robot-2.8.0.dev670}/src/robotcode/robot/diagnostics/semantic_analyzer/model.py

@@ -1,10 +1,12 @@
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Dict, FrozenSet, List, Optional
 
-from .enums import NodeKind
+from .enums import NodeKind, TokenKind
 from .nodes import (
     DefinitionBlock,
     DefinitionStatement,
+    KeywordCallStatement,
+    RunKeywordCallStatement,
     SemanticBlock,
     SemanticNode,
     SemanticStatement,
@@ -23,6 +25,13 @@ _SECTION_KINDS: FrozenSet[NodeKind] = frozenset(
     }
 )
 
+# The namespace and the name of a keyword reference; the span from the first to the
+# last of them also covers the "." between. An inner call of a Run Keyword variant
+# carries its name as KEYWORD_INNER.
+_KEYWORD_REFERENCE_KINDS: FrozenSet[TokenKind] = frozenset(
+    {TokenKind.NAMESPACE, TokenKind.KEYWORD, TokenKind.KEYWORD_INNER}
+)
+
 if TYPE_CHECKING:
     from ...utils.variables import VariableMatcher
     from ..entities import VariableDefinition
@@ -193,6 +202,37 @@ class SemanticModel:
                     SemanticModel._collect_token_path(sub, line, col, path)
                     return
 
+    def keyword_call_at(self, line: int, col: int) -> Optional[KeywordCallStatement]:
+        """Get the keyword call whose keyword reference covers a position.
+
+        The keyword reference is the namespace and the keyword name with the
+        "." between them, without a BDD prefix; its end counts as covered, as
+        in the legacy check of a keyword token. Besides the call that
+        `statement_at()` returns, this finds the calls in the body of an
+        inline IF, which are statements of their own on the line, and the
+        inner calls of a Run Keyword variant, searched recursively.
+        O(n) in statements.
+        """
+        for stmt in self.statements:
+            if isinstance(stmt, KeywordCallStatement) and stmt.line_start <= line <= stmt.line_end:
+                call = self._keyword_call_covering(stmt, line, col)
+                if call is not None:
+                    return call
+        return None
+
+    @staticmethod
+    def _keyword_call_covering(stmt: KeywordCallStatement, line: int, col: int) -> Optional[KeywordCallStatement]:
+        reference = [token for token in stmt.tokens if token.kind in _KEYWORD_REFERENCE_KINDS]
+        if reference and reference[0].line == line:
+            if reference[0].col_offset <= col <= reference[-1].col_offset + reference[-1].length:
+                return stmt
+        if isinstance(stmt, RunKeywordCallStatement):
+            for inner in stmt.inner_calls:
+                call = SemanticModel._keyword_call_covering(inner, line, col)
+                if call is not None:
+                    return call
+        return None
+
     def enclosing_definition(self, line: int) -> Optional["DefinitionBlock | DefinitionStatement"]:
         """Find the enclosing definition (Keyword/TestCase) containing the given line.
 

{robotcode_robot-2.8.0.dev548 → robotcode_robot-2.8.0.dev670}/src/robotcode/robot/diagnostics/semantic_analyzer/nodes.py

@@ -1,8 +1,9 @@
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, FrozenSet, List, Optional, Tuple
+from typing import TYPE_CHECKING, Any, Dict, FrozenSet, List, Optional, Tuple
 
 from robotcode.core.lsp.types import Position, Range
 
+from ..entities import library_entry_key
 from .enums import (
     ForFlavor,
     ForZipMode,
@@ -19,6 +20,16 @@ if TYPE_CHECKING:
     from ..library_doc import ArgumentSpec, KeywordDoc
 
 
+def _slot_values(node: object) -> Dict[str, Any]:
+    """The values of all slots of a node, the base of a statement's pickled state."""
+    return {slot: getattr(node, slot) for cls in type(node).__mro__ for slot in getattr(cls, "__slots__", ())}
+
+
+def _set_slot_values(node: object, state: Dict[str, Any]) -> None:
+    for slot, value in state.items():
+        setattr(node, slot, value)
+
+
 @dataclass(slots=True)
 class SemanticToken:
     """A single resolved token in the Semantic Model.
@@ -136,6 +147,21 @@ class KeywordCallStatement(SemanticStatement):
     # Variables that receive the return value: ${result}=    My Keyword
     assign_variables: List[SemanticToken] = field(default_factory=list)
 
+    def __getstate__(self) -> Dict[str, Any]:
+        # The namespace disk cache stores ids for the keyword and the library
+        # entry, which belong to the analysis of the imports;
+        # `resolve_references()` maps them back to the restored namespace's
+        # objects. Inner calls replace their own references.
+        state = _slot_values(self)
+        if self.keyword_doc is not None:
+            state["keyword_doc"] = self.keyword_doc.stable_id
+        if self.lib_entry is not None:
+            state["lib_entry"] = library_entry_key(self.lib_entry)
+        return state
+
+    def __setstate__(self, state: Dict[str, Any]) -> None:
+        _set_slot_values(self, state)
+
 
 @dataclass(slots=True)
 class RunKeywordCallStatement(KeywordCallStatement):
@@ -274,6 +300,18 @@ class ImportStatement(SemanticStatement):
     # second AST walk + libdoc lookup.
     init_keyword_doc: Optional["KeywordDoc"] = None
 
+    def __getstate__(self) -> Dict[str, Any]:
+        # ids in the namespace disk cache, see `KeywordCallStatement.__getstate__`
+        state = _slot_values(self)
+        if self.lib_entry is not None:
+            state["lib_entry"] = library_entry_key(self.lib_entry)
+        if self.init_keyword_doc is not None:
+            state["init_keyword_doc"] = self.init_keyword_doc.stable_id
+        return state
+
+    def __setstate__(self, state: Dict[str, Any]) -> None:
+        _set_slot_values(self, state)
+
 
 # --- Settings ---
 
@@ -328,6 +366,16 @@ class TemplateDataStatement(SemanticStatement):
 
     template_keyword_doc: Optional["KeywordDoc"] = None
 
+    def __getstate__(self) -> Dict[str, Any]:
+        # an id in the namespace disk cache, see `KeywordCallStatement.__getstate__`
+        state = _slot_values(self)
+        if self.template_keyword_doc is not None:
+            state["template_keyword_doc"] = self.template_keyword_doc.stable_id
+        return state
+
+    def __setstate__(self, state: Dict[str, Any]) -> None:
+        _set_slot_values(self, state)
+
 
 # --- Blocks (structural containers) ---
 

{robotcode_robot-2.8.0.dev548 → robotcode_robot-2.8.0.dev670}/src/robotcode/robot/diagnostics/semantic_analyzer/serialization.py

@@ -5,13 +5,14 @@ stable_id strings back to live objects, and pickle helper utilities.
 
 The SemanticModel is designed to be pickle-friendly:
 - SemanticToken is a pure value object (no live references) - pickles natively
-- SemanticStatement subclasses hold keyword_doc/lib_entry references which
-  are live objects that cannot survive pickle/unpickle across sessions
+- SemanticStatement subclasses hold keyword_doc/lib_entry/init_keyword_doc/
+  template_keyword_doc references which are live objects that cannot survive
+  pickle/unpickle across sessions
 
 For serialization:
-1. Before pickling: replace live object references with stable_id strings
-2. Pickle normally
-3. After unpickling: call resolve_references() to restore live objects
+1. When pickled, the statements store stable_id strings and library entry
+   keys instead of these references (`__getstate__` in nodes.py)
+2. After unpickling: call resolve_references() to restore live objects
 """
 
 from typing import TYPE_CHECKING, Dict, Optional
@@ -24,6 +25,7 @@ from .nodes import (
     RunKeywordCallStatement,
     SemanticBlock,
     SemanticStatement,
+    TemplateDataStatement,
 )
 
 if TYPE_CHECKING:
@@ -39,10 +41,11 @@ def resolve_references(
 ) -> None:
     """Resolve stable_id strings back to live objects after unpickling.
 
-    After unpickling a SemanticModel, keyword_doc and lib_entry fields
-    contain stable_id strings instead of live objects. This function
+    After unpickling a SemanticModel, the keyword_doc, lib_entry,
+    init_keyword_doc and template_keyword_doc fields contain stable_id
+    strings and library entry keys instead of live objects. This function
     walks the model and replaces them with the actual objects from the
-    provided lookup dicts.
+    provided lookup dicts; an id that is not in them resolves to None.
 
     Args:
         model: The unpickled SemanticModel to resolve.
@@ -85,6 +88,9 @@ def _resolve_statement(
         _resolve_keyword_call(stmt, kw_by_id, entry_by_key)
     elif isinstance(stmt, ImportStatement):
         stmt.lib_entry = _resolve_entry(stmt.lib_entry, entry_by_key)
+        stmt.init_keyword_doc = _resolve_keyword(stmt.init_keyword_doc, kw_by_id)
+    elif isinstance(stmt, TemplateDataStatement):
+        stmt.template_keyword_doc = _resolve_keyword(stmt.template_keyword_doc, kw_by_id)
     elif isinstance(stmt, DefinitionStatement):
         if isinstance(stmt.arguments_spec, str):
             # arguments_spec should not be serialized as string,
@@ -98,9 +104,7 @@ def _resolve_keyword_call(
     entry_by_key: Dict[str, "LibraryEntry"],
 ) -> None:
     """Resolve references in a keyword call statement."""
-    if isinstance(stmt.keyword_doc, str):
-        stmt.keyword_doc = kw_by_id.get(stmt.keyword_doc)  # type: ignore[unreachable]
-
+    stmt.keyword_doc = _resolve_keyword(stmt.keyword_doc, kw_by_id)
     stmt.lib_entry = _resolve_entry(stmt.lib_entry, entry_by_key)
 
     if isinstance(stmt, RunKeywordCallStatement):
@@ -108,6 +112,16 @@ def _resolve_keyword_call(
             _resolve_keyword_call(inner, kw_by_id, entry_by_key)
 
 
+def _resolve_keyword(
+    keyword_doc: Optional["KeywordDoc"],
+    kw_by_id: Dict[str, "KeywordDoc"],
+) -> Optional["KeywordDoc"]:
+    """Resolve a single keyword reference."""
+    if isinstance(keyword_doc, str):
+        return kw_by_id.get(keyword_doc)  # type: ignore[unreachable]
+    return keyword_doc
+
+
 def _resolve_entry(
     entry: Optional["LibraryEntry"],
     entry_by_key: Dict[str, "LibraryEntry"],

robotcode_robot-2.8.0.dev548/src/robotcode/robot/__version__.py

@@ -1 +0,0 @@
-__version__ = "2.8.0-dev.548"