🔄 Rename dealloc to sink in QCO dialect for qubit management

Author: simon1hofmann

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

@@ -1228,24 +1228,24 @@ class QCOProgramBuilder final : public ImplicitLocOpBuilder {
   //===--------------------------------------------------------------------===//
 
   /**
-   * @brief Explicitly deallocate a qubit
+   * @brief Consume a qubit value (end of lifetime)
    *
    * @details
    * Validates and removes the qubit from tracking. Optional; `finalize()`
-   * automatically deallocates all remaining qubits.
+   * automatically sinks all remaining qubits.
    *
-   * @param qubit Qubit to deallocate (must be valid/unconsumed)
+   * @param qubit Qubit to sink (must be valid/unconsumed)
    * @return Reference to this builder for method chaining
    *
    * @par Example:
    * ```c++
-   * builder.dealloc(q);
+   * builder.sink(q);
    * ```
    * ```mlir
-   * qco.dealloc %q : !qco.qubit
+   * qco.sink %q : !qco.qubit
    * ```
    */
-  QCOProgramBuilder& dealloc(Value qubit);
+  QCOProgramBuilder& sink(Value qubit);
 
   //===--------------------------------------------------------------------===//
   // SCF operations

mlir/include/mlir/Dialect/QCO/IR/QCOOps.td

@@ -93,19 +93,20 @@ def AllocOp : QCOOp<"alloc", [MemoryEffects<[MemAlloc]>]> {
   let hasVerifier = 1;
 }
 
-def DeallocOp : QCOOp<"dealloc", [MemoryEffects<[MemFree]>]> {
-  let summary = "Deallocate a qubit";
+def SinkOp : QCOOp<"sink", [MemoryEffects<[MemFree]>]> {
+  let summary = "Consume a qubit value (end of lifetime)";
   let description = [{
-        Deallocates a qubit.
+        Consumes a qubit SSA value and marks the end of its lifetime.
 
-        In QCO's value/linear semantics, this operation also serves as the sink
-        that consumes the qubit SSA value (ensuring every qubit value is used
-        exactly once). When converting back to QC (reference semantics), deallocs
-        corresponding to static qubits may be erased.
+        This operation is the canonical "sink" for QCO's linear/value semantics:
+        every qubit value must be consumed exactly once on all paths.
+
+        When converting back to QC (reference semantics), sinks corresponding to
+        static qubits may be erased.
 
         Example:
         ```mlir
-        qco.dealloc %q : !qco.qubit
+        qco.sink %q : !qco.qubit
         ```
     }];
 

mlir/include/mlir/Dialect/QCO/Utils/Drivers.h

@@ -107,8 +107,8 @@ template <typename Fn> void walkUnit(Region& region, Fn&& fn) {
         .template Case<MeasureOp>([&](MeasureOp op) {
           qubits.remap(op.getQubitIn(), op.getQubitOut());
         })
-        .template Case<DeallocOp>(
-            [&](DeallocOp op) { qubits.remove(op.getQubit()); });
+        .template Case<SinkOp>(
+            [&](SinkOp op) { qubits.remove(op.getQubit()); });
   }
 }
 } // namespace mlir::qco

mlir/lib/Conversion/JeffToQCO/JeffToQCO.cpp

@@ -406,7 +406,7 @@ struct ConvertJeffQubitAllocOpToQCO final
 };
 
 /**
- * @brief Converts jeff.qubit_free to qco.reset + qco.dealloc
+ * @brief Converts jeff.qubit_free to qco.reset + qco.sink
  *
  * @par Example:
  * ```mlir
@@ -415,7 +415,7 @@ struct ConvertJeffQubitAllocOpToQCO final
  * is converted to
  * ```mlir
  * %q_out = qco.reset %q_in : !qco.qubit
- * qco.dealloc %q_out : !qco.qubit
+ * qco.sink %q_out : !qco.qubit
  * ```
  */
 struct ConvertJeffQubitFreeOpToQCO final
