Fix linter errors

Author: denialhaag

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

@@ -104,7 +104,7 @@ class QCProgramBuilder final : public ImplicitLocOpBuilder {
     /// The MemRef value representing the qubit register
     Value value;
     /// The allocated qubit values
-    SmallVector<Value> qubits;
+    llvm::SmallVector<Value> qubits;
 
     /**
      * @brief Access a specific qubit in the register

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

@@ -112,7 +112,7 @@ class QCOProgramBuilder final : public ImplicitLocOpBuilder {
     /// The QTensor value representing the qubit register
     Value value;
     /// The allocated qubit values
-    SmallVector<Value> qubits;
+    llvm::SmallVector<Value> qubits;
 
     /**
      * @brief Access a specific qubit in the register
@@ -1155,7 +1155,7 @@ class QCOProgramBuilder final : public ImplicitLocOpBuilder {
    * ```c++
    * {controls_out, targets_out} =
    *   builder.ctrl(q0_in, q1_in,
-   *     [&](ValueRange targets) -> SmallVector<Value> {
+   *     [&](ValueRange targets) ->llvm::SmallVector<Value> {
    *       return {builder.x(targets[0])};
    *   });
    * ```
@@ -1180,7 +1180,7 @@ class QCOProgramBuilder final : public ImplicitLocOpBuilder {
    * @par Example:
    * ```c++
    * qubits_out = builder.inv(q0_in,
-   *   [&](ValueRange qubits) -> SmallVector<Value> {
+   *   [&](ValueRange qubits) ->llvm::SmallVector<Value> {
    *     return {builder.s(qubits[0])};
    *   }
    * );
@@ -1244,7 +1244,7 @@ class QCOProgramBuilder final : public ImplicitLocOpBuilder {
    * ```c++
    * auto result =
    *   builder.qcoIf(condition, q0,
-   *     [&](ValueRange args) -> SmallVector<Value> {
+   *     [&](ValueRange args) ->llvm::SmallVector<Value> {
    *       auto q1 = builder.h(args[0]);
    *       return {q1};
    *     });

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

@@ -88,9 +88,9 @@ LogicalResult walkProgram(Region& region, const WalkProgramFn& fn) {
   return success();
 }
 
-using ReleasedOps = SmallVector<UnitaryOpInterface, 8>;
+using ReleasedOps = llvm::SmallVector<UnitaryOpInterface, 8>;
 using PendingWiresMap =
-    DenseMap<UnitaryOpInterface, SmallVector<std::size_t, 2>>;
+    DenseMap<UnitaryOpInterface, llvm::SmallVector<std::size_t, 2>>;
 
 struct IsReady {
   bool operator()(PendingWiresMap::value_type& kv) const {
@@ -138,18 +138,18 @@ LogicalResult walkProgramGraph(MutableArrayRef<WireIterator> wires,
   PendingWiresMap pending;
   pending.reserve(wires.size());
 
-  SmallVector<std::size_t> curr(wires.size());
+  llvm::SmallVector<std::size_t> curr(wires.size());
   std::iota(curr.begin(), curr.end(), 0UL);
 
-  SmallVector<std::size_t> next;
+  llvm::SmallVector<std::size_t> next;
   next.reserve(wires.size());
 
   while (!curr.empty()) {
     for (std::size_t i : curr) {
       auto& it = wires[i];
       while (Traits::isActive(it)) {
         const auto res =
-            TypeSwitch<Operation*, WalkResult>(it.operation())
+            llvm::TypeSwitch<Operation*, WalkResult>(it.operation())
                 .template Case<UnitaryOpInterface>([&](UnitaryOpInterface& op) {
                   // If there are fewer wires than the qubit requires inputs,
                   // it's impossible to release the operation. Hence, fail.

mlir/lib/Conversion/JeffToQCO/JeffToQCO.cpp

@@ -20,6 +20,7 @@
 #include <jeff/IR/JeffOps.h>
 #include <llvm/ADT/STLExtras.h>
 #include <llvm/ADT/STLFunctionalExtras.h>
+#include <llvm/ADT/SmallVector.h>
 #include <llvm/Support/Casting.h>
 #include <llvm/Support/ErrorHandling.h>
 #include <mlir/Dialect/Arith/IR/Arith.h>

mlir/lib/Conversion/QCOToJeff/QCOToJeff.cpp

@@ -20,6 +20,7 @@
 #include <jeff/IR/JeffOps.h>
 #include <llvm/ADT/STLExtras.h>
 #include <llvm/ADT/SmallVector.h>
+#include <llvm/ADT/StringRef.h>
 #include <llvm/Support/Casting.h>
 #include <mlir/Dialect/Arith/IR/Arith.h>
 #include <mlir/Dialect/Func/IR/FuncOps.h>
@@ -226,7 +227,7 @@ template <typename QCOOpType>
 static void createCustomOp(QCOOpType& op, ConversionPatternRewriter& rewriter,
                            LoweringState& state, ValueRange targets,
                            ValueRange params, const bool isAdjoint,
-                           StringRef name) {
+                           llvm::StringRef name) {
   auto* const it = llvm::find(state.strings, name);
   if (it == state.strings.end()) {
     state.strings.emplace_back(name);

mlir/lib/Conversion/QCToQCO/QCToQCO.cpp

@@ -101,7 +101,7 @@ enum class AllocationMode : std::uint8_t {
 struct LoweringState {
   struct ModifierFrame {
     /// QC qubits yielded from the current modifier region, in yield order.
-    SmallVector<Value> yieldOrder;
+    llvm::SmallVector<Value> yieldOrder;
 
     /// Latest QCO SSA values for QC qubits that are remapped inside the
     /// modifier region.
@@ -123,7 +123,7 @@ struct LoweringState {
   llvm::DenseMap<Region*, llvm::DenseMap<Value, QubitInfo>> qubitInfoMap;
 
   /// Stack of active modifier regions
-  SmallVector<ModifierFrame> modifierFrames;
+  llvm::SmallVector<ModifierFrame> modifierFrames;
 
   /// The qubit allocation mode used in the module
   AllocationMode allocationMode = AllocationMode::Unset;
@@ -279,7 +279,7 @@ static void assignMappedTensor(LoweringState& state, Operation* anchor,
 
 /** @brief Resolves a range of QC qubits to their latest QCO values. */
 template <typename Range>
-[[nodiscard]] static SmallVector<Value>
+[[nodiscard]] static llvm::SmallVector<Value>
 resolveMappedQubits(LoweringState& state, Operation* anchor,
                     const Range& qcQubits) {
   return llvm::to_vector(llvm::map_range(qcQubits, [&](Value qcQubit) {

mlir/lib/Conversion/QCToQIR/QCToQIR.cpp

@@ -16,9 +16,11 @@
 #include "mlir/Dialect/QIR/Utils/QIRMetadata.h"
 #include "mlir/Dialect/QIR/Utils/QIRUtils.h"
 
+#include <llvm/ADT/DenseMap.h>
 #include <llvm/ADT/STLExtras.h>
 #include <llvm/ADT/SmallVector.h>
 #include <llvm/ADT/StringMap.h>
+#include <llvm/ADT/StringRef.h>
 #include <llvm/Support/Allocator.h>
 #include <llvm/Support/Casting.h>
 #include <llvm/Support/ErrorHandling.h>
@@ -76,10 +78,10 @@ enum class AllocationMode : std::uint8_t {
  */
 struct LoweringState : QIRMetadata {
   /// Cache static qubit pointers for reuse
-  DenseMap<int64_t, Value> staticQubits;
+  llvm::DenseMap<int64_t, Value> staticQubits;
 
   /// Cache MemRef sizes for reuse
-  DenseMap<Value, Value> memrefSizes;
+  llvm::DenseMap<Value, Value> memrefSizes;
 
   /// Map from register name to result-array pointer
   llvm::StringMap<Value> resultArrays;
@@ -88,11 +90,11 @@ struct LoweringState : QIRMetadata {
   llvm::DenseMap<std::pair<llvm::StringRef, int64_t>, Value> loadedResults;
 
   /// Map from index to result pointer for non-register results
-  DenseMap<int64_t, Value> resultPtrs;
+  llvm::DenseMap<int64_t, Value> resultPtrs;
 
   /// Modifier information
   int64_t inCtrlOp = 0;
-  DenseMap<int64_t, SmallVector<Value>> controls;
+  llvm::DenseMap<int64_t, llvm::SmallVector<Value>> controls;
 
   /// Allocator and StringSaver for stable StringRefs
   llvm::BumpPtrAllocator allocator;
@@ -168,16 +170,16 @@ template <typename QCOpType, typename QCOpAdaptorType>
 static LogicalResult
 convertUnitaryToCallOp(QCOpType& op, QCOpAdaptorType& adaptor,
                        ConversionPatternRewriter& rewriter, MLIRContext* ctx,
-                       LoweringState& state, StringRef fnName,
+                       LoweringState& state, llvm::StringRef fnName,
                        size_t numTargets, size_t numParams) {
   // Query state for modifier information
   const auto inCtrlOp = state.inCtrlOp;
-  const SmallVector<Value> controls =
-      inCtrlOp != 0 ? state.controls[inCtrlOp] : SmallVector<Value>{};
+  const llvm::SmallVector<Value> controls =
+      inCtrlOp != 0 ? state.controls[inCtrlOp] : llvm::SmallVector<Value>{};
   const size_t numCtrls = controls.size();
 
   // Define argument types
-  SmallVector<Type> argumentTypes;
+  llvm::SmallVector<Type> argumentTypes;
   argumentTypes.reserve(numParams + numCtrls + numTargets);
   const auto ptrType = LLVM::LLVMPointerType::get(ctx);
   const auto floatType = Float64Type::get(ctx);
@@ -202,7 +204,7 @@ convertUnitaryToCallOp(QCOpType& op, QCOpAdaptorType& adaptor,
   const auto fnDecl =
       getOrCreateFunctionDeclaration(rewriter, op, fnName, fnSignature);
 
-  SmallVector<Value> operands;
+  llvm::SmallVector<Value> operands;
   operands.reserve(numParams + numCtrls + numTargets);
   operands.append(controls.begin(), controls.end());
   operands.append(adaptor.getOperands().begin(), adaptor.getOperands().end());
@@ -865,8 +867,8 @@ struct ConvertQCCtrlOp final : StatefulOpConversionPattern<CtrlOp> {
     // Update modifier information
     auto& state = getState();
     state.inCtrlOp++;
-    const SmallVector<Value> controls(adaptor.getControls().begin(),
-                                      adaptor.getControls().end());
+    const llvm::SmallVector<Value> controls(adaptor.getControls().begin(),
+                                            adaptor.getControls().end());
     state.controls[state.inCtrlOp] = controls;
 
     // Inline region and remove operation
@@ -996,12 +998,13 @@ struct QCToQIR final : impl::QCToQIRBase<QCToQIR> {
     // Move operations to appropriate blocks
     for (auto it = bodyBlock->begin(); it != bodyBlock->end();) {
       // Ensure iterator remains valid after potential move
-      if (auto& op = *it++; isa<LLVM::ReturnOp>(op)) {
+      if (auto& op = *it++; llvm::isa<LLVM::ReturnOp>(op)) {
         // Move return to output block
         outputBlockOps.splice(outputBlock->end(), bodyBlockOps,
                               Block::iterator(op));
-      } else if (isa<memref::AllocOp>(op) || isa<memref::LoadOp>(op) ||
-                 isa<AllocOp>(op) || op.hasTrait<OpTrait::ConstantLike>()) {
+      } else if (llvm::isa<memref::AllocOp>(op) ||
+                 llvm::isa<memref::LoadOp>(op) || llvm::isa<AllocOp>(op) ||
+                 op.hasTrait<OpTrait::ConstantLike>()) {
         // Move allocations and constant-like operations to entry block
         entryBlock->getOperations().splice(entryBlock->end(), bodyBlockOps,
                                            Block::iterator(op));

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

@@ -12,6 +12,7 @@
 
 #include <llvm/ADT/STLExtras.h>
 #include <llvm/ADT/STLFunctionalExtras.h>
+#include <llvm/ADT/SmallPtrSet.h>
 #include <llvm/Support/Casting.h>
 #include <llvm/Support/ErrorHandling.h>
 #include <mlir/IR/Builders.h>