🚀 Clear assertion greyed-out lines on restart and highlight issue locations

.github/workflows/ci.yml

@@ -174,9 +174,9 @@ jobs:
     runs-on: ubuntu-slim
     steps:
       - name: Decide whether the needed jobs succeeded or failed
-        uses: re-actors/alls-green@05ac9388f0aebcb5727afa17fcccfecd6f8ec5fe # v1.2.2
-        with:
-          allowed-skips: >-
+        env:
+          NEEDS_JSON: ${{ toJSON(needs) }}
+          ALLOWED_SKIPS: >-
             ${{
               fromJSON(needs.change-detection.outputs.run-cpp-tests)
               && '' || 'cpp-tests-ubuntu,cpp-tests-macos,cpp-tests-windows,'
@@ -193,4 +193,39 @@ jobs:
               fromJSON(needs.change-detection.outputs.run-cd)
               && '' || 'build-sdist,build-wheel'
             }}
-          jobs: ${{ toJSON(needs) }}
+          ALLOWED_CANCELS: cpp-tests-windows
+          ALLOWED_FAILURES: ""
+        run: |
+          python - <<'PY'
+          import json
+          import os
+          import sys
+
+          def split_csv(value: str) -> set[str]:
+              return {item for item in value.replace("\n", "").split(",") if item}
+
+          needs = json.loads(os.environ["NEEDS_JSON"])
+          allowed_skips = split_csv(os.environ.get("ALLOWED_SKIPS", ""))
+          allowed_cancels = split_csv(os.environ.get("ALLOWED_CANCELS", ""))
+          allowed_failures = split_csv(os.environ.get("ALLOWED_FAILURES", ""))
+
+          failures = []
+          for job, info in needs.items():
+              result = (info or {}).get("result")
+              if result == "success":
+                  continue
+              if result == "skipped" and job in allowed_skips:
+                  continue
+              if result == "cancelled" and job in allowed_cancels:
+                  continue
+              if result == "failure" and job in allowed_failures:
+                  continue
+              failures.append(f"{job} => {result}")
+
+          if failures:
+              print("Some of the required jobs failed or were cancelled:")
+              for item in failures:
+                  print(f"  - {item}")
+              sys.exit(1)
+          print("All required jobs are green (or allowed to skip/cancel/fail).")
+          PY

bindings/InterfaceBindings.cpp