@@ -427,21 +427,21 @@ struct ConvertJeffQubitFreeOpToQCO final
                   ConversionPatternRewriter& rewriter) const override {
     auto resetOp =
         qco::ResetOp::create(rewriter, op.getLoc(), adaptor.getInQubit());
-    rewriter.replaceOpWithNewOp<qco::DeallocOp>(op, resetOp.getQubitOut());
+    rewriter.replaceOpWithNewOp<qco::SinkOp>(op, resetOp.getQubitOut());
     return success();
   }
 };
 
 /**
- * @brief Converts jeff.qubit_free_zero to qco.dealloc
+ * @brief Converts jeff.qubit_free_zero to qco.sink
  *
  * @par Example:
  * ```mlir
  * jeff.qubit_free_zero %q : !jeff.qubit
  * ```
  * is converted to
  * ```mlir
- * qco.dealloc %q : !qco.qubit
+ * qco.sink %q : !qco.qubit
  * ```
  */
 struct ConvertJeffQubitFreeZeroOpToQCO final
@@ -451,13 +451,13 @@ struct ConvertJeffQubitFreeZeroOpToQCO final
   LogicalResult
   matchAndRewrite(jeff::QubitFreeZeroOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter& rewriter) const override {
-    rewriter.replaceOpWithNewOp<qco::DeallocOp>(op, adaptor.getInQubit());
+    rewriter.replaceOpWithNewOp<qco::SinkOp>(op, adaptor.getInQubit());
     return success();
   }
 };
 
 /**
- * @brief Converts jeff.qubit_measure to qco.measure + qco.dealloc
+ * @brief Converts jeff.qubit_measure to qco.measure + qco.sink
  *
  * @par Example:
  * ```mlir
@@ -466,7 +466,7 @@ struct ConvertJeffQubitFreeZeroOpToQCO final
  * is converted to
  * ```mlir
  * %q_out, %result = qco.measure %q_in : !qco.qubit
- * qco.dealloc %q_out : !qco.qubit
+ * qco.sink %q_out : !qco.qubit
  * ```
  */
 struct ConvertJeffQubitMeasureOpToQCO final
@@ -479,7 +479,7 @@ struct ConvertJeffQubitMeasureOpToQCO final
     auto loc = op.getLoc();
     auto measureOp =
         qco::MeasureOp::create(rewriter, loc, adaptor.getInQubit());
-    qco::DeallocOp::create(rewriter, loc, measureOp.getQubitOut());
+    qco::SinkOp::create(rewriter, loc, measureOp.getQubitOut());
     rewriter.replaceOp(op, measureOp.getResult());
     return success();
   }

mlir/lib/Conversion/QCOToJeff/QCOToJeff.cpp

@@ -269,23 +269,22 @@ struct ConvertQCOAllocOpToJeff final
 };
 
 /**
- * @brief Converts qco.dealloc to jeff.qubit_free_zero
+ * @brief Converts qco.sink to jeff.qubit_free_zero
  *
  * @par Example:
  * ```mlir
- * qco.dealloc %q : !qco.qubit
+ * qco.sink %q : !qco.qubit
  * ```
  * is converted to
  * ```mlir
  * jeff.qubit_free_zero %q : !jeff.qubit
  * ```
  */
