robotcode-repl 2.7.0__py3-none-any.whl → 2.8.0.dev548__py3-none-any.whl

robotcode/repl/_pt/lexer.py

@@ -37,6 +37,7 @@ from robot.api import get_tokens
 from robotcode.robot.diagnostics.semantic_analyzer.enums import TokenKind
 from robotcode.robot.diagnostics.semantic_analyzer.nodes import SemanticToken
 from robotcode.robot.diagnostics.semantic_analyzer.variable_tokenizer import (
+    VariableSite,
     build_variable_sub_tokens,
 )
 
@@ -145,7 +146,9 @@ def _split_variable(value: str) -> Iterable[Tuple[str, str]]:
     still renders (just without per-part colouring).
     """
     try:
-        sub_tokens = build_variable_sub_tokens(value, line=1, col_offset=0)
+        # The lexer cannot tell definitions from usages, so it splits like a
+        # definition to show the type hints of `VAR` and `FOR` variables.
+        sub_tokens = build_variable_sub_tokens(value, line=1, col_offset=0, site=VariableSite.DECLARATION)
     except Exception:
         yield (_VARIABLE_FALLBACK_STYLE, value)
         return

robotcode/repl/base_interpreter.py

@@ -1,19 +1,26 @@
 import abc
 import contextlib
+import os
 import signal
+import sys
+from dataclasses import dataclass
 from datetime import datetime
 from io import StringIO
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Iterator, List, Optional, Protocol, Tuple, Union, cast
 
 from robot.api import get_model
-from robot.errors import ExecutionStatus
+from robot.errors import ExecutionFailed, ExecutionPassed, ExecutionStatus
 from robot.output import LOGGER
 from robot.output import Message as OutputMessage
+from robot.parsing.lexer.tokens import Token
+from robot.parsing.model.blocks import For, If, Try, While
+from robot.parsing.model.statements import Error, Statement
 from robot.result import Keyword as ResultKeyword
 from robot.running import Keyword, TestCase, TestSuite
 from robot.running.context import EXECUTION_CONTEXTS
 from robot.running.signalhandler import STOP_SIGNAL_MONITOR, _StopSignalMonitor
+from robot.utils import normalize
 
 from robotcode.robot.utils import RF_VERSION
 from robotcode.robot.utils.ast import iter_nodes
@@ -54,13 +61,89 @@ def _register_signal_handler(self: Any, exsignum: Any) -> None:
     pass
 
 
+# Robot Framework's own handling, kept for the signals that end a run outside a REPL session (a robot-debug run).
+_robot_monitor_call = _StopSignalMonitor.__call__
+_robot_stop_execution_gracefully = _StopSignalMonitor._stop_execution_gracefully
+
+# The interpreter of this process; the patched monitor hands the signals to it.
+_signal_interpreter: Optional["BaseInterpreter"] = None
+# Signals received so far that end the session or the run: SIGTERM, and SIGINT in a run without the
+# debugger. Counted here: Robot Framework resets its count after every REPL statement.
+_ending_signal_count = 0
+# Set by such a signal outside a REPL session: stopping then ends the run as Robot Framework does.
+_signal_ends_run = False
+
+
 def _stop_signal_monitor_call(self: Any, signum: Any, frame: Any) -> None:
+    if signum == signal.SIGTERM:
+        _on_sigterm(self, signum, frame)
+        return
+
+    if _signal_interpreter is not None:
+        # SIGINT at a prompt ends the wait for input, as Ctrl-C does with prompt_toolkit.
+        _signal_interpreter._interrupt_waiting()
+        # With the debugger attached, SIGINT first pauses at the next keyword, as pdb does.
+        if _signal_interpreter._pause_on_interrupt():
+            return
+        # Without the debugger, SIGINT ends a robot-debug run as it ends a Robot Framework run.
+        if _signal_interpreter._interrupt_ends_run():
+            _count_ending_signal()
+            _end_run(self, signum, frame)
+            return
     if self._running_keyword:
+        # SIGINT interrupts the running keyword; the session goes on.
         self._stop_execution_gracefully()
 
 
+def _count_ending_signal() -> None:
+    """Count a signal that ends the session or the run; the second one ends the process at once."""
+    global _ending_signal_count
+    _ending_signal_count += 1
+    if _ending_signal_count > 1:
+        try:
+            if sys.__stderr__ is not None:
+                sys.__stderr__.write("Execution forcefully stopped.\n")
+        finally:
+            os._exit(253)
+
+
+def _on_sigterm(monitor: Any, signum: Any, frame: Any) -> None:
+    _count_ending_signal()
+
+    interpreter = _signal_interpreter
+    if interpreter is not None and interpreter._in_repl_run:
+        if interpreter._running_statement:
+            # As in a Robot Framework run, the next keyword that starts stops the statement;
+            # Robot Framework resets the count when the statement ends.
+            monitor._signal_count += 1
+        interpreter._terminate_session(monitor._running_keyword)
+        return
+
+    _end_run(monitor, signum, frame)
+
+
+def _end_run(monitor: Any, signum: Any, frame: Any) -> None:
+    # A run, such as robot-debug: Robot Framework ends it, at once while a keyword runs
+    # (this raises), otherwise at the next keyword; the interpreter only stops waiting.
+    global _signal_ends_run
+    _signal_ends_run = True
+    interpreter = _signal_interpreter
+    if interpreter is not None:
+        interpreter._termination_requested = True
+    try:
+        _robot_monitor_call(monitor, signum, frame)
+    finally:
+        if interpreter is not None:
+            interpreter._end_waiting()
+
+
 def _stop_signal_monitor_stop_execution_gracefully(self: Any) -> None:
-    raise ExecutionInterrupted("Execution interrupted")
+    if _signal_ends_run:
+        _robot_stop_execution_gracefully(self)
+    elif _ending_signal_count:
+        raise ExecutionInterrupted("Execution terminated by signal")
+    else:
+        raise ExecutionInterrupted("Execution interrupted")
 
 
 _patched = False
@@ -80,7 +163,14 @@ def _patch() -> None:
 if RF_VERSION >= (7, 0):
 
     def _run_keyword(kw: Keyword, context: Any) -> Any:
-        return kw.run(context.steps[-1][1], context)
+        # A keyword typed at a stop becomes a child of the running step. At a stop
+        # where no step runs any more, such as the end of a test, it goes to the
+        # test, and without a test to a detached result.
+        if context.steps:
+            parent = context.steps[-1][1]
+        else:
+            parent = context.test if context.test is not None else ResultKeyword()
+        return kw.run(parent, context)
 
 else:
 
@@ -109,6 +199,80 @@ def result_qualified_name(result: Any) -> Optional[str]:
     return _keyword_qualified_name(result) if isinstance(result, ResultKeyword) else None
 
 
+# The definition name of a keyword with embedded arguments (`Select ${animal} From List`),
+# bare and qualified with its owner. Robot Framework sets it before the keyword starts, as
+# `source_name` from version 7 on and as `sourcename` before; other keywords have none.
+if RF_VERSION >= (7, 0):
+
+    def _keyword_definition_names(keyword: ResultKeyword) -> Tuple[str, ...]:
+        if not keyword.source_name:
+            return ()
+        if not keyword.owner:
+            return (keyword.source_name,)
+        return (keyword.source_name, f"{keyword.owner}.{keyword.source_name}")
+
+else:
+
+    def _keyword_definition_names(keyword: ResultKeyword) -> Tuple[str, ...]:
+        if not keyword.sourcename:
+            return ()
+        if not keyword.libname:
+            return (keyword.sourcename,)
+        return (keyword.sourcename, f"{keyword.libname}.{keyword.sourcename}")
+
+
+def result_definition_names(result: Any) -> Tuple[str, ...]:
+    return _keyword_definition_names(result) if isinstance(result, ResultKeyword) else ()
+
+
+# Blocks that stay open until their END. Their branches (ELSE, EXCEPT, …) are blocks of
+# the same classes with another header and never get an END of their own.
+if RF_VERSION >= (7, 2):
+    from robot.parsing.model.blocks import Group
+
+    _END_BLOCKS: Tuple[Any, ...] = (For, While, If, Try, Group)
+    _BLOCK_OPENERS = frozenset({Token.FOR, Token.WHILE, Token.IF, Token.TRY, Token.GROUP})
+else:
+    _END_BLOCKS = (For, While, If, Try)
+    _BLOCK_OPENERS = frozenset({Token.FOR, Token.WHILE, Token.IF, Token.TRY})
+
+# A REPL input runs as the body of the session test, so it can't have settings: neither
+# test settings nor the keyword settings that a test reports as not allowed.
+_SETTING_TYPES = frozenset(
+    {Token.DOCUMENTATION, Token.TAGS, Token.SETUP, Token.TEARDOWN, Token.TEMPLATE, Token.TIMEOUT}
+)
+_SETTING_NAMES = frozenset({"documentation", "tags", "setup", "teardown", "template", "timeout", "arguments", "return"})
+
+
+def _mark_settings_as_errors(test: Any) -> None:
+    """Mark the settings of a REPL input as errors, as Robot Framework's lexer marks a
+    setting a test can't have, so that Robot Framework reports them like a non-existing
+    setting."""
+    for i, node in enumerate(test.body):
+        if not isinstance(node, Statement):
+            continue
+        if node.type in _SETTING_TYPES:
+            node = test.body[i] = Error(
+                [Token(Token.ERROR, t.value, t.lineno, t.col_offset) if t.type == node.type else t for t in node.tokens]
+            )
+        if isinstance(node, Error):
+            for token in node.get_tokens(Token.ERROR):
+                name = token.value[1:-1].strip() if token.value.startswith("[") and token.value.endswith("]") else ""
+                if normalize(name) in _SETTING_NAMES:
+                    token.error = f"Setting '{name}' is not allowed in the REPL."
+
+
+@dataclass
+class ReplInput:
+    """REPL input parsed as a test body by `BaseInterpreter.parse_input`."""
+
+    test: TestCase
+    # The parse errors of the input.
+    errors: List[str]
+    # True while a block of the input lacks its END, so more lines can complete it.
+    incomplete: bool
+
+
 if RF_VERSION < (7, 0):
 
     class InterpreterLogger:
@@ -231,9 +395,24 @@ else:
             self.interpreter._notify_end_suite(data, result)
 
 
+# The interpreter whose prompt loop started last. `_maybe_trigger_repl` sets it when
+# the `repl` marker keyword starts; the marker's body takes it once the loop has returned.
+_active_interpreter: Optional["BaseInterpreter"] = None
+
+
+def take_active_interpreter() -> Optional["BaseInterpreter"]:
+    """Return the interpreter whose prompt loop started last and forget it, so a later
+    session in the same process never sees it."""
+    global _active_interpreter
+    interpreter, _active_interpreter = _active_interpreter, None
+    return interpreter
+
+
 class BaseInterpreter(abc.ABC):
     def __init__(self) -> None:
         _patch()
+        global _signal_interpreter
+        _signal_interpreter = self
 
         self._logger = InterpreterLogger(self)
         LOGGER.register_logger(self._logger)
@@ -248,6 +427,17 @@ class BaseInterpreter(abc.ABC):
         # The interpreter's own start_keyword/end_keyword hooks stay the primary
         # consumer; observers run alongside them.
         self._observers: List["ExecutionObserver"] = []
+        # Unhandled failures of the prompt loop, recorded only while `record_failures`
+        # is set (by `robotcode repl`). The `repl` marker keyword fails the session test
+        # with them.
+        self.record_failures = False
+        self.failures: List[ExecutionFailed] = []
+        # The code given to `.exit`/`.quit`, None without one.
+        self.exit_code: Optional[int] = None
+        # Set by a signal that ends the session or the run.
+        self._termination_requested = False
+        # Set while a statement of the input runs: SIGTERM then stops it at its next keyword.
+        self._running_statement = False
 
     @property
     def curdir(self) -> Path:
@@ -269,7 +459,7 @@ class BaseInterpreter(abc.ABC):
 
         return []
 
-    def get_test_body_from_string(self, command: str) -> Tuple[TestCase, List[str]]:
+    def _parse_test_body(self, command: str) -> Tuple[Any, TestCase]:
         suite_str = (
             "*** Test Cases ***\nDummyTestCase423141592653589793\n  "
             + ("\n  ".join(command.split("\n")) if "\n" in command else command)
@@ -278,16 +468,45 @@ class BaseInterpreter(abc.ABC):
         with StringIO(suite_str) as source:
             model = get_model(source, curdir=str(self.curdir).replace("\\", "\\\\"))
 
-        model.source = self.source
+        # RF < 6.1 expects a `str` source; RF 6.1+ converts it to a `Path` itself.
+        model.source = str(self.source) if self.source is not None else None
+        _mark_settings_as_errors(model.sections[0].body[0])
 
         suite: TestSuite = TestSuite.from_model(model)
 
+        return model, cast(TestCase, suite.tests[0])
+
+    def get_test_body_from_string(self, command: str) -> Tuple[TestCase, List[str]]:
+        model, test = self._parse_test_body(command)
+
         errors: List[str] = []
 
         for node in iter_nodes(model):
             errors.extend(self.check_for_errors(node))
 
-        return cast(TestCase, suite.tests[0]), errors
+        return test, errors
+
+    def parse_input(self, text: str) -> ReplInput:
+        """Parse REPL input as a test body without raising on errors.
+
+        Unlike `get_test_body_from_string`, whose `SyntaxError` for token errors
+        `repl_server` relies on, invalid statements are left to Robot Framework,
+        which fails them when execution reaches them.
+        """
+        model, test = self._parse_test_body(text)
+
+        errors: List[str] = []
+        incomplete = False
+
+        for node in iter_nodes(model):
+            try:
+                errors.extend(self.check_for_errors(node))
+            except SyntaxError as e:
+                errors.append(str(e))
+            if isinstance(node, _END_BLOCKS) and node.header.type in _BLOCK_OPENERS and node.end is None:
+                incomplete = True
+
+        return ReplInput(test=test, errors=errors, incomplete=incomplete)
 
     @abc.abstractmethod
     def get_input(self) -> Iterator[Optional[Keyword]]: ...
@@ -302,17 +521,50 @@ class BaseInterpreter(abc.ABC):
         except ExecutionStatus:
             raise
         except BaseException as e:
-            self.log_message(f"{type(e)}: {e}", "ERROR", timestamp=datetime.now())  # noqa: DTZ005
+            message = f"{type(e)}: {e}"
+            self.log_message(message, "ERROR", timestamp=datetime.now())  # noqa: DTZ005
+            self._record_failure(ExecutionFailed(message))
+
+    def _record_failure(self, error: ExecutionFailed) -> None:
+        if self.record_failures:
+            # Split like Robot Framework's body runner does, so the combined message
+            # numbers each failure.
+            self.failures.extend(error.get_errors())
 
     def interrupt(self) -> None:
         signal.raise_signal(signal.SIGINT)
 
+    def _terminate_session(self, keyword_running: bool) -> None:
+        """End the REPL session on SIGTERM, from the signal handler: a running keyword is
+        interrupted, then the session ends as at the end of the input, with exit code 253."""
+        self._termination_requested = True
+        self.exit_code = 253
+        self._end_waiting()
+        if keyword_running:
+            raise ExecutionInterrupted("Execution terminated by signal")
+
+    def _end_waiting(self) -> None:
+        """Stop waiting for input, from the signal handler. Each interpreter knows how it waits."""
+
+    def _interrupt_waiting(self) -> None:
+        """Interrupt a wait for input after SIGINT, from the signal handler. Each interpreter knows how it waits."""
+
+    def _pause_on_interrupt(self) -> bool:
+        """Pause at the next keyword after SIGINT instead of interrupting the keyword that runs, from the signal
+        handler. Returns whether it does; only an interpreter with a debugger can pause."""
+        return False
+
+    def _interrupt_ends_run(self) -> bool:
+        """Whether SIGINT ends the run as Robot Framework ends one, from the signal handler. Only an interpreter that
+        runs a suite, not a session, can end a run this way."""
+        return False
+
     def run(self) -> Any:
         self._logger.enabled = True
 
         has_input = True
         try:
-            while has_input:
+            while has_input and not self._termination_requested:
                 try:
                     self.run_input()
                 except EOFError:
@@ -321,19 +573,33 @@ class BaseInterpreter(abc.ABC):
                     break
                 except ExecutionInterrupted as e:
                     self.log_message(str(e), "ERROR", timestamp=datetime.now())  # noqa: DTZ005
-                except ExecutionStatus:
-                    pass
+                    self._record_failure(ExecutionFailed(str(e)))
+                except ExecutionPassed as e:
+                    # Failures continued before `Pass Execution` still fail a test in Robot Framework.
+                    if e.earlier_failures:
+                        self._record_failure(e.earlier_failures)
+                except ExecutionFailed as e:
+                    # As in Robot Framework, a skip counts as skipped even when failures
+                    # were continued before it.
+                    if not e.skip:
+                        self._record_failure(e)
                 except BaseException as e:
                     self.log_message(str(e), "ERROR", timestamp=datetime.now())  # noqa: DTZ005
+                    self._record_failure(ExecutionFailed(str(e)))
         finally:
             self._logger.enabled = False
 
     def run_input(self) -> None:
         for kw in self.get_input():
             with STOP_SIGNAL_MONITOR:
-                if kw is None:
-                    break
-                self.set_last_result(self.run_keyword(kw))
+                self._running_statement = True
+                try:
+                    # Checked after marking the statement: a SIGTERM in between can't be missed.
+                    if kw is None or self._termination_requested:
+                        break
+                    self.set_last_result(self.run_keyword(kw))
+                finally:
+                    self._running_statement = False
 
     def set_last_result(self, result: Any) -> None:
         self.last_result = result
@@ -444,6 +710,8 @@ class BaseInterpreter(abc.ABC):
         """
         if self._in_repl_run or not self._is_repl_marker(result):
             return False