@@ -62,6 +62,41 @@ struct StatevectorCPP {
 
 // NOLINTNEXTLINE(misc-use-internal-linkage)
 void bindFramework(nb::module_& m) {
+  // Bind the Result enum
+  nb::enum_<Result>(m, "Result", "Represents the result of an operation.")
+      .value("OK", OK, "Indicates that the operation was successful.")
+      .value("ERROR", ERROR, "Indicates that an error occurred.");
+
+  // Bind the LoadResultStatus enum
+  nb::enum_<LoadResultStatus>(
+      m, "LoadResultStatus",
+      "Represents the result of a code loading operation.")
+      .value("OK", LOAD_OK, "Indicates that the code was loaded successfully.")
+      .value("PARSE_ERROR", LOAD_PARSE_ERROR,
+             "Indicates that the code could not be parsed.")
+      .value("INTERNAL_ERROR", LOAD_INTERNAL_ERROR,
+             "Indicates that an internal error occurred while loading.");
+
+  // Bind the LoadResult struct
+  nb::class_<LoadResult>(m, "LoadResult")
+      .def(nb::init<>())
+      .def_rw("status", &LoadResult::status,
+              "Indicates whether the load was successful and why it failed.")
+      .def_rw("line", &LoadResult::line,
+              "The line number of the error location, or 0 if unknown.")
+      .def_rw("column", &LoadResult::column,
+              "The column number of the error location, or 0 if unknown.")
+      .def_prop_ro(
+          "message",
+          [](const LoadResult& self) {
+            if (self.message == nullptr) {
+              return nb::none();
+            }
+            return nb::cast(std::string(self.message));
+          },
+          "A human-readable error message, or None if none is available.")
+      .doc() = "The result of a code loading operation.";
+
   // Bind the VariableType enum
   nb::enum_<VariableType>(m, "VariableType",
                           "The type of a classical variable.")
@@ -164,13 +199,16 @@ Contains one element for each of the `num_states` states in the state vector.)")
       .def(
           "load_code",
           [](SimulationState* self, const char* code) {
-            checkOrThrow(self->loadCode(self, code));
+            return self->loadCode(self, code);
           },
           "code"_a,
           R"(Loads the given code into the simulation state.
 
 Args:
-    code: The code to load.)")
+    code: The code to load.
+
+Returns:
+    LoadResult: The result of the load operation.)")
       .def(
           "step_forward",
           [](SimulationState* self) { checkOrThrow(self->stepForward(self)); },

include/backend/dd/DDSimDebug.hpp

@@ -119,6 +119,10 @@ struct DDSimulationState {
    * @brief The code being executed, after preprocessing.
    */
   std::string processedCode;
+  /**
+   * @brief The most recent load error detail message.
+   */
+  std::string lastLoadErrorDetail;
   /**
    * @brief Indicates whether the debugger is ready to start simulation.
    */
@@ -277,9 +281,9 @@ Result ddsimInit(SimulationState* self);
  * @brief Loads the given code into the simulation state.
  * @param self The instance to load the code into.
  * @param code The code to load.
- * @return The result of the operation.
+ * @return The result of the load operation.
  */
-Result ddsimLoadCode(SimulationState* self, const char* code);
+LoadResult ddsimLoadCode(SimulationState* self, const char* code);
 /**
  * @brief Steps the simulation forward by one instruction.
  * @param self The instance to step forward.

include/backend/debug.h

@@ -50,9 +50,9 @@ struct SimulationStateStruct {
    * @brief Loads the given code into the simulation state.
    * @param self The instance to load the code into.
    * @param code The code to load.
-   * @return The result of the operation.
+   * @return The result of the load operation.
    */
-  Result (*loadCode)(SimulationState* self, const char* code);
+  LoadResult (*loadCode)(SimulationState* self, const char* code);
 
   /**
    * @brief Steps the simulation forward by one instruction.

include/common.h

@@ -42,6 +42,46 @@ typedef enum {
   ERROR,
 } Result;
 
+/**
+ * @brief The result of a code loading operation.
+ */
+typedef enum {
+  /**
+   * @brief Indicates that the code was loaded successfully.
+   */
+  LOAD_OK,
+  /**
+   * @brief Indicates that the code could not be parsed.
+   */
+  LOAD_PARSE_ERROR,
+  /**
+   * @brief Indicates that an internal error occurred while loading the code.
+   */
+  LOAD_INTERNAL_ERROR,
+} LoadResultStatus;
+
+/**
+ * @brief The result of a code loading operation.
+ */
+typedef struct {
+  /**
+   * @brief Indicates whether the load was successful and why it failed.
+   */
+  LoadResultStatus status;
+  /**
+   * @brief The line number of the error location, or 0 if unknown.
+   */
+  size_t line;
+  /**
+   * @brief The column number of the error location, or 0 if unknown.
+   */
+  size_t column;
+  /**
+   * @brief A human-readable error message, or nullptr if none is available.
+   */
+  const char* message;
+} LoadResult;
+
 /**
  * @brief The type of classical variables.
  *

include/common/parsing/CodePreprocessing.hpp

@@ -21,6 +21,7 @@
 #include <cstddef>
 #include <map>
 #include <memory>
+#include <optional>
 #include <set>
 #include <string>
 #include <utility>
@@ -211,6 +212,24 @@ struct ClassicControlledGate {
   std::vector<std::string> operations;
 };
 
+/**
+ * @brief Represents a parsed classic-controlled condition.
+ */
+struct ClassicCondition {
+  /**
+   * @brief The name of the classical register.
+   */
+  std::string registerName;
+  /**
+   * @brief Optional bit index if the condition targets a single bit.
+   */
+  std::optional<size_t> bitIndex;
+  /**
+   * @brief The expected value in the condition comparison.
+   */
+  size_t expectedValue;
+};
+
 /**
  * @brief Represents a function definition in the code.
  */
@@ -286,6 +305,22 @@ bool isClassicControlledGate(const std::string& line);
  */
 ClassicControlledGate parseClassicControlledGate(const std::string& code);
 
+/**
+ * @brief Parse a classic-controlled condition expression.
+ * @param condition The condition string to parse.
+ * @return The parsed condition, or std::nullopt if it cannot be parsed.
+ */
+std::optional<ClassicCondition>
+parseClassicConditionExpression(const std::string& condition);
+
+/**
+ * @brief Parse a classic-controlled condition from a classic-controlled gate.
+ * @param code The code to parse.
+ * @return The parsed condition, or std::nullopt if it cannot be parsed.
+ */
+std::optional<ClassicCondition>
+parseClassicConditionFromCode(const std::string& code);
+
 /**
  * @brief Check if a given line is a variable declaration.
  *

include/common/parsing/ParsingError.hpp

@@ -15,6 +15,7 @@
 
 #pragma once
 
+#include <cstddef>
 #include <stdexcept>
 #include <string>
 
@@ -30,6 +31,44 @@ class ParsingError : public std::runtime_error {
    * @param msg The error message.
    */
   explicit ParsingError(const std::string& msg);
+
+  /**
+   * @brief Constructs a new ParsingError with location information.
+   * @param line The one-based line number, or 0 if unknown.
+   * @param column The one-based column number, or 0 if unknown.
+   * @param detail The error detail message.
+   */
+  ParsingError(size_t line, size_t column, std::string detail);
+
+  /**
+   * @brief Constructs a new ParsingError with location information and message.
+   * @param line The one-based line number, or 0 if unknown.
+   * @param column The one-based column number, or 0 if unknown.
+   * @param detail The error detail message.
+   * @param message The formatted error message.
+   */
+  ParsingError(size_t line, size_t column, std::string detail,
+               const std::string& message);
+
+  /**
+   * @brief Gets the line number of the error location, or 0 if unknown.
+   */
+  size_t line() const noexcept;
+
+  /**
+   * @brief Gets the column number of the error location, or 0 if unknown.
+   */
+  size_t column() const noexcept;
+
+  /**
+   * @brief Gets the error detail message.
+   */
+  const std::string& detail() const noexcept;
+
+private:
+  size_t line_ = 0;
+  size_t column_ = 0;
+  std::string detail_;
 };
 
 } // namespace mqt::debugger