-struct ConvertQCODeallocOpToJeff final
-    : StatefulOpConversionPattern<qco::DeallocOp> {
+struct ConvertQCOSinkOpToJeff final : StatefulOpConversionPattern<qco::SinkOp> {
   using StatefulOpConversionPattern::StatefulOpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(qco::DeallocOp op, OpAdaptor adaptor,
+  matchAndRewrite(qco::SinkOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter& rewriter) const override {
     rewriter.replaceOpWithNewOp<jeff::QubitFreeZeroOp>(op, adaptor.getQubit());
     return success();
@@ -1364,7 +1363,7 @@ struct QCOToJeff final : impl::QCOToJeffBase<QCOToJeff> {
     // Register operation conversion patterns
     jeff::populateNativeToJeffConversionPatterns(patterns);
     patterns.add<
-        ConvertQCOAllocOpToJeff, ConvertQCODeallocOpToJeff,
+        ConvertQCOAllocOpToJeff, ConvertQCOSinkOpToJeff,
         ConvertQCOMeasureOpToJeff, ConvertQCOResetOpToJeff,
         ConvertQCOGPhaseOpToJeff,
         ConvertQCOOneTargetZeroParameterToJeff<qco::IdOp, jeff::IOp, false>,

mlir/lib/Conversion/QCOToQC/QCOToQC.cpp

@@ -96,7 +96,7 @@ struct ConvertQCOAllocOp final : OpConversionPattern<qco::AllocOp> {
 };
 
 /**
- * @brief Converts qco.dealloc to qc.dealloc (dynamic) or erases it (static).
+ * @brief Converts qco.sink to qc.dealloc (dynamic) or erases it (static).
  *
  * @details
  * For dynamic qubits (`!qco.qubit`), converts to `qc.dealloc`.
@@ -105,23 +105,23 @@ struct ConvertQCOAllocOp final : OpConversionPattern<qco::AllocOp> {
  *
  * Example transformation (dynamic):
  * ```mlir
- * qco.dealloc %q_qco : !qco.qubit
+ * qco.sink %q_qco : !qco.qubit
  * // becomes:
  * qc.dealloc %q_qc : !qc.qubit
  * ```
  *
  * Example transformation (static):
  * ```mlir
- * qco.dealloc %q_qco : !qco.qubit<static>
+ * qco.sink %q_qco : !qco.qubit<static>
  * // becomes:
  * (erased)
  * ```
  */
-struct ConvertQCODeallocOp final : OpConversionPattern<qco::DeallocOp> {
+struct ConvertQCOSinkOp final : OpConversionPattern<qco::SinkOp> {
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(qco::DeallocOp op, OpAdaptor adaptor,
+  matchAndRewrite(qco::SinkOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter& rewriter) const override {
     if (op.getQubit().getType().getIsStatic()) {
       rewriter.eraseOp(op);
@@ -769,7 +769,7 @@ struct QCOToQC final : impl::QCOToQCBase<QCOToQC> {
     // Register operation conversion patterns
     // Note: No state tracking needed - OpAdaptors handle type conversion
     patterns.add<
-        ConvertQCOAllocOp, ConvertQCODeallocOp, ConvertQCOStaticOp,
+        ConvertQCOAllocOp, ConvertQCOSinkOp, ConvertQCOStaticOp,
         ConvertQCOMeasureOp, ConvertQCOResetOp,
         ConvertQCOZeroTargetOneParameterToQC<qco::GPhaseOp, qc::GPhaseOp>,
         ConvertQCOOneTargetZeroParameterToQC<qco::XOp, qc::XOp>,

mlir/lib/Conversion/QCToQCO/QCToQCO.cpp

@@ -276,7 +276,7 @@ namespace {
  * QC uses reference semantics and does not enforce linear typing for qubits.
  * After conversion, QCO requires that every qubit SSA value is consumed
  * exactly once. For allocations (including static qubits), the sink is
- * `qco.dealloc`. This pattern inserts `qco.dealloc` operations for all
+ * `qco.sink`. This pattern inserts `qco.sink` operations for all
  * still-live qubits tracked in the lowering state right before the return.
  */
 struct ConvertFuncReturnOp final : StatefulOpConversionPattern<func::ReturnOp> {
@@ -319,7 +319,7 @@ struct ConvertFuncReturnOp final : StatefulOpConversionPattern<func::ReturnOp> {
     llvm::sort(liveQubitsSorted, SSAOrder{});
 
     for (Value qubit : liveQubitsSorted) {
-      qco::DeallocOp::create(rewriter, op.getLoc(), qubit);
+      qco::SinkOp::create(rewriter, op.getLoc(), qubit);
     }
 
     state.qubitMap.erase(funcRegion);
@@ -397,18 +397,18 @@ struct ConvertQCAllocOp final : StatefulOpConversionPattern<qc::AllocOp> {
 };
 
 /**
- * @brief Converts qc.dealloc to qco.dealloc
+ * @brief Converts qc.dealloc to qco.sink
  *
  * @details
  * Deallocates a qubit by looking up its latest QCO value and creating
- * a corresponding qco.dealloc operation. The mapping is removed from
+ * a corresponding qco.sink operation. The mapping is removed from
  * the state as the qubit is no longer in use.
  *
  * Example transformation:
  * ```mlir
  * qc.dealloc %q : !qc.qubit
  * // becomes (where %q maps to %q_final):
- * qco.dealloc %q_final : !qco.qubit
+ * qco.sink %q_final : !qco.qubit
  * ```
  */
 struct ConvertQCDeallocOp final : StatefulOpConversionPattern<qc::DeallocOp> {
@@ -424,8 +424,8 @@ struct ConvertQCDeallocOp final : StatefulOpConversionPattern<qc::DeallocOp> {
     Value qcQubit = op.getQubit();
     Value qcoQubit = lookupMappedQubit(state, operation, qcQubit);
 
-    // Create the dealloc operation
-    rewriter.replaceOpWithNewOp<qco::DeallocOp>(op, qcoQubit);
+    // Create the sink operation
+    rewriter.replaceOpWithNewOp<qco::SinkOp>(op, qcoQubit);
 
     // Remove from state as qubit is no longer in use
     qubitMap.erase(qcQubit);
@@ -1130,7 +1130,7 @@ struct QCToQCO final : impl::QCToQCOBase<QCToQCO> {
     // Conversion of qc types in func.return
     //
     // Note: `func.return` may already be type-legal even though we still need
-    // to insert sink operations (`qco.dealloc`) for remaining live
+    // to insert sink operations (`qco.sink`) for remaining live
     // qubits. Therefore, we make it dynamically illegal unless the lowering
     // state has no remaining qubits.
     patterns.add<ConvertFuncReturnOp>(typeConverter, context, &state);

mlir/lib/Dialect/QCO/Builder/QCOProgramBuilder.cpp

@@ -810,13 +810,13 @@ ValueRange QCOProgramBuilder::inv(
 // Deallocation
 //===----------------------------------------------------------------------===//
 
-QCOProgramBuilder& QCOProgramBuilder::dealloc(Value qubit) {
+QCOProgramBuilder& QCOProgramBuilder::sink(Value qubit) {
   checkFinalized();
 
   validateQubitValue(qubit);
   validQubits.erase(qubit);
 
-  DeallocOp::create(*this, qubit);
+  SinkOp::create(*this, qubit);
 
   return *this;
 }
@@ -924,7 +924,7 @@ OwningOpRef<ModuleOp> QCOProgramBuilder::finalize() {
   llvm::sort(sortedQubits, SSAOrder{});
 
   for (auto qubit : sortedQubits) {
-    DeallocOp::create(*this, qubit);
+    SinkOp::create(*this, qubit);
   }
 
   // Automatically deallocate all still-allocated tensors

…ect/QCO/IR/QubitManagement/DeallocOp.cpp …ialect/QCO/IR/QubitManagement/SinkOp.cppmlir/lib/Dialect/QCO/IR/QubitManagement/DeallocOp.cpp renamed to mlir/lib/Dialect/QCO/IR/QubitManagement/SinkOp.cpp mlir/lib/Dialect/QCO/IR/QubitManagement/DeallocOp.cpp renamed to mlir/lib/Dialect/QCO/IR/QubitManagement/SinkOp.cpp

@@ -12,7 +12,6 @@
 
 #include <llvm/Support/Casting.h>
 #include <mlir/IR/MLIRContext.h>
-#include <mlir/IR/OperationSupport.h>
 #include <mlir/IR/PatternMatch.h>
 #include <mlir/Support/LogicalResult.h>
 
@@ -22,21 +21,19 @@ using namespace mlir::qco;
 namespace {
 
 /**
- * @brief Remove matching allocation and deallocation pairs without operations
+ * @brief Remove matching allocation/static and sink pairs without operations
  * between them.
  */
-struct RemoveAllocDeallocPair final : OpRewritePattern<DeallocOp> {
+struct RemoveAllocSinkPair final : OpRewritePattern<SinkOp> {
   using OpRewritePattern::OpRewritePattern;
 
-  LogicalResult matchAndRewrite(DeallocOp op,
+  LogicalResult matchAndRewrite(SinkOp op,
                                 PatternRewriter& rewriter) const override {
-    // Check if the predecessor is an AllocOp or a StaticOp
     auto* defOp = op.getQubit().getDefiningOp();
     if (!llvm::isa<AllocOp, StaticOp>(defOp)) {
       return failure();
     }
 
-    // Remove the AllocOp/StaticOp and the DeallocOp
     rewriter.eraseOp(op);
     rewriter.eraseOp(defOp);
     return success();
@@ -45,7 +42,7 @@ struct RemoveAllocDeallocPair final : OpRewritePattern<DeallocOp> {
 
 } // namespace
 
-void DeallocOp::getCanonicalizationPatterns(RewritePatternSet& results,
-                                            MLIRContext* context) {
-  results.add<RemoveAllocDeallocPair>(context);
+void SinkOp::getCanonicalizationPatterns(RewritePatternSet& results,
+                                         MLIRContext* context) {
+  results.add<RemoveAllocSinkPair>(context);
 }