✨ Update QubitType handling in QCO and QC dialects to support static allocation, modifying builders and operations accordingly.

Author: simon1hofmann

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

@@ -65,12 +65,12 @@ def AllocOp : QCOp<"alloc", [MemoryEffects<[MemAlloc]>]> {
 
     let builders = [
         OpBuilder<(ins), [{
-            build($_builder, $_state, QubitType::get($_builder.getContext()), nullptr, nullptr, nullptr);
+            build($_builder, $_state, QubitType::get($_builder.getContext(), /*isStatic=*/false), nullptr, nullptr, nullptr);
         }]>,
         OpBuilder<(ins "::mlir::StringAttr":$register_name,
                        "::mlir::IntegerAttr":$register_size,
                        "::mlir::IntegerAttr":$register_index), [{
-            build($_builder, $_state, QubitType::get($_builder.getContext()),
+            build($_builder, $_state, QubitType::get($_builder.getContext(), /*isStatic=*/false),
                   register_name, register_size, register_index);
         }]>
     ];

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

@@ -25,7 +25,18 @@ def QubitType : QCType<"Qubit", "qubit"> {
         QC dialect. Operations using this type modify qubits in place using
         reference semantics, similar to how classical imperative languages handle
         mutable references.
+
+        `!qc.qubit` (default) denotes a dynamically allocated qubit.
+        `!qc.qubit<static>` denotes a qubit that has been mapped to a fixed
+        hardware position.
     }];
+    let parameters = (ins DefaultValuedParameter<"bool", "false">:$isStatic);
+    let builders = [
+        TypeBuilder<(ins), [{
+            return $_get($_ctxt, /*isStatic=*/false);
+        }]>
+    ];
+    let hasCustomAssemblyFormat = 1;
 }
 
 #endif // MLIR_DIALECT_QC_IR_QCTYPES_TD

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

@@ -65,12 +65,12 @@ def AllocOp : QCOOp<"alloc", [MemoryEffects<[MemAlloc]>]> {
 
     let builders = [
         OpBuilder<(ins), [{
-            build($_builder, $_state, QubitType::get($_builder.getContext()), nullptr, nullptr, nullptr);
+            build($_builder, $_state, QubitType::get($_builder.getContext(), /*isStatic=*/false), nullptr, nullptr, nullptr);
         }]>,
         OpBuilder<(ins "::mlir::StringAttr":$register_name,
                        "::mlir::IntegerAttr":$register_size,
                        "::mlir::IntegerAttr":$register_index), [{
-            build($_builder, $_state, QubitType::get($_builder.getContext()),
+            build($_builder, $_state, QubitType::get($_builder.getContext(), /*isStatic=*/false),
                   register_name, register_size, register_index);
         }]>
     ];

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

@@ -26,13 +26,24 @@ def QubitType : QCOType<"Qubit", "qubit"> {
         and produce new output qubits following value semantics and the SSA
         paradigm, enabling powerful dataflow analysis and optimization.
 
+        `!qco.qubit` (default) denotes a dynamically allocated qubit.
+        `!qco.qubit<static>` denotes a qubit that has been mapped to a fixed
+        hardware position.
+
         Example:
         ```mlir
         %q0 = qco.alloc : !qco.qubit
         %q1 = qco.h %q0 : !qco.qubit -> !qco.qubit
         %q2 = qco.x %q1 : !qco.qubit -> !qco.qubit
         ```
     }];
+    let parameters = (ins DefaultValuedParameter<"bool", "false">:$isStatic);
+    let builders = [
+        TypeBuilder<(ins), [{
+            return $_get($_ctxt, /*isStatic=*/false);
+        }]>
+    ];
+    let hasCustomAssemblyFormat = 1;
 }
 
 #endif // MLIR_DIALECT_QCO_IR_QCOTYPES_TD

mlir/lib/Conversion/JeffToQCO/JeffToQCO.cpp

@@ -902,7 +902,7 @@ class JeffToQCOTypeConverter final : public TypeConverter {
     addConversion([](Type type) { return type; });
 
     addConversion([ctx](jeff::QubitType /*type*/) -> Type {
-      return qco::QubitType::get(ctx);
+      return qco::QubitType::get(ctx, /*isStatic=*/false);
     });
   }
 };

mlir/lib/Dialect/QCO/IR/Modifiers/CtrlOp.cpp

@@ -126,8 +126,8 @@ struct ReduceCtrl final : OpRewritePattern<CtrlOp> {
     op->setAttr(opResultSegmentsAttrName, newSegments);
 
     // Add a block argument for the target qubit
-    auto arg = op.getBody()->addArgument(QubitType::get(rewriter.getContext()),
-                                         op.getLoc());
+    auto arg = op.getBody()->addArgument(
+        QubitType::get(rewriter.getContext(), /*isStatic=*/false), op.getLoc());
 
     // Replace the current GPhaseOp with a PhaseOp
     const OpBuilder::InsertionGuard guard(rewriter);

mlir/lib/Dialect/QCO/IR/QCOOps.cpp

@@ -71,7 +71,8 @@ parseTargetAliasing(OpAsmParser& parser, Region& region,
       // Hard-code QubitType since targets in qco.ctrl are always qubits.
       // This avoids double-binding type($targets_in) in the assembly format
       // while keeping the parser simple and the assembly format clean.
-      newArg.type = QubitType::get(parser.getBuilder().getContext());
+      newArg.type =
+          QubitType::get(parser.getBuilder().getContext(), /*isStatic=*/false);
       blockArgs.push_back(newArg);
 
     } while (succeeded(parser.parseOptionalComma()));

mlir/lib/Dialect/QTensor/IR/Operations/AllocOp.cpp

@@ -31,9 +31,9 @@ void AllocOp::build(OpBuilder& builder, OperationState& result, Value size) {
     assert(*sizeValue > 0 && "qtensor.alloc size must be positive");
   }
 
-  auto resultType =
-      RankedTensorType::get({sizeValue ? *sizeValue : ShapedType::kDynamic},
-                            qco::QubitType::get(builder.getContext()));
+  auto resultType = RankedTensorType::get(
+      {sizeValue ? *sizeValue : ShapedType::kDynamic},
+      qco::QubitType::get(builder.getContext(), /*isStatic=*/false));
   build(builder, result, resultType, size);
 }