✨ Add non-linear control flow conversions between QC and QCO dialects

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

@@ -868,6 +868,208 @@ class QCProgramBuilder final : public OpBuilder {
    */
   QCProgramBuilder& dealloc(Value qubit);
 
+  //===--------------------------------------------------------------------===//
+  // SCF operations
+  //===--------------------------------------------------------------------===//
+
+  /**
+   * @brief Constructs a scf.for operation without iter args
+   *
+   * @param lowerbound Lowerbound of the loop
+   * @param upperbound Upperbound of the loop
+   * @param step Stepsize of the loop
+   * @param body Function that builds the body of the for operation
+   * @return Reference to this builder for method chaining
+   *
+   * @par Example:
+   * ```c++
+   * builder.scfFor(lb, ub, step, [&](auto& b) { b.x(q0); });
+   * ```
+   * ```mlir
+   * scf.for %iv = %lb to %ub step %step {
+   *   qc.x %q0 : !qc.qubit
+   * }
+   * ```
+   */
+  QCProgramBuilder& scfFor(Value lowerbound, Value upperbound, Value step,
+                           const std::function<void(OpBuilder&)>& body);
+
+  /**
+   * @brief Constructs a scf.while operation without return values
+   *
+   * @param beforeBody Function that builds the before body of the while
+   * operation
+   * @param afterBody Function that builds the after body of the while operation
+   * @return Reference to this builder for method chaining
+   *
+   * @par Example:
+   * ```c++
+   * builder.scfWhile([&](auto& b) {
+   * b.h(q0);
+   * auto res = b.measure(q0)
+   * b.condition(res)
+   * }, [&](auto& b) {
+   * b.x(q0);
+   * b.yield()
+   * });
+   * ```
+   * ```mlir
+   * scf.while : () -> () {
+   * qc.h %q0 : !qc.qubit
+   * %res = qc.measure %q0 : !qc.qubit -> i1
+   * scf.condition(%tres)
+   * } do {
+   * qc.x %q0 : !qc.qubit
+   * scf.yield
+   * }
+   * ```
+   */
+  QCProgramBuilder& scfWhile(const std::function<void(OpBuilder&)>& beforeBody,
+                             const std::function<void(OpBuilder&)>& afterBody);
+
+  /**
+   * @brief Constructs a scf.if operation without return values
+   *
+   * @param condition Condition for the if operation
+   * @param thenBody Function that builds the then body of the if
+   * operation
+   * @param elseBody Function that builds the else body of the if operation
+   * @return Reference to this builder for method chaining
+   *
+   * @par Example:
+   * ```c++
+   * builder.scf.if(condition, [&](auto& b) {
+   * b.h(q0);
+   * }, [&](auto& b) {
+   * b.x(q0);
+   * });
+   * ```
+   * ```mlir
+   * scf.if %condition {
+   * qc.h %q0 : !qc.qubit
+   * } else {
+   * qc.x %q0 : !qc.qubit
+   * }
+   * ```
+   */
+  QCProgramBuilder&
+  scfIf(Value condition, const std::function<void(OpBuilder&)>& thenBody,
+        const std::function<void(OpBuilder&)>& elseBody = nullptr);
+
+  /**
+   * @brief Constructs a scf.condition operation without any additional Values
+   *
+   * @param condition Condition for condition operation
+   * @return Reference to this builder for method chaining
+   *
+   * @par Example:
+   * ```c++
+   * builder.condition(condition);
+   * ```
+   * ```mlir
+   * scf.condition(%condition)
+   * ```
+   */
+  QCProgramBuilder& scfCondition(Value condition);
+
+  //===--------------------------------------------------------------------===//
+  // Func operations
+  //===--------------------------------------------------------------------===//
+
+  /**
+   * @brief Constructs a func.return operation without return values
+   *
+   * @return Reference to this builder for method chaining
+   *
+   * @par Example:
+   * ```c++
+   * builder.funcReturn();
+   * ```
+   * ```mlir
+   * func.return
+   * ```
+   */
+  QCProgramBuilder& funcReturn();
+
+  /**
+   * @brief Constructs a func.call operation without return values
+   *
+   * @param name Name of the function that is called
+   * @param operands ValueRange of the used operands
+   *
+   * @par Example:
+   * ```c++
+   * builder.funcCall("test", {q0});
+   * ```
+   * ```mlir
+   * func.call @test(%q0) : (!qco.qubit) -> ()
+   * ```
+   */
+  QCProgramBuilder& funcCall(StringRef name, ValueRange operands);
+
+  /**
+   * @brief Constructs a func.func operation with return values
+   *
+   * @param name Name of the function that is called
+   * @param argTypes TypeRange of the arguments
+   * @param body Body of the function
+   * @return Reference to this builder for method chaining
+   *
+   * @par Example:
+   * ```c++
+   * builder.funcFunc("test", argTypes, [&](OpBuilder& b,
+   * ValueRange args) {
+   *   b.h(args[0]);
+   *   b.funcReturn();
+   * })
+   * ```
+   * ```mlir
+   * func.func @test(%arg0 : !qco.qubit) {
+   *   qc.h %arg0 : !qc.qubit
+   *   func.return
+   * }
+   * ```
+   */
+  QCProgramBuilder&
+  funcFunc(StringRef name, TypeRange argTypes,
+           const std::function<void(OpBuilder&, ValueRange)>& body);
+
+  //===--------------------------------------------------------------------===//
+  // Arith operations
+  //===--------------------------------------------------------------------===//
+
+  /**
+   * @brief Constructs a arith.constant of type Index with a given value
+   *
+   * @param index Value of the constant operation
+   * @return Result of the constant operation
+   *
+   * @par Example:
+   * ```c++
+   * builder.arithConstantIndex(4);
+   * ```
+   * ```mlir
+   * arith.constant 4 : index
+   * ```
+   */
+  Value arithConstantIndex(int index);
+
+  /**
+   * @brief Constructs a arith.constant of type i1 with a given bool value
+   *
+   * @param b Bool value of the constant operation
+   * @return Result of the constant operation
+   *
+   * @par Example:
+   * ```c++
+   * builder.arithConstantBool(true);
+   * ```
+   * ```mlir
+   * arith.constant 1 : i1
+   * ```
+   */
+  Value arithConstantBool(bool b);
+
   //===--------------------------------------------------------------------===//
   // Finalization
   //===--------------------------------------------------------------------===//