✨ Add Dead Gate Elimination Pattern

CHANGELOG.md

@@ -42,9 +42,9 @@ releases may include breaking changes.
   [#1513], [#1521], [#1542], [#1548], [#1550], [#1554], [#1567], [#1569],
   [#1570], [#1572], [#1573], [#1580], [#1602], [#1620], [#1623], [#1624],
   [#1626], [#1627], [#1635], [#1638], [#1673], [#1675], [#1700], [#1710],
-  [#1717], [#1728], [#1730], [#1749], [#1751], [#1762], [#1765], [#1780],
-  [#1781], [#1782], [#1787], [#1806], [#1807], [#1808], [#1823], [#1824],
-  [#1830], [#1869], [#1872]) ([**@burgholzer**], [**@denialhaag**],
+  [#1717], [#1728], [#1730], [#1749], [#1751], [#1755], [#1762], [#1765],
+  [#1780], [#1781], [#1782], [#1787], [#1806], [#1807], [#1808], [#1823],
+  [#1824], [#1830], [#1869], [#1872]) ([**@burgholzer**], [**@denialhaag**],
   [**@taminob**], [**@DRovara**], [**@li-mingbao**], [**@Ectras**],
   [**@MatthiasReumann**], [**@simon1hofmann**])
 
@@ -654,6 +654,7 @@ changelogs._
 [#1766]: https://github.com/munich-quantum-toolkit/core/pull/1766
 [#1765]: https://github.com/munich-quantum-toolkit/core/pull/1765
 [#1762]: https://github.com/munich-quantum-toolkit/core/pull/1762
+[#1755]: https://github.com/munich-quantum-toolkit/core/pull/1755
 [#1751]: https://github.com/munich-quantum-toolkit/core/pull/1751
 [#1749]: https://github.com/munich-quantum-toolkit/core/pull/1749
 [#1748]: https://github.com/munich-quantum-toolkit/core/pull/1748

bindings/ir/register_quantum_computation.cpp

@@ -2003,15 +2003,17 @@ This method is equivalent to calling :meth:`measure` multiple times.
     qubits: The qubits to measure
     cbits: The classical bits to store the results)pb");
   qc.def("measure_all", &qc::QuantumComputation::measureAll, nb::kw_only(),
-         "add_bits"_a = true,
+         "add_bits"_a = true, "add_barrier"_a = true,
          R"pb(Measure all qubits and store the results in classical bits.
 
 Details:
     If `add_bits` is `True`, a new classical register (named "`meas`") with the same size as the number of qubits will be added to the circuit and the results will be stored in it.
     If `add_bits` is `False`, the classical register must already exist and have a sufficient number of bits to store the results.
+    If `add_barrier` is `True`, a barrier is added before the measurements.
 
 Args:
-    add_bits: Whether to explicitly add a classical register)pb");
+    add_bits: Whether to explicitly add a classical register
+    add_barrier: Whether to add a barrier before the measurements)pb");
 
   qc.def("reset", nb::overload_cast<qc::Qubit>(&qc::QuantumComputation::reset),
          "q"_a, R"pb(Add a reset operation to the circuit.

include/mqt-core/ir/QuantumComputation.hpp

@@ -322,11 +322,12 @@ class QuantumComputation {
   /**
    * @brief Add measurements to all qubits
    * @param addBits Whether to add new classical bits to the circuit
+   * @param addBarrier Whether to add a barrier before the measurements
    * @details This function adds measurements to all qubits in the circuit and
    * appends a new classical register (named "meas") to the circuit if addBits
    * is true. Otherwise, qubit q is measured into classical bit q.
    */
-  void measureAll(bool addBits = true);
+  void measureAll(bool addBits = true, bool addBarrier = true);
 
   void bridge(const Targets& targets);
 

include/mqt-core/qasm3/Parser.hpp

@@ -114,7 +114,7 @@ class Parser final {
 
   std::shared_ptr<BarrierStatement> parseBarrierStatement();
 
-  std::shared_ptr<Statement> parseDeclaration(bool isConst);
+  std::shared_ptr<Statement> parseDeclaration(bool isConst, bool isOutput);
 
   std::shared_ptr<GateDeclaration> parseGateDefinition();
 

include/mqt-core/qasm3/Statement.hpp

@@ -347,15 +347,18 @@ class DeclarationStatement final
       public std::enable_shared_from_this<DeclarationStatement> {
 public:
   bool isConst;
+  bool isOutput;
   std::variant<std::shared_ptr<TypeExpr>, std::shared_ptr<ResolvedType>> type;
   std::string identifier;
   std::shared_ptr<DeclarationExpression> expression;
 
   DeclarationStatement(std::shared_ptr<DebugInfo> debug, const bool declIsConst,
-                       std::shared_ptr<TypeExpr> ty, std::string id,
+                       bool declIsOutput, std::shared_ptr<TypeExpr> ty,
+                       std::string id,
                        std::shared_ptr<DeclarationExpression> expr)
-      : Statement(std::move(debug)), isConst(declIsConst), type(ty),
-        identifier(std::move(id)), expression(std::move(expr)) {}
+      : Statement(std::move(debug)), isConst(declIsConst),
+        isOutput(declIsOutput), type(ty), identifier(std::move(id)),
+        expression(std::move(expr)) {}
 
   void accept(InstVisitor* visitor) override;
 };

mlir/include/mlir/Conversion/QCToQIR/QIRCommon/QIRCommon.h

@@ -67,6 +67,15 @@ struct LoweringState {
   Block* measurementsBlock{};
   Block* outputBlock{};
 
+  /// Set of MeasureOps whose results should be recorded in the output.
+  DenseSet<Operation*> returnedMeasurements;
+
+  /// Set of array register names that should be recorded in the output.
+  DenseSet<StringRef> recordedArrays;
+
+  /// Set of unnamed result indices that should be recorded in the output.
+  DenseSet<int64_t> recordedIndices;
+
   /// The qubit allocation mode used in the module
   AllocationMode allocationMode = AllocationMode::Unset;
 
@@ -152,4 +161,28 @@ void populateQCToQIRPatterns(RewritePatternSet& patterns,
 void addOutputRecording(LLVM::LLVMFuncOp& main, MLIRContext* ctx,
                         LoweringState& state);
 
+/**
+ * @brief Strips returned measurement results from function return statements
+ *
+ * @details
+ * Walks all `func::ReturnOp` operations in the module to identify operands
+ * that are directly defined by a `qc::MeasureOp`. For each such operand:
+ * - The defining `MeasureOp` is added to `state.returnedMeasurements` so that
+ *   it will be included in the QIR output recording.
+ * - The operand is removed from the return statement.
+ *
+ * Non-measurement return values are preserved. After stripping, the enclosing
+ * `func::FuncOp` function type is updated to match the new return operands.
+ *
+ * This must be called **before** func-to-LLVM conversion, while
+ * `func::ReturnOp` and `qc::MeasureOp` are still in the IR.
+ *
+ * Return values that are indirectly computed from measurement outcomes remain
+ * unaffected.
+ *
+ * @param moduleOp The top-level module operation to walk
+ * @param state The lowering state; `returnedMeasurements` is populated
+ */
+void stripReturnedMeasurements(Operation* moduleOp, LoweringState& state);
+
 } // namespace mlir

mlir/include/mlir/Dialect/QC/Builder/QCProgramBuilder.h

@@ -70,14 +70,32 @@ class QCProgramBuilder final : public ImplicitLocOpBuilder {
   //===--------------------------------------------------------------------===//
 
   /**
-   * @brief Initialize the builder and prepare for program construction
+   * @brief Initialize the builder and prepare for program construction, with
+   * a default return type of i64.
    *
    * @details
    * Creates a main function with an entry_point attribute. Must be called
    * before adding operations.
    */
   void initialize();
 
+  /**
+   * @brief Initialize the builder and prepare for program construction
+   * with specified return types.
+   * @param returnTypes The return types for the main function
+   *
+   * @details
+   * Creates a main function with an entry_point attribute. Must be called
+   * before adding operations.
+   */
+  void initialize(TypeRange returnTypes);
+
+  /**
+   * @brief Modify the return types of the main function after initialization.
+   * @param returnTypes The new return types for the main function
+   */
+  void retype(TypeRange returnTypes);
+
   //===--------------------------------------------------------------------===//
   // Constants
   //===--------------------------------------------------------------------===//
@@ -1145,17 +1163,38 @@ class QCProgramBuilder final : public ImplicitLocOpBuilder {
   OwningOpRef<ModuleOp> finalize();
 
   /**
-   * @brief Convenience method for building quantum programs
+   * @brief Finalize the program with a given exit code and return the
+   * constructed module
+   * @param returnValues Values representing the exit code to return
+   *
+   * @details
+   * Automatically deallocates all remaining valid qubits and tensors of qubits,
+   * adds a return statement with a given exit code,
+   * and transfers ownership of the module to the caller. The builder should not
+   * be used after calling this method.
+   *
+   * The return values must have the types indicated by the function signature
+   * of the main function, which returns an `i64` by default and can be
+   * modified by passing different arguments to the `initialize()` method.
+   *
+   * @return OwningOpRef containing the constructed quantum program module
+   */
+  OwningOpRef<ModuleOp> finalize(ValueRange returnValues);
+
+  /**
+   * @brief Convenience method for building quantum programs.
    * @param context The MLIR context to use for building the program
    * @param buildFunc A function that takes a reference to a QCProgramBuilder
    * and uses it to build the desired quantum program. The builder will be
    * properly initialized before calling this function, and the resulting module
-   * will be finalized and returned after this function completes.
+   * will be finalized using the returned ValueRange after this function
+   * completes.
    * @return The module containing the quantum program built by buildFunc.
    */
   static OwningOpRef<ModuleOp>
   build(MLIRContext* context,
-        const function_ref<void(QCProgramBuilder&)>& buildFunc);
+        const function_ref<std::pair<SmallVector<Value>, SmallVector<Type>>(
+            QCProgramBuilder&)>& buildFunc);
 
 private:
   enum class AllocationMode : uint8_t { Unset, Static, Dynamic };

mlir/include/mlir/Dialect/QCO/Builder/QCOProgramBuilder.h

@@ -78,14 +78,32 @@ class QCOProgramBuilder final : public ImplicitLocOpBuilder {
   //===--------------------------------------------------------------------===//
 
   /**
-   * @brief Initialize the builder and prepare for program construction
+   * @brief Initialize the builder and prepare for program construction, with
+   * a default return type of i64.
    *
    * @details
    * Creates a main function with an entry_point attribute. Must be called
    * before adding operations.
    */
   void initialize();
 
+  /**
+   * @brief Initialize the builder and prepare for program construction
+   * with specified return types.
+   * @param returnTypes The return types for the main function
+   *
+   * @details
+   * Creates a main function with an entry_point attribute. Must be called
+   * before adding operations.
+   */
+  void initialize(TypeRange returnTypes);
+
+  /**
+   * @brief Modify the return types of the main function after initialization.
+   * @param returnTypes The new return types for the main function
+   */
+  void retype(TypeRange returnTypes);
+
   //===--------------------------------------------------------------------===//
   // Constants
   //===--------------------------------------------------------------------===//
@@ -387,7 +405,7 @@ class QCOProgramBuilder final : public ImplicitLocOpBuilder {
    *
    * @param qubit Input qubit (must be valid/unconsumed)
    * @param bit The classical bit to record the result
-   * @return Output qubit value
+   * @return Pair of (output_qubit, measurement_result)
    *
    * @par Example:
    * ```c++
@@ -397,7 +415,7 @@ class QCOProgramBuilder final : public ImplicitLocOpBuilder {
    * %q0_out, %r0 = qco.measure("c", 3, 0) %q0 : !qco.qubit
    * ```
    */
-  Value measure(Value qubit, const Bit& bit);
+  std::pair<Value, Value> measure(Value qubit, const Bit& bit);
 
   /**
    * @brief Reset a qubit to |0⟩ state
@@ -1453,17 +1471,39 @@ class QCOProgramBuilder final : public ImplicitLocOpBuilder {
   OwningOpRef<ModuleOp> finalize();
 
   /**
-   * @brief Convenience method for building quantum programs
+   * @brief Finalize the program with a given exit code and return the
+   * constructed module
+   * @param returnValues Values representing the exit code to return
+   *
+   * @details
+   * Automatically deallocates all remaining valid qubits and tensors of qubits,
+   * adds a return statement with a given exit code,
+   * and transfers ownership of the module to the caller. The builder should not
+   * be used after calling this method.
+   *
+   * The return values must have the types indicated by the function signature
+   * of the main function, which returns an `i64` by default and can be
+   * modified by passing different arguments to the `initialize()` method.
+   *
+   * @return OwningOpRef containing the constructed quantum program module
+   */
+  OwningOpRef<ModuleOp> finalize(ValueRange returnValues);
+
+  /**
+   * @brief Convenience method for building quantum programs.
    * @param context The MLIR context to use for building the program
+   * @param returnTypes The types of the values to be returned by the program.
    * @param buildFunc A function that takes a reference to a QCOProgramBuilder
    * and uses it to build the desired quantum program. The builder will be
    * properly initialized before calling this function, and the resulting module
-   * will be finalized and returned after this function completes.
+   * will be finalized using the returned ValueRange after this function
+   * completes.
    * @return The module containing the quantum program built by buildFunc.
    */
   static OwningOpRef<ModuleOp>
   build(MLIRContext* context,
-        const function_ref<void(QCOProgramBuilder&)>& buildFunc);
+        const function_ref<std::pair<SmallVector<Value>, SmallVector<Type>>(
+            QCOProgramBuilder&)>& buildFunc);
 
 private:
   enum class AllocationMode : uint8_t { Unset, Static, Dynamic };