robotcode-debugger 2.7.0__tar.gz → 2.8.0__tar.gz

{robotcode_debugger-2.7.0 → robotcode_debugger-2.8.0}/.gitignore

@@ -279,6 +279,9 @@ dist
 # vuepress build output
 .vuepress/dist
 
+# Astro (documentation site)
+docs/.astro/
+
 # Serverless directories
 .serverless/
 
@@ -339,7 +342,7 @@ bundled/libs
 # .agents
 .agents/
 skills-lock.json
-.claude
+#.claude
 
 # sarif files
 /**/*.sarif.json

{robotcode_debugger-2.7.0 → robotcode_debugger-2.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: robotcode-debugger
-Version: 2.7.0
+Version: 2.8.0
 Summary: RobotCode Debugger for Robot Framework
 Project-URL: Homepage, https://robotcode.io
 Project-URL: Donate, https://opencollective.com/robotcode
@@ -20,13 +20,14 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
-Requires-Dist: robotcode-jsonrpc2==2.7.0
-Requires-Dist: robotcode-runner==2.7.0
+Requires-Dist: robotcode-jsonrpc2==2.8.0
+Requires-Dist: robotcode-runner==2.8.0
 Requires-Dist: robotframework>=5.0.0
 Provides-Extra: debugpy
 Requires-Dist: debugpy; extra == 'debugpy'

{robotcode_debugger-2.7.0 → robotcode_debugger-2.8.0}/pyproject.toml

@@ -18,6 +18,7 @@ classifiers = [
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
   "Programming Language :: Python :: 3.14",
+  "Programming Language :: Python :: 3.15",
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Implementation :: PyPy",
   "Operating System :: OS Independent",
@@ -29,8 +30,8 @@ classifiers = [
 dynamic = ["version"]
 dependencies = [
   "robotframework>=5.0.0",
-  "robotcode-jsonrpc2==2.7.0",
-  "robotcode-runner==2.7.0",
+  "robotcode-jsonrpc2==2.8.0",
+  "robotcode-runner==2.8.0",
 ]
 
 [project.optional-dependencies]

robotcode_debugger-2.8.0/src/robotcode/debugger/__version__.py

@@ -0,0 +1 @@
+__version__ = "2.8.0"

{robotcode_debugger-2.7.0 → robotcode_debugger-2.8.0}/src/robotcode/debugger/cli.py

@@ -145,8 +145,14 @@ def debug(
     robot_options_and_args: Tuple[str, ...],
 ) -> None:
     """Starts a Robot Framework debug session and waits for incomming connections."""
+    from robotcode.runner.cli.robot import load_robot_profile
+
     from .run import run_debugger
 
+    # Before the debug server starts, so that it runs under the `wrapper` too; an error
+    # of the configuration shows when `robot` runs in the debug session.
+    load_robot_profile(app, robot_options_and_args)
+
     mode, port, bind, pipe_name = resolve_server_options(
         ctx,
         app,
@@ -204,5 +210,9 @@ def debug(
         raise
     except KeyboardInterrupt:
         app.keyboard_interrupt()
+    except click.ClickException:
+        # Errors robotcode reports itself, such as a broken configuration; the root
+        # group gives them Robot Framework's exit code.
+        raise
     except Exception as e:
         raise UnknownError(str(e)) from e

{robotcode_debugger-2.7.0 → robotcode_debugger-2.8.0}/src/robotcode/debugger/dap_types.py

@@ -1119,6 +1119,24 @@ class SetExceptionBreakpointsResponse(Response):
     body: Optional[SetExceptionBreakpointsResponseBody] = None
 
 
+@dataclass
+class ExceptionInfoArguments(Model):
+    thread_id: int
+
+
+@dataclass
+class ExceptionDetails(Model):
+    stack_trace: Optional[str] = None
+
+
+@dataclass
+class ExceptionInfoResponseBody(Model):
+    exception_id: str
+    break_mode: ExceptionBreakMode
+    description: Optional[str] = None
+    details: Optional[ExceptionDetails] = None
+
+
 @dataclass
 class _CompletionsRequest:
     arguments: CompletionsArguments

{robotcode_debugger-2.7.0 → robotcode_debugger-2.8.0}/src/robotcode/debugger/debugger.py

@@ -1,4 +1,5 @@
 import itertools
+import operator
 import os
 import pathlib
 import re
@@ -35,6 +36,7 @@ from typing import (
 from robot.api.parsing import get_model
 from robot.errors import VariableError
 from robot.output import LOGGER
+from robot.result import Keyword as ResultKeyword
 from robot.running import EXECUTION_CONTEXTS, Keyword, TestCase, TestSuite
 from robot.running.model import Try
 from robot.utils import Matcher as RobotMatcher
@@ -52,7 +54,10 @@ from .dap_types import (
     ContinuedEventBody,
     EvaluateArgumentContext,
     Event,
+    ExceptionBreakMode,
+    ExceptionDetails,
     ExceptionFilterOptions,
+    ExceptionInfoResponseBody,
     ExceptionOptions,
     OutputCategory,
     OutputEvent,
@@ -291,6 +296,30 @@ class HitCountEntry(NamedTuple):
     type: str
 
 
+# A breakpoint's hit count is read as in debugpy: `N` or `== N` stops at the N-th hit, `>`, `>=`,
+# `<` and `<=` compare the hits with N, and `% N` stops at every N-th hit.
+_HIT_CONDITION_PATTERN = re.compile(r"^\s*(==|>=|<=|>|<|%)?\s*(\d+)\s*$")
+_HIT_CONDITION_OPERATORS: Dict[str, Callable[[int, int], bool]] = {
+    "==": operator.eq,
+    ">": operator.gt,
+    ">=": operator.ge,
+    "<": operator.lt,
+    "<=": operator.le,
+    "%": lambda hits, value: hits % value == 0,
+}
+
+
+def hit_condition_met(hit_condition: str, hits: int) -> bool:
+    """Whether a breakpoint with `hit_condition` stops at its `hits`-th hit.
+
+    Raises `ValueError` for a hit condition that has none of the forms above.
+    """
+    match = _HIT_CONDITION_PATTERN.match(hit_condition)
+    if match is None or (match.group(1) == "%" and int(match.group(2)) == 0):
+        raise ValueError(f"'{hit_condition}' is not a valid hit count; use N, == N, > N, >= N, < N, <= N or % N.")
+    return _HIT_CONDITION_OPERATORS[match.group(1) or "=="](hits, int(match.group(2)))
+
+
 class PathMapping(NamedTuple):
     local_root: Optional[str]
     remote_root: Optional[str]
@@ -299,6 +328,21 @@ class PathMapping(NamedTuple):
 class DebugLoggerBase:
     def __init__(self) -> None:
         self.steps: List[Any] = []
+        self.last_fail_message: Optional[str] = None
+        self.last_fail_traceback: Optional[str] = None
+
+    def log_message(self, message: Any) -> None:
+        # Robot Framework logs a failure's Python traceback at DEBUG right after its message; unlike a listener, a
+        # registered logger gets it whatever the log level
+        if message.level == "FAIL":
+            self.last_fail_message = message.message
+            self.last_fail_traceback = None
+        elif (
+            message.level == "DEBUG"
+            and message.message.startswith("Traceback (most recent call last):")
+            and message.message.splitlines()[1:2] != ["  None"]
+        ):
+            self.last_fail_traceback = message.message
 
 
 if RF_VERSION < (7, 0):
@@ -437,6 +481,7 @@ class Debugger:
         self._variables_cache: Dict[int, Any] = {}
         self._variables_object_cache: List[Any] = []
         self._current_exception: Optional[ExceptionInformation] = None
+        self._current_exception_info: Optional[ExceptionInfoResponseBody] = None
 
     @property
     def state(self) -> State:
@@ -658,7 +703,17 @@ class Debugger:
         if self.state == State.Stopped:
             return
 
-        if self.requested_state == RequestedState.Pause:
+        if self.terminated:
+            # after a terminate request the run goes on to its end, so pending pause and step requests are dropped
+            if self.requested_state in (
+                RequestedState.Pause,
+                RequestedState.Next,
+                RequestedState.StepIn,
+                RequestedState.StepOut,
+            ):
+                self.requested_state = RequestedState.Nothing
+
+        elif self.requested_state == RequestedState.Pause:
             self.requested_state = RequestedState.Nothing
             self.state = State.Paused
 
@@ -723,6 +778,9 @@ class Debugger:
             source_path = self.map_path_to_client(str(Path(source).absolute()))
             if source_path in self.breakpoints:
                 breakpoints = [v for v in self.breakpoints[source_path].breakpoints if v.line == line_no]
+                if self.terminated:
+                    # after a terminate request only breakpoints that write a log message, and never pause, are left
+                    breakpoints = [v for v in breakpoints if v.log_message]
                 if len(breakpoints) > 0:
                     for point in breakpoints:
                         if point.condition is not None:
@@ -737,23 +795,44 @@ class Debugger:
                                 )
                             except (SystemExit, KeyboardInterrupt):
                                 raise
-                            except BaseException:
+                            except BaseException as e:
                                 hit = False
+                                error = str(e) or e.__class__.__name__
+                                self.send_event(
+                                    self,
+                                    OutputEvent(
+                                        body=OutputEventBody(
+                                            output=f"Breakpoint condition error: {error}{os.linesep}",
+                                            category=OutputCategory.STDERR,
+                                            source=Source(path=str(source_path)),
+                                            line=line_no,
+                                        )
+                                    ),
+                                )
 
                             if not hit:
                                 return
-                        if point.hit_condition is not None:
+                        if point.hit_condition:
                             hit = False
                             entry = HitCountEntry(source_path, line_no, type)
                             if entry not in self.hit_counts:
                                 self.hit_counts[entry] = 0
                             self.hit_counts[entry] += 1
                             try:
-                                hit = self.hit_counts[entry] != int(point.hit_condition)
-                            except (SystemExit, KeyboardInterrupt):
-                                raise
-                            except BaseException:
+                                hit = hit_condition_met(point.hit_condition, self.hit_counts[entry])
+                            except ValueError as e:
                                 hit = False
+                                self.send_event(
+                                    self,
+                                    OutputEvent(
+                                        body=OutputEventBody(
+                                            output=f"Breakpoint hit count error: {e}{os.linesep}",
+                                            category=OutputCategory.STDERR,
+                                            source=Source(path=str(source_path)),
+                                            line=line_no,
+                                        )
+                                    ),
+                                )
                             if not hit:
                                 return
                         if point.log_message:
@@ -798,27 +877,39 @@ class Debugger:
         filter_id: Set[str],
         description: str,
         text: Optional[str],
+        name: str,
+        message: Optional[str],
     ) -> None:
         if self.state == State.CallKeyword:
             return
         if self.state == State.Stopped:
             return
 
-        if (
-            not self.terminated
-            and status == "FAIL"
-            and any(
-                v
-                for v in self.exception_breakpoints
-                if v.filter_options and any(o for o in v.filter_options if o.filter_id in filter_id)
-            )
-        ):
+        matched_filter_ids = {
+            o.filter_id
+            for v in self.exception_breakpoints
+            if v.filter_options
+            for o in v.filter_options
+            if o.filter_id in filter_id
+        }
+
+        if not self.terminated and status == "FAIL" and matched_filter_ids:
             reason = StoppedReason.EXCEPTION
 
             self.requested_state = RequestedState.Nothing
             self.state = State.Paused
 
             self._current_exception = {"text": text, "description": description, "status": status}
+            self._current_exception_info = ExceptionInfoResponseBody(
+                exception_id=name,
+                break_mode=(
+                    ExceptionBreakMode.UNHANDLED
+                    if "uncaught_failed_keyword" in matched_filter_ids
+                    else ExceptionBreakMode.ALWAYS
+                ),
+                description=message,
+                details=self._create_exception_details(message),
+            )
 
             self.send_event(
                 self,
@@ -840,8 +931,16 @@ class Debugger:
                         lambda: (
                             self.state in [State.Running, State.Stopped, State.CallKeyword]
                             or self.requested_state != RequestedState.Nothing
+                            or self.terminated
                         )
                     )
+                    # a pause that began while a terminate request arrived ends at once, the run goes on to its end
+                    if (
+                        self.terminated
+                        and self.state == State.Paused
+                        and self.requested_state == RequestedState.Nothing
+                    ):
+                        self.requested_state = RequestedState.Running
 
                 if self.state == State.CallKeyword:
                     self._evaluated_keyword_result = None
@@ -876,6 +975,7 @@ class Debugger:
 
                 break
             self._current_exception = None
+            self._current_exception_info = None
 
     def start_output_group(self, name: str, attributes: AttributeDict, type: Optional[str] = None) -> None:
         if self.group_output:
@@ -887,7 +987,7 @@ class Debugger:
                 OutputEvent(
                     body=OutputEventBody(
                         output=f"\u001b[38;5;14m{(type + ' ') if type else ''}\u001b[0m{name}\n",
-                        category="OutputCategory.CONSOLE",
+                        category=OutputCategory.CONSOLE,
                         group=OutputGroup.START,
                         source=Source(path=str(self.map_path_to_client(source))) if source else None,
                         line=line_no if source is not None else None,
@@ -1018,7 +1118,7 @@ class Debugger:
         entry = self.add_stackframe_entry(name, type, source, line_no, longname=longname)
 
         if self.debug:
-            if self.stop_on_entry:
+            if self.stop_on_entry and not self.terminated:
                 self.stop_on_entry = False
 
                 self.requested_state = RequestedState.Nothing
@@ -1057,6 +1157,8 @@ class Debugger:
                     {"failed_suite"},
                     "Suite failed.",
                     f"Suite failed{f': {v}' if (v := attributes.get('message')) else ''}",
+                    name,
+                    attributes.get("message"),
                 )
                 self.wait_for_running()
 
@@ -1103,9 +1205,11 @@ class Debugger:
             if status == "FAIL":
                 self.process_end_state(
                     status,
-                    {""},
+                    {"failed_test"},
                     "Test failed.",
                     f"Test failed{f': {v}' if (v := attributes.get('message')) else ''}",
+                    name,
+                    attributes.get("message"),
                 )
 
                 self.wait_for_running()
@@ -1300,6 +1404,8 @@ class Debugger:
                     },
                     "Keyword failed.",
                     f"Keyword failed: {self.last_fail_message}" if self.last_fail_message else "Keyword failed.",
+                    name,
+                    self.last_fail_message,
                 )
 
                 self.wait_for_running()
@@ -1757,7 +1863,14 @@ class Debugger:
     if RF_VERSION >= (7, 0):
 
         def _run_keyword(self, kw: Keyword, context: Any) -> Any:
-            return kw.run(context.steps[-1][1], context)
+            # An evaluated keyword becomes a child of the running step. At a stop
+            # where no step runs, such as the end of a test or suite, 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:
 
@@ -2062,7 +2175,7 @@ class Debugger:
 
                 self._after_evaluate_keyword_event.set()
 
-            return result
+        return result
 
     def _create_set_variable_result(self, value: Any) -> SetVariableResult:
         if isinstance(value, Mapping):
@@ -2135,7 +2248,7 @@ class Debugger:
                 if option.filter_id in [
                     "failed_keyword",
                     "uncaught_failed_keyword",
-                    "",
+                    "failed_test",
                     "failed_suite",
                 ]:
                     entry = ExceptionBreakpointsEntry(
@@ -2151,6 +2264,38 @@ class Debugger:
 
         return result or None
 
+    def _create_exception_details(self, message: Optional[str]) -> Optional[ExceptionDetails]:
+        rows: List[Tuple[str, Optional[str]]] = []
+        # outermost first, as Python lists calls, so that a traceback below continues the list into the library
+        for entry in reversed(self.stack_frames):
+            if entry.type == "SUITE":
+                continue
+            position = entry.stack_frames[0] if entry.stack_frames else None if entry.top_hidden else entry
+            if position is None:
+                continue
+            source = self.source_from_entry(position)
+            location = None
+            if source is not None and source.path:
+                location = source.path if position.line is None else f"{source.path}:{position.line}"
+            rows.append((entry.longname or entry.kwname or entry.name or entry.type, location))
+
+        width = max((len(name) for name, _ in rows), default=0)
+        stack_trace = "\n".join(f"{name.ljust(width)}  {location}" if location else name for name, location in rows)
+
+        logger = self.debug_logger
+        if message and logger is not None and logger.last_fail_message == message and logger.last_fail_traceback:
+            stack_trace = "\n\n".join(part for part in (stack_trace, logger.last_fail_traceback) if part)
+
+        return ExceptionDetails(stack_trace=stack_trace) if stack_trace else None
+
+    def get_exception_info(self, thread_id: int) -> ExceptionInfoResponseBody:
+        self.check_thread_id(thread_id)
+
+        if self._current_exception_info is None:
+            raise RuntimeError("The run is not stopped at a failure.")
+
+        return self._current_exception_info
+
     if RF_VERSION >= (7, 0):
 
         def _get_keywords_from_lib(self, lib: Any) -> Any:

{robotcode_debugger-2.7.0 → robotcode_debugger-2.8.0}/src/robotcode/debugger/default_capabilities.py

@@ -28,21 +28,22 @@ DFEAULT_CAPABILITIES = Capabilities(
         ),
         ExceptionBreakpointsFilter(
             filter="failed_test",
-            label="Failed Test",
+            label="Failed Tests",
             description="Breaks on failed tests",
             default=False,
             supports_condition=True,
         ),
         ExceptionBreakpointsFilter(
             filter="failed_suite",
-            label="Failed Suite",
-            description="Breaks on failed suite",
+            label="Failed Suites",
+            description="Breaks on failed suites",
             default=False,
             supports_condition=True,
         ),
     ],
     supports_exception_options=True,
     supports_exception_filter_options=True,
+    supports_exception_info_request=True,
     supports_completions_request=True,
     supports_a_n_s_i_styling=True,
 )

{robotcode_debugger-2.7.0 → robotcode_debugger-2.8.0}/src/robotcode/debugger/launcher/server.py

@@ -6,7 +6,7 @@ import os
 import shlex
 import sys
 from pathlib import Path
-from typing import Any, Dict, List, Literal, Optional
+from typing import Any, Dict, List, Literal, Mapping, Optional
 
 from robotcode.core.types import ServerMode, TcpParams
 from robotcode.core.utils.logging import LoggingDescriptor
@@ -70,6 +70,30 @@ def _build_robotcode_run_args(
     ]
 
 
+Console = Literal["robotcodeTerminal", "internalConsole", "integratedTerminal", "externalTerminal"]
+
+
+def _console_for_client(console: Optional[Console], client_id: Optional[str]) -> Optional[Console]:
+    """The console a run uses: RobotCode's own run terminal is part of its VS Code extension, so any other client
+    gets the integrated terminal instead."""
+    if console == "robotcodeTerminal" and client_id != "vscode":
+        return "integratedTerminal"
+    return console
+
+
+def _merged_environment(
+    base: Mapping[str, str], env: Mapping[str, Optional[str]], windows: bool
+) -> Dict[str, Optional[str]]:
+    """The environment of a run: ``base`` with the variables of ``env``. On Windows, where a name means the same
+    variable in any case, a variable of ``env`` replaces the one of ``base`` whose name differs only in case, and of
+    two names in ``env`` that differ only in case, the last one stays."""
+    if windows:
+        last = {name.upper(): name for name in env}
+        env = {name: value for name, value in env.items() if last[name.upper()] == name}
+        base = {name: value for name, value in base.items() if name.upper() not in last}
+    return {**base, **env}
+
+
 class OutputProtocol(asyncio.SubprocessProtocol):
     def __init__(self, parent: LauncherDebugAdapterProtocol) -> None:
         super().__init__()
@@ -136,7 +160,7 @@ class LauncherDebugAdapterProtocol(DebugAdapterProtocol):
         paths: Optional[List[str]] = None,
         args: Optional[List[str]] = None,
         env: Optional[Dict[str, Optional[Any]]] = None,
-        console: Optional[Literal["internalConsole", "integratedTerminal", "externalTerminal"]] = "integratedTerminal",
+        console: Optional[Console] = "integratedTerminal",
         name: Optional[str] = None,
         no_debug: Optional[bool] = None,
         robotPythonPath: Optional[List[str]] = None,  # noqa: N803
@@ -263,7 +287,19 @@ class LauncherDebugAdapterProtocol(DebugAdapterProtocol):
 
         env = {k: ("" if v is None else str(v)) for k, v in env.items()} if env else {}
 
-        if console in ["integratedTerminal", "externalTerminal"]:
+        console = _console_for_client(
+            console, self._initialize_arguments.client_id if self._initialize_arguments is not None else None
+        )
+
+        if console == "robotcodeTerminal":
+            # RobotCode's VS Code extension runs it as the process of a terminal of its own, without a shell
+            await self.send_event_async(
+                Event(
+                    event="runInRobotCodeTerminal",
+                    body={"cwd": cwd, "args": [*robotcode_run_args, *run_args], "env": env, "title": name},
+                )
+            )
+        elif console in ["integratedTerminal", "externalTerminal"]:
             await self.send_request_async(
                 RunInTerminalRequest(
                     arguments=RunInTerminalRequestArguments(
@@ -284,8 +320,7 @@ class LauncherDebugAdapterProtocol(DebugAdapterProtocol):
             )
             # time.sleep(1)  # Give some time for the terminal to start
         elif console is None or console == "internalConsole":
-            run_env: Dict[str, Optional[str]] = dict(os.environ)
-            run_env.update(env)
+            run_env = _merged_environment(os.environ, env, sys.platform == "win32")
 
             await asyncio.get_event_loop().subprocess_exec(
                 lambda: OutputProtocol(self), *robotcode_run_args, *run_args, cwd=cwd, env=run_env

{robotcode_debugger-2.7.0 → robotcode_debugger-2.8.0}/src/robotcode/debugger/listeners.py

@@ -1,7 +1,7 @@
 import re
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Dict, Iterator, List, Optional, Union, cast
+from typing import Any, Dict, Iterator, List, Optional, Set, Union, cast
 
 from robot import result, running
 from robot.model import Message
@@ -13,6 +13,14 @@ from .debugger import Debugger, LogMessage
 from .mixins import SyncedEventBody
 
 
+@dataclass
+class RobotFailure(Model):
+    # indices into failed_keywords: the failed keyword whose message and caught mark are the failure's, and the failed
+    # keywords from the innermost call out to the test
+    keyword: int
+    calls: List[int]
+
+
 @dataclass
 class RobotExecutionEventBody(Model, SyncedEventBody):
     type: str
@@ -21,6 +29,8 @@ class RobotExecutionEventBody(Model, SyncedEventBody):
     parent_id: Optional[str] = None
     attributes: Optional[Dict[str, Any]] = None
     failed_keywords: Optional[List[Dict[str, Any]]] = None
+    # in the order their keywords ended
+    failures: Optional[List[RobotFailure]] = None
     source: Optional[str] = None
     lineno: Optional[int] = None
     synced: bool = True
@@ -56,11 +66,31 @@ def source_from_attributes(attributes: Dict[str, Any]) -> str:
     return s or ""
 
 
+def without_empty_lineno(attributes: Dict[str, Any]) -> Dict[str, Any]:
+    """A copy of listener attributes with an empty line number as None. Up to Robot Framework 6.1, listeners get ""
+    for a test or keyword without one, as a custom parser or a pre-run modifier creates them."""
+    result = dict(attributes)
+    if result.get("lineno") == "":
+        result["lineno"] = None
+    return result
+
+
 class ListenerV2:
     ROBOT_LISTENER_API_VERSION = "2"
 
     def __init__(self) -> None:
         self.failed_keywords: Optional[List[Dict[str, Any]]] = None
+        # the number of failed keywords when each running keyword or control structure started; per depth, the failed
+        # keywords of the last TRY branch there, and those of them that its EXCEPT branch caught
+        self.failed_keyword_marks: List[int] = []
+        # by the id of a failed keyword, the nearest failed keyword it ran in
+        self.failed_keyword_parents: Dict[int, Dict[str, Any]] = {}
+        # per running keyword or control structure, whether it logged a failure itself, as Robot Framework does for the
+        # keyword whose error it is; and the ids of the failed keywords that did
+        self.failure_logged: List[bool] = []
+        self.failed_keywords_with_own_failure: Set[int] = set()
+        self.try_failures: Dict[int, List[Dict[str, Any]]] = {}
+        self.caught_by_except: Dict[int, List[Dict[str, Any]]] = {}
         self.last_fail_message: Optional[str] = None
         self.suite_id_stack: List[str] = []
 
@@ -105,16 +135,17 @@ class ListenerV2:
                     id=id,
                     parent_id=self.suite_id_stack[-1] if self.suite_id_stack else None,
                     failed_keywords=self.failed_keywords,
+                    failures=self._failures(),
                     source=source_from_attributes(attributes) or None,
                     lineno=attributes.get("lineno", None),
                 ),
             ),
         )
         self.suite_id_stack.pop()
-        self.failed_keywords = None
+        self._forget_failed_keywords()
 
     def start_test(self, name: str, attributes: Dict[str, Any]) -> None:
-        self.failed_keywords = None
+        self._forget_failed_keywords()
 
         Debugger.instance.send_event(
             self,
@@ -124,11 +155,11 @@ class ListenerV2:
                     type="test",
                     name=name,
                     id=f"{source_from_attributes(attributes)};{attributes.get('longname', '')};"
-                    f"{attributes.get('lineno', 0)}",
+                    f"{attributes.get('lineno') or 0}",
                     parent_id=self.suite_id_stack[-1] if self.suite_id_stack else None,
-                    attributes=dict(attributes),
+                    attributes=without_empty_lineno(attributes),
                     source=source_from_attributes(attributes) or None,
-                    lineno=attributes.get("lineno", None),
+                    lineno=attributes.get("lineno") or None,
                 ),
             ),
         )
@@ -150,19 +181,89 @@ class ListenerV2:
                     type="test",
                     name=name,
                     id=f"{source_from_attributes(attributes)};{attributes.get('longname', '')};"
-                    f"{attributes.get('lineno', 0)}",
+                    f"{attributes.get('lineno') or 0}",
                     parent_id=self.suite_id_stack[-1] if self.suite_id_stack else None,
-                    attributes=dict(attributes),
+                    attributes=without_empty_lineno(attributes),
                     failed_keywords=self.failed_keywords,
+                    failures=self._failures(),
                     source=source_from_attributes(attributes) or None,
-                    lineno=attributes.get("lineno", None),
+                    lineno=attributes.get("lineno") or None,
                 ),
             ),
         )
 
