🔥 Remove register information from allocation operations (#1623)

## Description

After #1580, it no longer makes sense to store register information in
`qc::AllocOp` and `qco::AllocOp`. This PR thus removes this information.

## Checklist

- [x] The pull request only contains commits that are focused and
relevant to this change.
- [x] ~~I have added appropriate tests that cover the new/changed
functionality.~~
- [x] ~~I have updated the documentation to reflect these changes.~~
- [x] I have added entries to the changelog for any noteworthy
additions, changes, fixes, or removals.
- [x] ~~I have added migration instructions to the upgrade guide (if
needed).~~
- [x] The changes follow the project's style guidelines and introduce no
new warnings.
- [x] The changes are fully tested and pass the CI checks.
- [x] I have reviewed my own code changes.

Author: denialhaag

CHANGELOG.md

@@ -15,7 +15,7 @@ This project adheres to [Semantic Versioning], with the exception that minor rel
 - ✨ Add conversions between Jeff and QCO ([#1479], [#1548], [#1565]) ([**@denialhaag**])
 - ✨ Add a `place-and-route` pass for mapping circuits to architectures with restricted topologies ([#1537], [#1547], [#1568], [#1581], [#1583], [#1588]) ([**@MatthiasReumann**])
 - ✨ Add initial infrastructure for new QC and QCO MLIR dialects
-  ([#1264], [#1330], [#1402], [#1428], [#1430], [#1436], [#1443], [#1446], [#1464], [#1465], [#1470], [#1471], [#1472], [#1474], [#1475], [#1506], [#1510], [#1513], [#1521], [#1542], [#1548], [#1550], [#1554], [#1567], [#1569], [#1570], [#1572], [#1573], [#1580], [#1602])
+  ([#1264], [#1330], [#1402], [#1428], [#1430], [#1436], [#1443], [#1446], [#1464], [#1465], [#1470], [#1471], [#1472], [#1474], [#1475], [#1506], [#1510], [#1513], [#1521], [#1542], [#1548], [#1550], [#1554], [#1567], [#1569], [#1570], [#1572], [#1573], [#1580], [#1602], [#1623])
   ([**@burgholzer**], [**@denialhaag**], [**@taminob**], [**@DRovara**], [**@li-mingbao**], [**@Ectras**], [**@MatthiasReumann**], [**@simon1hofmann**])
 
 ### Changed
@@ -335,6 +335,7 @@ _📚 Refer to the [GitHub Release Notes](https://github.com/munich-quantum-tool
 
 <!-- PR links -->
 
+[#1623]: https://github.com/munich-quantum-toolkit/core/pull/1623
 [#1602]: https://github.com/munich-quantum-toolkit/core/pull/1602
 [#1596]: https://github.com/munich-quantum-toolkit/core/pull/1596
 [#1593]: https://github.com/munich-quantum-toolkit/core/pull/1593

mlir/include/mlir/Dialect/QC/IR/QCOps.td

@@ -33,48 +33,23 @@ class QCOp<string mnemonic, list<Trait> traits = []>
 def AllocOp : QCOp<"alloc", [MemoryEffects<[MemAlloc]>]> {
   let summary = "Allocate a qubit dynamically";
   let description = [{
-        Allocates a new qubit dynamically and returns a reference to it.
-        The qubit is initialized to the |0⟩ state.
+    Allocates a new qubit dynamically and returns a reference to it.
+    The qubit is initialized to the |0⟩ state.
 
-        Optionally, the qubit can be part of a register by specifying:
-        - `register_name`: The name of the register this qubit belongs to
-        - `register_size`: The total size of the register
-        - `register_index`: The index of this qubit within the register
+    Example:
+    ```mlir
+    %q = qc.alloc : !qc.qubit
+    ```
+  }];
 
-        Example (single qubit):
-        ```mlir
-        %q = qc.alloc : !qc.qubit
-        ```
-
-        Example (qubits in a register):
-        ```mlir
-        %q0 = qc.alloc("q", 3, 0) : !qc.qubit
-        %q1 = qc.alloc("q", 3, 1) : !qc.qubit
-        %q2 = qc.alloc("q", 3, 2) : !qc.qubit
-        ```
-    }];
-
-  let arguments = (ins OptionalAttr<StrAttr>:$register_name,
-      OptionalAttr<ConfinedAttr<I64Attr, [IntPositive]>>:$register_size,
-      OptionalAttr<ConfinedAttr<I64Attr, [IntNonNegative]>>:$register_index);
   let results = (outs QubitType:$result);
   let assemblyFormat = [{
-        (`(` $register_name^ `,` $register_size `,` $register_index `)`)?
-        attr-dict `:` type($result)
-    }];
+    attr-dict `:` type($result)
+  }];
 
   let builders = [OpBuilder<(ins), [{
-            build($_builder, $_state, QubitType::get($_builder.getContext()), nullptr, nullptr, nullptr);
-        }]>,
-                  OpBuilder<(ins "::mlir::StringAttr":$register_name,
-                                "::mlir::IntegerAttr":$register_size,
-                                "::mlir::IntegerAttr":$register_index),
-                            [{
-            build($_builder, $_state, QubitType::get($_builder.getContext()),
-                  register_name, register_size, register_index);
+            build($_builder, $_state, QubitType::get($_builder.getContext()));
         }]>];
-
-  let hasVerifier = 1;
 }
 
 def DeallocOp : QCOp<"dealloc", [MemoryEffects<[MemFree]>]> {

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

@@ -33,48 +33,23 @@ class QCOOp<string mnemonic, list<Trait> traits = []>
 def AllocOp : QCOOp<"alloc", [MemoryEffects<[MemAlloc]>]> {
   let summary = "Allocate a qubit dynamically";
   let description = [{
-        Allocates a new qubit dynamically and returns an SSA value representing it.
-        The qubit is initialized to the |0⟩ state.
+    Allocates a new qubit dynamically and returns an SSA value representing it.
+    The qubit is initialized to the |0⟩ state.
 
-        Optionally, the qubit can be part of a register by specifying:
-        - `register_name`: The name of the register this qubit belongs to
-        - `register_size`: The total size of the register
-        - `register_index`: The index of this qubit within the register
+    Example:
+    ```mlir
+    %q = qco.alloc : !qco.qubit
+    ```
+  }];
 
-        Example (single qubit):
-        ```mlir
-        %q = qco.alloc : !qco.qubit
-        ```
-
-        Example (qubits in a register):
-        ```mlir
-        %q0 = qco.alloc("q", 3, 0) : !qco.qubit
-        %q1 = qco.alloc("q", 3, 1) : !qco.qubit
-        %q2 = qco.alloc("q", 3, 2) : !qco.qubit
-        ```
-    }];
-
-  let arguments = (ins OptionalAttr<StrAttr>:$register_name,
-      OptionalAttr<ConfinedAttr<I64Attr, [IntPositive]>>:$register_size,
-      OptionalAttr<ConfinedAttr<I64Attr, [IntNonNegative]>>:$register_index);
   let results = (outs QubitType:$result);
   let assemblyFormat = [{
-        (`(` $register_name^ `,` $register_size `,` $register_index `)`)?
-        attr-dict `:` type($result)
-    }];
+    attr-dict `:` type($result)
+  }];
 
   let builders = [OpBuilder<(ins), [{
-            build($_builder, $_state, QubitType::get($_builder.getContext()), nullptr, nullptr, nullptr);
-        }]>,
-                  OpBuilder<(ins "::mlir::StringAttr":$register_name,
-                                "::mlir::IntegerAttr":$register_size,
-                                "::mlir::IntegerAttr":$register_index),
-                            [{
-            build($_builder, $_state, QubitType::get($_builder.getContext()),
-                  register_name, register_size, register_index);
+            build($_builder, $_state, QubitType::get($_builder.getContext()));
         }]>];
-
-  let hasVerifier = 1;
 }
 
 def SinkOp : QCOOp<"sink", [MemoryEffects<[MemFree]>]> {

mlir/lib/Conversion/QCOToQC/QCOToQC.cpp

@@ -226,19 +226,13 @@ struct ConvertQTensorDeallocOp final : OpConversionPattern<qtensor::DeallocOp> {
 /**
  * @brief Converts qco.alloc to qc.alloc
  *
- * @details
- * Allocates a new qubit initialized to the |0⟩ state. Register metadata
- * (name, size, index) is preserved during conversion.
- *
- * The conversion is straightforward: the QCO allocation produces an SSA
- * value, while the QC allocation produces a reference. MLIR's type
- * conversion system automatically handles the semantic shift.
- *
- * Example transformation:
+ * @par Example:
  * ```mlir
- * %q0 = qco.alloc("q", 3, 0) : !qco.qubit
- * // becomes:
- * %q = qc.alloc("q", 3, 0) : !qc.qubit
+ * %q = qco.alloc : !qco.qubit
+ * ```
+ * is converted to
+ * ```mlir
+ * %q = qc.alloc : !qc.qubit
  * ```
  */
 struct ConvertQCOAllocOp final : StatefulOpConversionPattern<qco::AllocOp> {
@@ -254,10 +248,8 @@ struct ConvertQCOAllocOp final : StatefulOpConversionPattern<qco::AllocOp> {
     assert(qubitMode != QubitAddressingMode::Static &&
            "Static qubits cannot be mixed with dynamic qubits");
 
-    // Create qc.alloc with preserved register metadata
-    rewriter.replaceOpWithNewOp<qc::AllocOp>(op, op.getRegisterNameAttr(),
-                                             op.getRegisterSizeAttr(),
-                                             op.getRegisterIndexAttr());
+    // Create qc.alloc
+    rewriter.replaceOpWithNewOp<qc::AllocOp>(op);
 
     return success();
   }

mlir/lib/Conversion/QCToQCO/QCToQCO.cpp

@@ -552,19 +552,13 @@ struct ConvertMemRefDeallocOp final
 /**
  * @brief Converts qc.alloc to qco.alloc
  *
- * @details
- * Allocates a new qubit and establishes the initial mapping in the state.
- * Both dialects initialize qubits to the |0⟩ state.
- *
- * Register metadata (name, size, index) is preserved during conversion,
- * allowing the QCO representation to maintain register information for
- * debugging and visualization.
- *
- * Example transformation:
+ * @par Example:
  * ```mlir
- * %q = qc.alloc("q", 3, 0) : !qc.qubit
- * // becomes:
- * %q0 = qco.alloc("q", 3, 0) : !qco.qubit
+ * %q = qc.alloc : !qc.qubit
+ * ```
+ * is converted to
+ * ```mlir
+ * %q = qco.alloc : !qco.qubit
  * ```
  */
 struct ConvertQCAllocOp final : StatefulOpConversionPattern<qc::AllocOp> {
@@ -574,19 +568,13 @@ struct ConvertQCAllocOp final : StatefulOpConversionPattern<qc::AllocOp> {
   matchAndRewrite(qc::AllocOp op, OpAdaptor /*adaptor*/,
                   ConversionPatternRewriter& rewriter) const override {
     auto& state = getState();
-    auto* operation = op.getOperation();
     auto qcQubit = op.getResult();
 
-    // Create the qco.alloc operation with preserved register metadata
-    auto qcoOp = rewriter.replaceOpWithNewOp<qco::AllocOp>(
-        op, op.getRegisterNameAttr(), op.getRegisterSizeAttr(),
-        op.getRegisterIndexAttr());
+    // Create the qco.alloc operation
+    auto qcoOp = rewriter.replaceOpWithNewOp<qco::AllocOp>(op);
 
     auto qcoQubit = qcoOp.getResult();
-
-    // Establish initial mapping: this QC qubit reference now corresponds
-    // to this QCO SSA value
-    assignMappedQubit(state, operation, qcQubit, qcoQubit);
+    assignMappedQubit(state, qcoOp, qcQubit, qcoQubit);
 
     return success();
   }