+        global _active_interpreter
+        _active_interpreter = self
         self._in_repl_run = True
         try:
             self.run()

robotcode/repl/cli.py

@@ -17,7 +17,7 @@ from ._backends import BACKEND_CHOICES
 from ._debug import DebugController, DebugTerminated
 from .console_interpreter import _LINE_BREAK_RE, ConsoleInterpreter
 from .prompt_toolkit_interpreter import PromptToolkitConsoleInterpreter
-from .run import run_repl
+from .run import ReplResult, run_repl
 
 
 def _pick_interpreter(
@@ -79,6 +79,8 @@ def _invoke_runner(
     ctx: click.Context,
     by_longname: Tuple[str, ...],
     exclude_by_longname: Tuple[str, ...],
+    by_test_metadata: Tuple[str, ...],
+    exclude_by_test_metadata: Tuple[str, ...],
     robot_options_and_args: Tuple[str, ...],
 ) -> None:
     """Run the real suite via the normal `robotcode robot` runner."""
@@ -89,6 +91,10 @@ def _invoke_runner(
         forwarded += ["--by-longname", value]
     for value in exclude_by_longname:
         forwarded += ["--exclude-by-longname", value]
+    for value in by_test_metadata:
+        forwarded += ["--by-test-metadata", value]
+    for value in exclude_by_test_metadata:
+        forwarded += ["--exclude-by-test-metadata", value]
     forwarded += list(robot_options_and_args)
 
     robot_ctx = robot_command.make_context("robot", forwarded, parent=ctx)
@@ -107,6 +113,21 @@ def _is_interactive_stdin() -> bool:
         return False
 
 
+def _session_exit_code(result: ReplResult, *, statusrc: Optional[bool], interactive: bool) -> int:
+    """The exit code of a `repl` session.
+
+    A code given to `.exit`/`.quit` wins. Otherwise Robot's return code, which
+    already honors `statusrc` from the configuration, is used when `--statusrc`/
+    `--nostatusrc` was given or the session is not interactive; an interactive
+    session exits with 0.
+    """
+    if result.exit_code is not None:
+        return result.exit_code
+    if statusrc is not None or not interactive:
+        return result.return_code
+    return 0
+
+
 def _resolve_backend(plain: bool, backend: str) -> str:
     """The effective input backend.
 
@@ -235,8 +256,8 @@ REPL_BASE_OPTIONS = [
     ),
 ]
 
-# `repl`-only options (interactive session setup + snippet files).
-SHELL_OPTIONS = [
+# Variables and the python path, shared by `repl` and `doc`.
+VARIABLE_AND_PATH_OPTIONS = [
     click.option(
         "-v",
         "--variable",
@@ -262,6 +283,11 @@ SHELL_OPTIONS = [
         help="Additional locations where to search test libraries"
         " and other extensions when they are imported. See `robot --pythonpath` option.",
     ),
+]
+
+# `repl`-only options (interactive session setup + snippet files).
+SHELL_OPTIONS = [
+    *VARIABLE_AND_PATH_OPTIONS,
     click.option(
         "-k",
         "--show-keywords",
@@ -316,11 +342,20 @@ SHELL_OPTIONS = [
         "--source",
         type=click.Path(path_type=Path),
         metavar="FILE",
-        help="Use the parent directory of FILE as the REPL's working directory. "
-        "Relative paths inside `Import Resource`, `Import Library`, "
-        "file-based variables, etc. resolve against that directory. "
-        "The file itself is never read or written, so the path doesn't "
-        "need to exist.",
+        help="Run the session as if its keywords were written in FILE: `${CURDIR}` is the "
+        "directory of FILE, `${SUITE SOURCE}` is FILE and, on Robot Framework 7.4 and newer, "
+        "relative paths in `Import Resource`, `Import Library`, and `Import Variables` resolve "
+        "against that directory. A relative FILE is resolved against the directory the command "
+        "is started from. The file itself is never read or written, so the path doesn't need to exist.",
+    ),
+    click.option(
+        "--statusrc/--nostatusrc",
+        default=None,
+        help="Exit with 1 if a statement failed without being handled, otherwise 0, in any session "
+        "(`--statusrc`), or exit with 0 regardless of failures (`--nostatusrc`). Both override `no-status-rc` "
+        "from the configuration. Without either option only non-interactive sessions (piped input, or FILES "
+        "without `--inspect`) exit with 1 after such a failure, unless the configuration switches this off. "
+        "A code given to `.exit` takes precedence.",
     ),
     click.argument(
         "files",
@@ -350,7 +385,8 @@ DEBUG_OPTIONS = [
         "break_at",
         metavar="LOCATION",
         multiple=True,
-        help="Break at LOCATION — a `file:line` or a keyword name. Repeatable.",
+        help="Break at LOCATION — a `file:line`, or a keyword name or glob pattern "
+        "matched like Robot Framework. Repeatable.",
     ),
     click.option(
         "--break-on-exception/--no-break-on-exception",
@@ -403,6 +439,7 @@ def repl(
     log: Optional[str],
     xunit: Optional[str],
     source: Optional[Path],
+    statusrc: Optional[bool],
     files: Tuple[Path, ...],
     debugger_attached: Optional[bool],
     break_at: Tuple[str, ...],
@@ -441,6 +478,9 @@ def repl(
         no_history=no_history,
         backend=backend,
     )
+    # Only `repl` fails its session test on unhandled failures — not `robot-debug`,
+    # which builds its interpreter the same way.
+    interpreter.record_failures = True
     # The debugger stays wired for the whole interactive session and is torn down
     # with the interpreter when the session ends — so, unlike `robot`, there is no
     # per-run unregister here. `attached` decides whether it actually pauses.
@@ -454,7 +494,7 @@ def repl(
         break_on_failed_suite=break_on_failed_suite,
     )
 
-    run_repl(
+    result = run_repl(
         interpreter=interpreter,
         app=app,
         variable=variable,
@@ -467,8 +507,13 @@ def repl(
         xunit=xunit,
         source=source,
         files=files,
+        statusrc=statusrc,
     )
 
+    # Script files without `--inspect` end on their own, like piped input.
+    interactive = _is_interactive_stdin() and (not files or inspect)
+    app.exit(_session_exit_code(result, statusrc=statusrc, interactive=interactive))
+
 
 @wrappable
 @click.command(
@@ -479,13 +524,13 @@ def repl(
     epilog="Use `-- --help` to see `robot` help.",
 )
 @add_options(*REPL_BASE_OPTIONS)
-@add_options(*(ROBOT_OPTIONS - ROBOT_VERSION_OPTIONS))
+@add_options(*(option for option in ROBOT_OPTIONS if option not in ROBOT_VERSION_OPTIONS))
 @add_options(*DEBUG_OPTIONS)
 @click.option(
     "--stop-on-entry",
     is_flag=True,
     default=False,
-    help="Break at the very first keyword.",
+    help="Break at the very first step.",
 )
 @add_options(*ROBOT_VERSION_OPTIONS)
 @pass_application
@@ -495,6 +540,8 @@ def robot_debug(
     app: Application,
     by_longname: Tuple[str, ...],
     exclude_by_longname: Tuple[str, ...],
+    by_test_metadata: Tuple[str, ...],
+    exclude_by_test_metadata: Tuple[str, ...],
     robot_options_and_args: Tuple[str, ...],
     no_history: bool,
     backend: str,
@@ -540,7 +587,14 @@ def robot_debug(
     # default (or the user's `--console`), not forced.
     try:
         with interpreter.forward_events(echo_messages=False):
-            _invoke_runner(ctx, by_longname, exclude_by_longname, robot_options_and_args)
+            _invoke_runner(
+                ctx,
+                by_longname,
+                exclude_by_longname,
+                by_test_metadata,
+                exclude_by_test_metadata,
+                robot_options_and_args,
+            )
     except DebugTerminated:
         app.echo("Debugger: run terminated.")
     finally: