robotframework-robocop 9.1.2__tar.gz → 9.2.0__tar.gz

robotframework_robocop-9.2.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "9.2.0"
+}

{robotframework_robocop-9.1.2 → robotframework_robocop-9.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: robotframework-robocop
-Version: 9.1.2
+Version: 9.2.0
 Summary: Static code analysis tool (linter) and code formatter for Robot Framework
 Project-URL: Bug tracker, https://github.com/MarketSquare/robotframework-robocop/issues
 Project-URL: Source code, https://github.com/MarketSquare/robotframework-robocop

{robotframework_robocop-9.1.2 → robotframework_robocop-9.2.0}/docs/releasenotes/changelog.md

@@ -1,5 +1,18 @@
 # Release notes
 
+## [9.2.0](https://github.com/MarketSquare/robotframework-robocop/compare/v9.1.2...v9.2.0) (2026-11-06)
+
+
+### Features
+
+* support embedded robot code in markdown and python files ([#1932](https://github.com/MarketSquare/robotframework-robocop/issues/1932)) ([6e81470](https://github.com/MarketSquare/robotframework-robocop/commit/6e81470b16e07942dc4ad062cade954b6c2c77c2))
+
+
+### Bug Fixes
+
+* handle Set Local Variable in variable naming rules ([#1953](https://github.com/MarketSquare/robotframework-robocop/issues/1953)) ([57f1cce](https://github.com/MarketSquare/robotframework-robocop/commit/57f1cce9ac48138b016113d6b353a39135cfc564))
+* remove jinja syntax from unused-resource rule docs ([#1960](https://github.com/MarketSquare/robotframework-robocop/issues/1960)) ([d98afa6](https://github.com/MarketSquare/robotframework-robocop/commit/d98afa69f2977df3fdb46220f73c7f2a92538346))
+
 ## [9.1.2](https://github.com/MarketSquare/robotframework-robocop/compare/v9.1.1...v9.1.2) (2026-10-23)
 
 

{robotframework_robocop-9.1.2 → robotframework_robocop-9.2.0}/docs/rules_list.md

@@ -3921,7 +3921,7 @@ Example of rule violation:
 A resource is considered used when the file uses any keyword or variable defined in it, or in any resource it
 imports itself, since resource imports are transitive in Robot Framework. Variables are also recognized when
 used with the extended variable syntax (``${var.attr}``, ``${var['key']}``), item access (``${var}[key]``) or in
-Python expressions (``$var`` in ``IF`` conditions, ``Evaluate`` or ``${{ }}``).
+Python expressions (``$var`` in ``IF`` conditions, ``Evaluate`` or inline Python evaluation in variables).
 
 To avoid false positives, imports are not reported when:
 

robotframework_robocop-9.2.0/docs/user_guide/embedded_code.md

@@ -0,0 +1,62 @@
+# Embedded Robot Framework code
+
+Robocop can lint and format Robot Framework code that is embedded in other files:
+
+- **Markdown** files (`.md`, `.markdown`) – fenced code blocks tagged with ` ```robotframework ` (or ` ```robot `).
+- **Python** files (`.py`) – the same fenced blocks placed inside docstrings, as used for runnable examples in
+  library documentation.
+
+This mirrors the embedded execution support that Robot Framework added in version 7.5, but Robocop does its own
+parsing, so it works regardless of the installed Robot Framework version.
+
+A single file may contain zero, one, or many code blocks. **Each block is treated as an independent suite** – it is
+linted and formatted on its own, and the surrounding prose, fences and indentation are left untouched.
+
+````markdown
+# Example
+
+Some documentation describing the test below.
+
+```robotframework
+*** Test Cases ***
+Example Test
+    Log    message
+```
+````
+
+## Opting in
+
+Embedded files are **not** analyzed by default. There are two ways to opt in:
+
+1. **Pass the file directly** on the command line:
+
+    ```bash
+    robocop check docs/example.md
+    robocop format library.py
+    ```
+
+2. **Add the extension to the include patterns** so the files are picked up during directory scans:
+
+    ```bash
+    robocop check --include "*.md" --include "*.py" .
+    ```
+
+    or in the configuration file:
+
+    ```toml
+    [tool.robocop]
+    include = ["*.robot", "*.resource", "*.md"]
+    ```
+
+## Positions and fixes
+
+Reported issues point at the **exact physical line and column** of the code inside the original file, not at a
+position within an extracted block. Automatic fixes (`--fix`) and formatting are written back in place, preserving
+the block indentation (for example the indentation of a fenced block inside a Python docstring) and the file's line
+endings.
+
+## Notes
+
+- Because every block is an independent suite, suite-level rules (such as *missing documentation in suite*) are
+  reported once per block.
+- Blocks tagged with any language other than `robotframework`/`robot` are ignored.

{robotframework_robocop-9.1.2 → robotframework_robocop-9.2.0}/mkdocs.yml

@@ -37,6 +37,7 @@ nav:
   - Robocop: index.md
   - User Guide:
       - "Getting started": user_guide/intro.md
+      - "Embedded code (Markdown, Python)": user_guide/embedded_code.md
       - "Migrate to Robocop 6.0": user_guide/migrate_to_robocop6.md
       - "Python API Reference": user_guide/python_api.md
   - Linter:

{robotframework_robocop-9.1.2 → robotframework_robocop-9.2.0}/pyproject.toml

@@ -188,6 +188,7 @@ lint.unfixable = [
 ]
 extend-exclude = [
     "tests/linter/test_data/",
+    "tests/embedded/test_data/",
     "docs/"
 ]
 [tool.ruff.lint.extend-per-file-ignores]

robotframework_robocop-9.2.0/src/robocop/__init__.py

@@ -0,0 +1 @@
+__version__ = "9.2.0"  # x-release-please-version

{robotframework_robocop-9.1.2 → robotframework_robocop-9.2.0}/src/robocop/config/manager.py

@@ -11,7 +11,7 @@ from robocop.cache import RobocopCache
 from robocop.config.builder import ConfigBuilder
 from robocop.config.parser import read_toml_config
 from robocop.config.schema import Config, RawConfig
-from robocop.source_file import SourceFile
+from robocop.source_file import SourceFile, build_source_file
 
 if TYPE_CHECKING:
     from collections.abc import Generator, Sequence
@@ -291,4 +291,4 @@ class ConfigManager:
             if source.is_dir():
                 self.resolve_paths(list(source.iterdir()), target=target)
             elif source.is_file():
-                target[source] = self._paths.get(source) or SourceFile(path=source, config=config)
+                target[source] = self._paths.get(source) or build_source_file(source, config)

robotframework_robocop-9.2.0/src/robocop/embedded.py

@@ -0,0 +1,220 @@
+"""
+Extraction of embedded Robot Framework code blocks from Markdown and Python files.
+
+Robot Framework 7.5 added support for executing Robot code embedded in Markdown files. The code lives in fenced
+code blocks tagged with ``robotframework`` (or ``robot``)::
+
+    ```robotframework
+    *** Test Cases ***
+    Example
+        Log    message
+    ```
+
+The same convention is used to embed runnable examples in Python docstrings (see Robot Framework's own
+``Collections`` library). Robocop supports both sources.
+
+Unlike Robot Framework -- which concatenates every block and throws away line positions -- Robocop needs to keep
+the exact physical position (line and column) of each block so that reported issues and applied fixes point at the
+right place in the original file. This module extracts blocks while preserving that information.
+
+The extraction is intentionally line based (it does not parse Python syntax). A fenced ``robotframework`` block is
+recognized wherever it appears, which covers both Markdown prose and Python docstrings. Blocks nested inside
+indented docstrings keep their common indentation, which is stripped when the block is turned into a Robot model
+and re-applied when the file is written back.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from robot.api.parsing import ModelVisitor
+
+if TYPE_CHECKING:
+    from robot.parsing.model import File
+    from robot.parsing.model.statements import Statement
+
+# Supported code block languages (case-insensitive), mirroring Robot Framework's Markdown parser.
+ROBOT_BLOCK_LANGUAGES = frozenset({"robotframework", "robot"})
+
+# File extensions that may contain embedded Robot Framework code blocks.
+MARKDOWN_EXTENSIONS = frozenset({".md", ".markdown"})
+PYTHON_EXTENSIONS = frozenset({".py"})
+EMBEDDED_EXTENSIONS = MARKDOWN_EXTENSIONS | PYTHON_EXTENSIONS
+
+# Opening fence: optional indentation, at least three backticks or tildes, then the language token.
+_FENCE_OPEN = re.compile(r"(?P<indent>[ \t]*)(?P<fence>`{3,}|~{3,})[ \t]*(?P<lang>\S+)")
+
+
+@dataclass
+class RobotCodeBlock:
+    """
+    A single embedded Robot Framework code block located inside a Markdown or Python file.
+
+    Attributes:
+        start_line: 1-indexed physical line number of the first code line (line just after the opening fence).
+        end_line: 1-indexed physical line number of the last code line (inclusive). For an empty block this is
+            ``start_line - 1`` so that ``range(start_line, end_line + 1)`` is empty.
+        indent: Common leading whitespace shared by every non-blank code line. It is stripped when building the
+            Robot model and re-applied when writing changes back to the file.
+        fence_open_line: 1-indexed physical line number of the opening fence.
+        fence_close_line: 1-indexed physical line number of the closing fence, or ``None`` if the block is closed
+            implicitly by the end of the file.
+
+    """
+
+    start_line: int
+    end_line: int
+    indent: str
+    fence_open_line: int
+    fence_close_line: int | None
+
+    @property
+    def is_empty(self) -> bool:
+        return self.end_line < self.start_line
+
+    def contains(self, lineno: int) -> bool:
+        """Return whether the given 1-indexed physical line is a code line of this block."""
+        return self.start_line <= lineno <= self.end_line
+
+
+def is_embedded_extension(suffix: str) -> bool:
+    """Return whether files with the given suffix may contain embedded Robot Framework code blocks."""
+    return suffix.lower() in EMBEDDED_EXTENSIONS
+
+
+def _common_indent(lines: list[str]) -> str:
+    """
+    Return the longest leading whitespace shared by every non-blank line.
+
+    Blank lines (only whitespace or empty) are ignored, mirroring :func:`textwrap.dedent`.
+    """
+    common: str | None = None
+    for line in lines:
+        stripped = line.lstrip(" \t")
+        if not stripped or stripped in ("\n", "\r\n", "\r"):
+            continue
+        indent = line[: len(line) - len(stripped)]
+        if common is None:
+            common = indent
+            continue
+        # Shrink the common prefix to the shared portion.
+        shared_len = 0
+        for a, b in zip(common, indent, strict=False):
+            if a != b:
+                break
+            shared_len += 1
+        common = common[:shared_len]
+        if not common:
+            break
+    return common or ""
+
+
+def extract_robot_blocks(lines: list[str]) -> list[RobotCodeBlock]:
+    """
+    Find all embedded Robot Framework code blocks in the given file lines.
+
+    Args:
+        lines: The physical file lines, including line endings (as returned by ``file.readlines()``).
+
+    Returns:
+        List of :class:`RobotCodeBlock`, in file order. Empty if the file has no Robot code blocks.
+
+    """
+    blocks: list[RobotCodeBlock] = []
+    total = len(lines)
+    index = 0
+    while index < total:
+        match = _FENCE_OPEN.match(lines[index])
+        if not match or match.group("lang").lower() not in ROBOT_BLOCK_LANGUAGES:
+            index += 1
+            continue
+        fence = match.group("fence")
+        fence_char = re.escape(fence[0])
+        # Closing fence: at least as many of the same fence character, optionally surrounded by whitespace.
+        close_re = re.compile(rf"[ \t]*{fence_char}{{{len(fence)},}}[ \t]*$")
+        fence_open_line = index + 1
+        code_lines: list[str] = []
+        cursor = index + 1
+        while cursor < total and not close_re.match(lines[cursor].rstrip("\r\n")):
+            code_lines.append(lines[cursor])
+            cursor += 1
+        start_line = index + 2
+        end_line = cursor  # cursor is the closing fence (or EOF); last code line is cursor - 1 (0-indexed) -> cursor
+        fence_close_line = cursor + 1 if cursor < total else None
+        blocks.append(
+            RobotCodeBlock(
+                start_line=start_line,
+                end_line=end_line,
+                indent=_common_indent(code_lines),
+                fence_open_line=fence_open_line,
+                fence_close_line=fence_close_line,
+            )
+        )
+        index = cursor + 1
+    return blocks
+
+
+def strip_indent(line: str, indent: str) -> str:
+    """Remove up to ``indent`` leading characters from ``line`` (only if the line starts with that indentation)."""
+    if indent and line.startswith(indent):
+        return line[len(indent) :]
+    # Blank or shorter-indented lines: drop whatever leading whitespace overlaps the common indent.
+    stripped = line.lstrip(" \t")
+    leading = line[: len(line) - len(stripped)]
+    keep = leading[len(indent) :] if len(leading) > len(indent) else ""
+    return keep + stripped
+
+
+def reconstruct_source(lines: list[str], blocks: list[RobotCodeBlock]) -> str:
+    """
+    Build a Robot Framework source string that preserves physical line numbers.
+
+    Non-code lines (prose, fences, Python code) are replaced with blank lines and code lines are dedented by their
+    block indentation. The resulting model therefore has line numbers matching the original file, while section
+    headers and statements start at column 0 as Robot Framework requires.
+
+    Args:
+        lines: The physical file lines, including line endings.
+        blocks: Blocks extracted from ``lines`` via :func:`extract_robot_blocks`.
+
+    Returns:
+        Robot Framework source text with one entry per physical line.
+
+    """
+    reconstructed = ["\n"] * len(lines)
+    for block in blocks:
+        for lineno in range(block.start_line, block.end_line + 1):
+            original = lines[lineno - 1]
+            newline = _line_ending(original)
+            reconstructed[lineno - 1] = strip_indent(original.rstrip("\r\n"), block.indent) + newline
+    return "".join(reconstructed)
+
+
+def _line_ending(line: str) -> str:
+    if line.endswith("\r\n"):
+        return "\r\n"
+    if line.endswith("\n"):
+        return "\n"
+    if line.endswith("\r"):
+        return "\r"
+    return ""
+
+
+class _LineShifter(ModelVisitor):  # type: ignore[misc]
+    """Shift every token line number by a fixed offset, turning block-local lines into physical file lines."""
+
+    def __init__(self, offset: int) -> None:
+        self.offset = offset
+
+    def visit_Statement(self, node: Statement) -> None:  # noqa: N802
+        for token in node.tokens:
+            token.lineno += self.offset
+
+
+def shift_model_lines(model: File, offset: int) -> File:
+    """Add ``offset`` to every token line number in the model (in place) and return it."""
+    if offset:
+        _LineShifter(offset).visit(model)
+    return model

{robotframework_robocop-9.1.2 → robotframework_robocop-9.2.0}/src/robocop/formatter/runner.py

@@ -68,6 +68,18 @@ class RobocopFormatter:
                         cached_files += 1
                         continue
                 previous_changed_files = changed_files
+                if source_file.is_embedded:
+                    diff, old_text, new_text = self.format_embedded(source_file)
+                    if diff:
+                        self.save_text(source_file.path, new_text)
+                        self.log_formatted_source(source_file.path, stdin)
+                        self.output_diff_text(source_file.path, old_text, new_text)
+                        changed_files += 1
+                    if not diff or self.config.formatter.overwrite:
+                        self.config_manager.cache.set_formatter_entry(
+                            source_file.path, source_file.config.hash, needs_formatting=False
+                        )
+                    continue
                 diff, old_model, new_model, model = self.format_until_stable(source_file)
                 # if stdin:
                 #     self.print_to_stdout(new_model)
@@ -150,6 +162,87 @@ class RobocopFormatter:
         new_model = StatementLinesCollector(model)
         return new_model != old_model, old_model, new_model
 
+    def format_embedded(self, source_file: SourceFile) -> tuple[bool, str, str]:
+        """
+        Format every Robot code block embedded in a Markdown or Python file independently.
+
+        Each block is formatted on its own, re-indented to its original position and spliced back into the physical
+        file, leaving prose, fences and indentation of the surrounding document untouched.
+
+        Returns:
+            Tuple of (changed, original_text, new_text) with the full physical file contents.
+
+        """
+        resolved_config = self.config_resolver.resolve_config(source_file.config)
+        original = list(source_file.source_lines)
+        physical = list(original)
+        newline = self._detect_newline(original)
+        # Blocks are spliced bottom-to-top so that changing the length of one block does not shift the others.
+        for block, model in reversed(source_file.format_blocks()):  # type: ignore[attr-defined]
+            formatted = self.format_block(model, resolved_config)
+            if formatted is None:
+                continue
+            physical[block.start_line - 1 : block.end_line] = self._reindent_block(formatted, block.indent, newline)
+        new_text = "".join(physical)
+        old_text = "".join(original)
+        return new_text != old_text, old_text, new_text
+
+    def format_block(self, model: File, resolved_config: ResolvedConfig) -> str | None:
+        """
+        Run the configured formatters on a single block model.
+
+        Returns:
+            The formatted block text, or ``None`` if the block is unchanged or fully disabled.
+
+        """
+        disabler_finder = disablers.RegisterDisablers(self.config.formatter.start_line, self.config.formatter.end_line)
+        disabler_finder.visit(model)
+        if disabler_finder.is_disabled_in_file(disablers.ALL_FORMATTERS):
+            return None
+        original_text = StatementLinesCollector(model).text
+        formatted = self._apply_formatters(model, disabler_finder.disablers, resolved_config)
+        reruns = self.config.formatter.reruns
+        while formatted != original_text and reruns:
+            rerun_model = get_model(formatted)
+            rerun_disablers = disablers.RegisterDisablers(
+                self.config.formatter.start_line, self.config.formatter.end_line
+            )
+            rerun_disablers.visit(rerun_model)
+            new_formatted = self._apply_formatters(rerun_model, rerun_disablers.disablers, resolved_config)
+            if new_formatted == formatted:
+                break
+            formatted = new_formatted
+            reruns -= 1
+        return formatted if formatted != original_text else None
+
+    @staticmethod
+    def _apply_formatters(
+        model: File, disablers_in_file: disablers.DisablersInFile, resolved_config: ResolvedConfig
+    ) -> str:
+        for name, formatter in resolved_config.formatters.items():
+            formatter.disablers = disablers_in_file
+            if disablers_in_file.is_disabled_in_file(name):
+                continue
+            formatter.visit(model)
+        return StatementLinesCollector(model).text
+
+    @staticmethod
+    def _detect_newline(lines: list[str]) -> str:
+        """Return the line ending used by the physical file so formatted blocks keep the surrounding style."""
+        for line in lines:
+            if line.endswith("\r\n"):
+                return "\r\n"
+            if line.endswith("\n"):
+                return "\n"
+            if line.endswith("\r"):
+                return "\r"
+        return os.linesep
+
+    @staticmethod
+    def _reindent_block(text: str, indent: str, newline: str) -> list[str]:
+        """Re-apply the block indentation and the file's line ending to formatted lines, leaving blanks unindented."""
+        return [f"{indent}{line}{newline}" if line.strip() else f"{line}{newline}" for line in text.splitlines()]
+
     def log_formatted_source(self, source: Path, stdin: bool) -> None:
         if stdin or self.config.silent:
             return
@@ -171,6 +264,28 @@ class RobocopFormatter:
             output = self.config.formatter.output or source
             misc.ModelWriter(output=str(output), newline=self.get_line_ending(str(source))).write(model)
 
+    def save_text(self, source: Path, text: str) -> None:
+        """Write the full physical file content of an embedded file, preserving its original line endings."""
+        if self.config.formatter.overwrite:
+            output = self.config.formatter.output or source
+            with open(output, "w", encoding="utf-8", newline="") as f:
+                f.write(text)
+
+    def output_diff_text(self, path: Path, old_text: str, new_text: str) -> None:
+        if not self.config.formatter.diff:
+            return
+        old = [line + "\n" for line in old_text.splitlines()]
+        new = [line + "\n" for line in new_text.splitlines()]
+        lines = list(unified_diff(old, new, fromfile=f"{path}\tbefore", tofile=f"{path}\tafter"))
+        if not lines:
+            return
+        if self.config.formatter.color:
+            output = misc.decorate_diff_with_color(lines)
+        else:
+            output = misc.escape_rich_markup(lines)
+        for line in output:
+            console.print(line, end="", highlight=False, soft_wrap=True)
+
     def get_line_ending(self, path: str) -> str:
         if self.config.formatter.whitespace_config.line_ending == "auto":
             with open(path) as f:

{robotframework_robocop-9.1.2 → robotframework_robocop-9.2.0}/src/robocop/linter/checkers/names.py

@@ -131,7 +131,9 @@ class NamesChecker(VisitorChecker):
         """Check the name of a variable assigned with one of the ``Set * Variable`` keywords."""
         if not node.keyword:
             return
-        if utils.normalize_robot_name(node.keyword, remove_prefix="builtin.") not in naming.SET_VARIABLE_VARIANTS:
+        if utils.normalize_robot_name(node.keyword, remove_prefix="builtin.") not in (
+            naming.NON_LOCAL_SET_VARIABLE_VARIANTS
+        ):
             return
         if len(node.data_tokens) < 2:
             return

{robotframework_robocop-9.1.2 → robotframework_robocop-9.2.0}/src/robocop/linter/checkers/naming.py

@@ -12,7 +12,7 @@ from robot.parsing.model.statements import Arguments
 from robot.variables.search import search_variable
 
 from robocop.linter.rules import VisitorChecker, variables
-from robocop.linter.rules.naming import SET_VARIABLE_VARIANTS
+from robocop.linter.rules.naming import LOCAL_SET_VARIABLE_VARIANTS, SET_VARIABLE_VARIANTS
 from robocop.linter.utils import misc as utils
 from robocop.version_handling import ROBOT_VERSION, TYPE_SUPPORTED
 
@@ -58,17 +58,22 @@ class SimilarVariableChecker(VisitorChecker):
         self.generic_visit(node)
 
     def visit_KeywordCall(self, node: KeywordCall) -> None:  # noqa: N802
-        if utils.normalize_robot_name(node.keyword, remove_prefix="builtin.") in SET_VARIABLE_VARIANTS:
-            normalized, assign_value = "", ""
+        normalized_keyword = utils.normalize_robot_name(node.keyword, remove_prefix="builtin.")
+        if normalized_keyword in SET_VARIABLE_VARIANTS:
+            normalized, assign_token = "", None
             for index, token in enumerate(node.data_tokens[1:]):
                 if index == 0:  # First argument is assign-like
                     normalized = utils.normalize_robot_var_name(token.value)
-                    assign_value = token.value  # process assign last, cache for now
+                    assign_token = token  # process assign last, cache for now
                 else:
                     self.find_not_nested_variable(token)
-            if assign_value:
-                variable = search_variable(assign_value, ignore_errors=True)
-                self.assigned_variables[normalized].append(variable.base)
+            if assign_token is not None and assign_token.value:
+                variable = search_variable(assign_token.value, ignore_errors=True)
+                if variable.base is not None and normalized_keyword in LOCAL_SET_VARIABLE_VARIANTS:
+                    # local scope behaves like a normal assignment and can overwrite a similar variable
+                    self.find_similar_variables([assign_token], node)
+                else:
+                    self.assigned_variables[normalized].append(variable.base)
         else:
             for token in node.get_tokens(Token.ARGUMENT, Token.KEYWORD):  # argument can be used in keyword name
                 self.find_not_nested_variable(token)

{robotframework_robocop-9.1.2 → robotframework_robocop-9.2.0}/src/robocop/linter/checkers/raw_file.py

@@ -31,7 +31,8 @@ class RawFileRulesChecker(RawFileChecker):
 
     def parse_file(self) -> None:
         self.lines = self.source_file.source_lines
-        if self.ignored_data.enabled or self.bom_encoding_in_file.enabled:
+        is_embedded = self.source_file.is_embedded
+        if not is_embedded and (self.ignored_data.enabled or self.bom_encoding_in_file.enabled):
             is_bom = detect_bom(self.source_file.path)
             self.bom_encoding_in_file.check(is_bom)
             self.ignored_data.check(self.lines, is_bom)
@@ -39,11 +40,12 @@ class RawFileRulesChecker(RawFileChecker):
             doc_lines: frozenset[int] = frozenset()
             if self.line_too_long.enabled and self.line_too_long.ignore_docs:
                 doc_lines = self.line_too_long.get_documentation_lines(self.source_file.model)
-            for lineno, line in enumerate(self.lines, start=1):
+            for lineno, line in self.source_file.check_lines:
                 self.trailing_whitespace.check(line, lineno)
                 self.line_too_long.check(line, lineno, doc_lines)
-        self.too_many_trailing_blank_lines.check(self.lines)
-        self.missing_trailing_blank_line.check(self.lines)
+        if not is_embedded:
+            self.too_many_trailing_blank_lines.check(self.lines)
+            self.missing_trailing_blank_line.check(self.lines)
 
 
 def detect_bom(source: Path) -> bool:

{robotframework_robocop-9.1.2 → robotframework_robocop-9.2.0}/src/robocop/linter/fix.py

@@ -319,6 +319,7 @@ class FixApplier:
         if not all_edits:
             return False
 
+        all_edits = source_file.prepare_fix_edits(all_edits)
         sorted_edits = sorted(all_edits, key=lambda e: (e.start_line, e.start_col))
         non_overlapping_edits = self._remove_overlapping_edits(sorted_edits)
 

{robotframework_robocop-9.1.2 → robotframework_robocop-9.2.0}/src/robocop/linter/rules/__init__.py

@@ -595,7 +595,8 @@ class VisitorChecker(BaseChecker, ModelVisitor):  # type: ignore[misc]
         self.source_file = source_file
         self.templated_suite = templated
         self.context = Context()
-        self.visit_File(source_file.model)
+        for model in source_file.models:
+            self.visit_File(model)
         return self.issues
 
     def visit_File(self, node: File) -> None:  # noqa: N802

{robotframework_robocop-9.1.2 → robotframework_robocop-9.2.0}/src/robocop/linter/rules/imports.py

@@ -266,7 +266,7 @@ class UnusedResourceImportRule(Rule):
     A resource is considered used when the file uses any keyword or variable defined in it, or in any resource it
     imports itself, since resource imports are transitive in Robot Framework. Variables are also recognized when
     used with the extended variable syntax (``${var.attr}``, ``${var['key']}``), item access (``${var}[key]``) or in
-    Python expressions (``$var`` in ``IF`` conditions, ``Evaluate`` or ``${{ }}``).
+    Python expressions (``$var`` in ``IF`` conditions, ``Evaluate`` or inline Python evaluation in variables).
 
     To avoid false positives, imports are not reported when:
 

{robotframework_robocop-9.1.2 → robotframework_robocop-9.2.0}/src/robocop/linter/rules/naming.py

@@ -1111,12 +1111,16 @@ class WrongCaseInKeywordCallRule(FixableRule):
         return wrong_case_in_keyword_fix(self, diag, source_lines, is_keyword_call=True)
 
 
-SET_VARIABLE_VARIANTS = {
+LOCAL_SET_VARIABLE_VARIANTS = {
+    "setlocalvariable",
+}
+NON_LOCAL_SET_VARIABLE_VARIANTS = {
     "settaskvariable",
     "settestvariable",
     "setsuitevariable",
     "setglobalvariable",
 }
+SET_VARIABLE_VARIANTS = LOCAL_SET_VARIABLE_VARIANTS | NON_LOCAL_SET_VARIABLE_VARIANTS
 
 
 def uppercase_error_msg(name: str) -> str:

{robotframework_robocop-9.1.2 → robotframework_robocop-9.2.0}/src/robocop/linter/runner.py

@@ -145,11 +145,18 @@ class RobocopLinter:
         run_stats = RunStatistic(
             files_count=files, fix_stats=fix_applier.fix_stats, modified_files=fix_applier.modified_files
         )
+        self.offset_embedded_diagnostics()
         self.make_reports(run_stats=run_stats)
         if self.config_manager.default_config.linter.return_result:
             return self.diagnostics
         return self.return_with_exit_code(len(self.diagnostics))
 
+    def offset_embedded_diagnostics(self) -> None:
+        """Translate diagnostic positions of embedded files (Markdown, Python) to physical file coordinates."""
+        for diagnostic in self.diagnostics:
+            if diagnostic.source.is_embedded:
+                diagnostic.source.offset_range(diagnostic.range)
+
     def run_check(self, source_file: SourceFile, fix_applier: FixApplier | None = None) -> list[Diagnostic]:
         """
         Run all rules on file model and return list of diagnostics.
@@ -204,7 +211,7 @@ class RobocopLinter:
             fix_applier.fix_stats.total_fixes += max(prev_fixable - len(fixable_diagnostics), 0)
             prev_fixable = len(fixable_diagnostics)
             # Collect fixes from diagnostics
-            fixes = [diag.fix or diag.rule.fix(diag, source_file.source_lines) for diag in fixable_diagnostics]
+            fixes = [diag.fix or diag.rule.fix(diag, source_file.fix_source_lines) for diag in fixable_diagnostics]
             if not fix_applier.apply_fixes(source_file, [fix for fix in fixes if fix]):
                 break
         if source_file.config.linter.fix and not source_file.config.linter.diff:
@@ -317,7 +324,7 @@ class RobocopLinter:
             source_file = modified_files.get(resolved_path) or project_files.get(resolved_path)
             if source_file is None:
                 source_file = source_diagnostics[0].source
-            fixes = [diag.fix or diag.rule.fix(diag, source_file.source_lines) for diag in source_diagnostics]
+            fixes = [diag.fix or diag.rule.fix(diag, source_file.fix_source_lines) for diag in source_diagnostics]
             fixes_before = self.count_applied_fixes(fix_applier)
             if not fix_applier.apply_fixes(source_file, [fix for fix in fixes if fix]):
                 continue