python/mqt/debugger/__init__.py

@@ -18,6 +18,9 @@
     Diagnostics,
     ErrorCause,
     ErrorCauseType,
+    LoadResult,
+    LoadResultStatus,
+    Result,
     SimulationState,
     Statevector,
     Variable,
@@ -33,6 +36,9 @@
     "Diagnostics",
     "ErrorCause",
     "ErrorCauseType",
+    "LoadResult",
+    "LoadResultStatus",
+    "Result",
     "SimulationState",
     "Statevector",
     "Variable",

python/mqt/debugger/check/run_preparation.py

@@ -42,22 +42,32 @@ def start_compilation(code: Path, output_dir: Path) -> None:
         output_dir (Path): The directory to store the compiled slices.
     """
     state = dbg.create_ddsim_simulation_state()
-    with code.open("r", encoding="utf-8") as f:
-        code_str = f.read()
-    state.load_code(code_str)
-    i = 0
-    while True:
-        i += 1
-        settings = dbg.CompilationSettings(
-            opt=0,
-            slice_index=i - 1,
-        )
-        compiled = state.compile(settings)
-        if not compiled:
-            break
-        with (output_dir / f"slice_{i}.qasm").open("w") as f:
-            f.write(compiled)
-    dbg.destroy_ddsim_simulation_state(state)
+    try:
+        with code.open("r", encoding="utf-8") as f:
+            code_str = f.read()
+        load_result = state.load_code(code_str)
+        if load_result.status != dbg.LoadResultStatus.OK:
+            message = load_result.message or "Error loading code"
+            raise RuntimeError(message)
+        i = 0
+        compiled_any = False
+        while True:
+            i += 1
+            settings = dbg.CompilationSettings(
+                opt=0,
+                slice_index=i - 1,
+            )
+            compiled = state.compile(settings)
+            if not compiled:
+                break
+            compiled_any = True
+            with (output_dir / f"slice_{i}.qasm").open("w") as f:
+                f.write(compiled)
+        if not compiled_any:
+            msg = "No compiled slices produced; check input code for validity."
+            raise RuntimeError(msg)
+    finally:
+        dbg.destroy_ddsim_simulation_state(state)
 
 
 # -------------------------