+        self._forget_failed_keywords()
+
+    def _forget_failed_keywords(self) -> None:
         self.failed_keywords = None
+        self.failed_keyword_parents = {}
+        self.failed_keywords_with_own_failure = set()
+
+    def _failures(self) -> Optional[List[RobotFailure]]:
+        keywords = self.failed_keywords
+        if not keywords:
+            return None
+
+        index = {id(keyword): i for i, keyword in enumerate(keywords)}
+        parents = self.failed_keyword_parents
+
+        # the failed keywords inside a keyword are those it is the parent of that are caught, or not caught, like it; a
+        # caught one inside a keyword that is not caught was caught within it and stays a failure of its own
+        def is_inside(keyword: Dict[str, Any], parent: Optional[Dict[str, Any]]) -> bool:
+            return parent is not None and bool(parent.get("caught")) == bool(keyword.get("caught"))
+
+        inside: Dict[int, List[Dict[str, Any]]] = {}
+        for keyword in keywords:
+            parent = parents.get(id(keyword))
+            if parent is not None and is_inside(keyword, parent):
+                inside.setdefault(id(parent), []).append(keyword)
+
+        # a keyword that logged a failure of its own after failures inside it turned theirs into its own, as Wait Until
+        # Keyword Succeeds does after its last attempt; one that passes them on or collects them logs none
+        def turns_into_own(keyword: Dict[str, Any]) -> bool:
+            return bool(inside.get(id(keyword))) and id(keyword) in self.failed_keywords_with_own_failure
+
+        def within(keyword: Dict[str, Any]) -> Iterator[Dict[str, Any]]:
+            current, parent = keyword, parents.get(id(keyword))
+            while parent is not None and is_inside(current, parent):
+                yield parent
+                current, parent = parent, parents.get(id(parent))
+
+        def outwards(keyword: Dict[str, Any]) -> List[int]:
+            calls = []
+            current: Optional[Dict[str, Any]] = keyword
+            while current is not None:
+                calls.append(index[id(current)])
+                current = parents.get(id(current))
+            return calls
+
+        # the calls of the newest failure inside the keyword, up to it
+        def last_inside(keyword: Dict[str, Any]) -> List[int]:
+            for candidate in keywords:
+                if inside.get(id(candidate)):
+                    continue
+                calls = [index[id(candidate)]]
+                for outer in within(candidate):
+                    if outer is keyword:
+                        return calls
+                    calls.append(index[id(outer)])
+            return []
+
+        failures = []
+        for keyword in reversed(keywords):
+            if any(turns_into_own(outer) for outer in within(keyword)):
+                continue
+            if turns_into_own(keyword):
+                failures.append(RobotFailure(index[id(keyword)], last_inside(keyword) + outwards(keyword)))
+            elif not inside.get(id(keyword)):
+                failures.append(RobotFailure(index[id(keyword)], outwards(keyword)))
+
+        return failures
 
     def start_keyword(self, name: str, attributes: Dict[str, Any]) -> None:
+        self.failed_keyword_marks.append(len(self.failed_keywords or []))
+        self.failure_logged.append(False)
+
         if attributes["type"] in ["KEYWORD", "SETUP", "TEARDOWN"]:
             Debugger.instance.start_output_group(
                 f"{name}({', '.join(repr(v) for v in attributes.get('args', []))})",
@@ -191,6 +292,8 @@ class ListenerV2:
 
     def end_keyword(self, name: str, attributes: Dict[str, Any]) -> None:
         Debugger.instance.end_keyword(name, attributes)
+        mark = self.failed_keyword_marks.pop() if self.failed_keyword_marks else 0
+        failure_logged = self.failure_logged.pop() if self.failure_logged else False
 
         # if Debugger.instance.state != State.CallKeyword:
         #     Debugger.instance.send_event(
@@ -216,7 +319,38 @@ class ListenerV2:
                 if self.failed_keywords is None:
                     self.failed_keywords = []
 
-                self.failed_keywords.insert(0, {"message": self.last_fail_message, **attributes})
+                keyword = {"message": self.last_fail_message, **without_empty_lineno(attributes)}
+                # it is the nearest failed keyword around those that ended since it started and have none yet
+                for inner in self.failed_keywords[: max(0, len(self.failed_keywords) - mark)]:
+                    self.failed_keyword_parents.setdefault(id(inner), keyword)
+                self.failed_keywords.insert(0, keyword)
+                if failure_logged:
+                    self.failed_keywords_with_own_failure.add(id(keyword))
+
+        self._mark_caught_failures(attributes, mark, len(self.failed_keyword_marks))
+
+    def _mark_caught_failures(self, attributes: Dict[str, Any], mark: int, depth: int) -> None:
+        # Robot Framework's log expands a failed test only along what failed, so a failure inside a keyword or control
+        # structure that did not fail was caught, as by Run Keyword And Ignore Error. Listener version 2 gets the
+        # branches of a TRY/EXCEPT but not the TRY/EXCEPT, whose status the log follows: an EXCEPT branch that passed
+        # caught the failures of its TRY branch, unless the FINALLY branch fails and with it the TRY/EXCEPT
+        kind, status = attributes["type"], attributes["status"]
+        failed = self.failed_keywords or []
+        inside = failed[: max(0, len(failed) - mark)]
+        if status != "FAIL":
+            for keyword in inside:
+                keyword["caught"] = True
+        if kind == "TRY":
+            self.try_failures[depth] = inside
+            self.caught_by_except[depth] = []
+        elif kind == "EXCEPT" and status == "PASS":
+            caught = [keyword for keyword in self.try_failures.get(depth, []) if not keyword.get("caught")]
+            for keyword in caught:
+                keyword["caught"] = True
+            self.caught_by_except[depth] = caught
+        elif kind == "FINALLY" and status == "FAIL":
+            for keyword in self.caught_by_except.pop(depth, []):
+                keyword.pop("caught", None)
 
     RE_FILE_LINE_MATCHER = re.compile(r".+\sin\sfile\s'(?P<file>.*)'\son\sline\s(?P<line>\d+):(?P<message>.*)")
 
@@ -227,9 +361,11 @@ class ListenerV2:
             if message["level"] == "FAIL":
                 self.last_fail_message = message["message"]
                 Debugger.instance.last_fail_message = self.last_fail_message
+                if self.failure_logged:
+                    self.failure_logged[-1] = True
 
             source = current_frame.source if current_frame else None
-            line = current_frame.line if current_frame else None
+            line = (current_frame.line or None) if current_frame else None
             column = current_frame.column if current_frame else None
 
             item_id = next(
@@ -238,7 +374,7 @@ class ListenerV2:
                         f"{normalized_path(Path(item.source)) if item.source is not None else ''};{item.longname}"
                         if item.type == "SUITE"
                         else f"{normalized_path(Path(item.source)) if item.source is not None else ''};"
-                        f"{item.longname};{item.line}"
+                        f"{item.longname};{item.line or 0}"
                     )
                     for item in Debugger.instance.full_stack_frames
                     if item.type in ["SUITE", "TEST"]
@@ -278,7 +414,7 @@ class ListenerV2:
             current_frame = Debugger.instance.full_stack_frames[0] if Debugger.instance.full_stack_frames else None
 
             source = current_frame.source if current_frame else None
-            line = current_frame.line if current_frame else None
+            line = (current_frame.line or None) if current_frame else None
             column = current_frame.column if current_frame else None
 
             item_id = next(
@@ -287,7 +423,7 @@ class ListenerV2:
                         f"{normalized_path(Path(item.source)) if item.source is not None else ''};{item.longname}"
                         if item.type == "SUITE"
                         else f"{normalized_path(Path(item.source)) if item.source is not None else ''};"
-                        f"{item.longname};{item.line}"
+                        f"{item.longname};{item.line or 0}"
                     )
                     for item in Debugger.instance.full_stack_frames
                     if item.type in ["SUITE", "TEST"]
@@ -371,7 +507,9 @@ class ListenerV3:
                     yield from enqueue(s)
                 return
 
-            yield (f"{normalized_path(item.source) if item.source is not None else ''};{item.longname};{item.lineno}")
+            yield (
+                f"{normalized_path(item.source) if item.source is not None else ''};{item.longname};{item.lineno or 0}"
+            )
 
         if self._event_sended:
             return
@@ -404,9 +542,10 @@ class ListenerV3:
                                 "lineno": data_item.lineno if data_item is not None else 0,
                                 "message": result_item.message,
                             },
-                            id=f"{result_item.source or ''};{result_item.longname or ''}"
+                            id=f"{normalized_path(Path(result_item.source)) if result_item.source else ''};"
+                            f"{result_item.longname or ''}"
                             + (
-                                f";{data_item.lineno if data_item is not None else 0}"
+                                f";{(data_item.lineno if data_item is not None else None) or 0}"
                                 if isinstance(result_item, result.TestCase)
                                 else ""
                             ),

{robotcode_debugger-2.7.0 → robotcode_debugger-2.8.0}/src/robotcode/debugger/run.py

@@ -5,7 +5,9 @@ import threading
 import time
 from concurrent.futures import CancelledError
 from typing import (
+    IO,
     TYPE_CHECKING,
+    Any,
     Callable,
     List,
     Optional,
@@ -25,7 +27,7 @@ from robotcode.core.utils.debugpy import (
 )
 from robotcode.core.utils.logging import LoggingDescriptor
 from robotcode.core.utils.net import find_free_port
-from robotcode.plugin import Application
+from robotcode.plugin import Application, UnknownError
 
 from .dap_types import Event
 from .debugger import Debugger
@@ -145,6 +147,40 @@ def start_debugpy(
         config_done_callback = connect_debugpy
 
 
+def _run_robot(ctx: click.Context, app: Application, args: List[str]) -> int:
+    from robotcode.runner.cli.robot import robot
+
+    args = [
+        "--listener",
+        "robotcode.debugger.listeners.ListenerV3",
+        "--listener",
+        "robotcode.debugger.listeners.ListenerV2",
+        *args,
+    ]
+
+    app.verbose("Start robot")
+    try:
+        app.verbose(f"Create robot context with args: {args}")
+        robot_ctx = robot.make_context("robot", args, parent=ctx)
+        robot.invoke(robot_ctx)
+    except SystemExit as e:
+        return cast(int, e.code)
+    return 0
+
+
+class _ShownError(click.ClickException):
+    """An error that `run_debugger` showed before the debug session ended. It keeps the
+    error's exit code and shows nothing, so the command shows the error only once."""
+
+    def __init__(self, error: click.ClickException) -> None:
+        super().__init__(error.message)
+        # click declares the exit code on the class; this one is the code of the error shown
+        self.exit_code = error.exit_code  # type: ignore[misc]
+
+    def show(self, file: Optional[IO[Any]] = None) -> None:
+        pass
+
+
 @_logger.call
 def run_debugger(
     ctx: click.Context,
@@ -167,6 +203,11 @@ def run_debugger(
     output_timestamps: bool = False,
     group_output: bool = False,
 ) -> int:
+    if app.config.dry:
+        # A dry run starts neither debugpy nor the debug adapter and waits for no
+        # client; the robot command only prints what it would execute.
+        return _run_robot(ctx, app, args)
+
     if debug and debugpy and not is_debugpy_installed():
         app.warning("Debugpy not installed")
 
@@ -215,14 +256,6 @@ def run_debugger(
         if debugpy and debugpy_wait_for_client:
             debugpy_connected.wait(wait_for_client_timeout)
 
-        args = [
-            "--listener",
-            "robotcode.debugger.listeners.ListenerV3",
-            "--listener",
-            "robotcode.debugger.listeners.ListenerV2",
-            *args,
-        ]
-
         Debugger.instance.stop_on_entry = stop_on_entry
         Debugger.instance.output_messages = output_messages
         Debugger.instance.output_log = output_log
@@ -237,15 +270,17 @@ def run_debugger(
 
         exit_code = 0
         try:
-            from robotcode.runner.cli.robot import robot
-
-            app.verbose("Start robot")
-            try:
-                app.verbose(f"Create robot context with args: {args}")
-                robot_ctx = robot.make_context("robot", args, parent=ctx)
-                robot.invoke(robot_ctx)
-            except SystemExit as e:
-                exit_code = cast(int, e.code)
+            exit_code = _run_robot(ctx, app, args)
+        except CancelledError:
+            raise
+        except Exception as e:
+            # An error that stops the run, such as one of the configuration: shown
+            # while the session lasts, since the debug launcher forwards the output of
+            # the run to VS Code's Debug Console only until then. An error that is not
+            # robotcode's own is shown as `debug` shows it.
+            error = e if isinstance(e, click.ClickException) else UnknownError(str(e))
+            error.show()
+            raise _ShownError(error) from e
         finally:
             if server.protocol.connected:
                 server.protocol.send_event(

{robotcode_debugger-2.7.0 → robotcode_debugger-2.8.0}/src/robotcode/debugger/server.py

@@ -23,6 +23,8 @@ from .dap_types import (
     EvaluateArguments,
     EvaluateResponseBody,
     Event,
+    ExceptionInfoArguments,
+    ExceptionInfoResponseBody,
     ExitedEvent,
     ExitedEventBody,
     InitializedEvent,
@@ -208,6 +210,11 @@ class DebugAdapterServerProtocol(DebugAdapterProtocol):
         *args: Any,
         **kwargs: Any,
     ) -> None:
+        if self.exited:
+            # The run has ended and the process only waits for the client to disconnect. A signal would end it with
+            # the exit code of an interrupt and skip its exit handlers, such as those that close a library's browsers.
+            return
+
         Debugger.instance.terminate()
 
         if not restart and not self._sigint_signaled:
@@ -384,6 +391,15 @@ class DebugAdapterServerProtocol(DebugAdapterProtocol):
         )
         return SetExceptionBreakpointsResponseBody(breakpoints=result) if result else None
 
+    @rpc_method(name="exceptionInfo", param_type=ExceptionInfoArguments)
+    async def _exception_info(
+        self,
+        arguments: ExceptionInfoArguments,
+        *args: Any,
+        **kwargs: Any,
+    ) -> ExceptionInfoResponseBody:
+        return Debugger.instance.get_exception_info(arguments.thread_id)
+
     @rpc_method(name="completions", param_type=CompletionsArguments)
     async def _completions(
         self,

robotcode_debugger-2.7.0/src/robotcode/debugger/__version__.py

@@ -1 +0,0 @@
-__version__ = "2.7.0"