[mlir][NFC] Add a using directive for llvm::SetVector in mlir/Support/LLVM.h

[rriddle]

rebase

[rriddle]

rebase

mlir/include/mlir/Analysis/CallGraph.h

private:
   void addEdge(CallGraphNode *node, Edge::Kind kind);
 
   /// The callable region defines the boundary of the call graph node. This is
   /// the region referenced by 'call' operations. This is at a per-region
   /// boundary as operations may define multiple callable regions.
   Region *callableRegion;
 
   /// A set of out-going edges from this node to other nodes in the graph.
-  llvm::SetVector<Edge, SmallVector<Edge, 4>,
-                  llvm::SmallDenseSet<Edge, 4, EdgeKeyInfo>>
+  SetVector<Edge, SmallVector<Edge, 4>,
       edges;
 
   // Provide access to private methods.
   friend class CallGraph;
 };
 
 //===----------------------------------------------------------------------===//
 // CallGraph

mlir/include/mlir/Analysis/SliceAnalysis.h

 ///
 /// Assuming all local orders match the numbering order:
 /// 1. after getting back to the root getForwardSlice, `forwardSlice` may
 ///    contain:
 ///      {9, 7, 8, 5, 1, 2, 6, 3, 4}
 /// 2. reversing the result of 1. gives:
 ///      {4, 3, 6, 2, 1, 5, 8, 7, 9}
 ///
-void getForwardSlice(Operation *op, llvm::SetVector<Operation *> *forwardSlice,
+void getForwardSlice(Operation *op, SetVector<Operation *> *forwardSlice,
                      TransitiveFilter filter = nullptr /* pass-through*/);
 
 /// Value-rooted version of `getForwardSlice`. Return the union of all forward
 /// slices for the uses of the value `root`.
-void getForwardSlice(Value root, llvm::SetVector<Operation *> *forwardSlice,
+void getForwardSlice(Value root, SetVector<Operation *> *forwardSlice,
                      TransitiveFilter filter = nullptr /* pass-through*/);
 
 /// Fills `backwardSlice` with the computed backward slice (i.e.
 /// all the transitive defs of op), **without** including that operation.
 ///
 /// This additionally takes a TransitiveFilter which acts as a frontier:
 /// when looking at defs transitively, an operation that does not pass the
 /// filter is never propagated through. This allows in particular to carve out

 ///      7               8
 ///      |_______________|
 ///              |
 ///              9
 ///
 /// Assuming all local orders match the numbering order:
 ///    {1, 2, 5, 3, 4, 6}
 ///
-void getBackwardSlice(Operation *op,
-                      llvm::SetVector<Operation *> *backwardSlice,
+void getBackwardSlice(Operation *op, SetVector<Operation *> *backwardSlice,
                       TransitiveFilter filter = nullptr /* pass-through*/);
 
 /// Value-rooted version of `getBackwardSlice`. Return the union of all backward
 /// slices for the op defining or owning the value `root`.
-void getBackwardSlice(Value root, llvm::SetVector<Operation *> *backwardSlice,
+void getBackwardSlice(Value root, SetVector<Operation *> *backwardSlice,
                       TransitiveFilter filter = nullptr /* pass-through*/);
 
 /// Iteratively computes backward slices and forward slices until
-/// a fixed point is reached. Returns an `llvm::SetVector<Operation *>` which
+/// a fixed point is reached. Returns an `SetVector<Operation *>` which
 /// **includes** the original operation.
 ///
 /// This allows building a slice (i.e. multi-root DAG where everything
 /// that is reachable from an Value in forward and backward direction is
 /// contained in the slice).
 /// This is the abstraction we need to materialize all the operations for
 /// supervectorization without worrying about orderings and Value
 /// replacements.

 ///   5. for any {x} |= defs,    uses |= uses(x); because all go through op
 ///   6. for any {x} |= uses, uses(x) |= uses;    because all go through op
 ///
 /// Intuitively, we should be able to recurse like:
 ///   preorder(defs) - op - postorder(uses)
 /// and keep things ordered but this is still hand-wavy and not worth the
 /// trouble for now: punt to a simple worklist-based solution.
 ///
-llvm::SetVector<Operation *>
+SetVector<Operation *>
 getSlice(Operation *op,
          TransitiveFilter backwardFilter = nullptr /* pass-through*/,
          TransitiveFilter forwardFilter = nullptr /* pass-through*/);
 
 /// Multi-root DAG topological sort.
 /// Performs a topological sort of the Operation in the `toSort` SetVector.
 /// Returns a topologically sorted SetVector.
-llvm::SetVector<Operation *>
-topologicalSort(const llvm::SetVector<Operation *> &toSort);
+SetVector<Operation *> topologicalSort(const SetVector<Operation *> &toSort);
 
 } // end namespace mlir
 
 #endif // MLIR_ANALYSIS_SLICEANALYSIS_H_

mlir/include/mlir/IR/SymbolTable.h

public:
   /// Replace all of the uses of the given symbol with `newSymbolName`.
   void replaceAllUsesWith(Operation *symbol, StringRef newSymbolName);
 
 private:
   /// A reference to the symbol table used to construct this map.
   SymbolTableCollection &symbolTable;
 
   /// A map of symbol operations to symbol users.
-  DenseMap<Operation *, llvm::SetVector<Operation *>> symbolToUsers;
+  DenseMap<Operation *, SetVector<Operation *>> symbolToUsers;
 };
 
 //===----------------------------------------------------------------------===//
 // SymbolTable Trait Types
 //===----------------------------------------------------------------------===//
 
 namespace detail {
 LogicalResult verifySymbolTable(Operation *op);
Operation *lookupSymbol(StringRef name) {
     return mlir::SymbolTable::lookupSymbolIn(this->getOperation(), name);
   }
   template <typename T> T lookupSymbol(StringRef name) {
     return dyn_cast_or_null<T>(lookupSymbol(name));
   }
   Operation *lookupSymbol(SymbolRefAttr symbol) {
     return mlir::SymbolTable::lookupSymbolIn(this->getOperation(), symbol);
   }
-  template <typename T>
-  T lookupSymbol(SymbolRefAttr symbol) {
+  template <typename T> T lookupSymbol(SymbolRefAttr symbol) {
     return dyn_cast_or_null<T>(lookupSymbol(symbol));
   }
 };
 
 } // end namespace OpTrait
 
 //===----------------------------------------------------------------------===//
 // Visibility parsing implementation.

mlir/include/mlir/Support/LLVM.h

 
 #ifndef MLIR_SUPPORT_LLVM_H
 #define MLIR_SUPPORT_LLVM_H
 
 // We include these two headers because they cannot be practically forward
 // declared, and are effectively language features.
 #include "llvm/ADT/None.h"
 #include "llvm/Support/Casting.h"
+#include <vector>
 
 // Workaround for clang-5 (PR41549)
 #if defined(__clang_major__)
 #if __clang_major__ <= 5
 #include "llvm/ADT/SmallVector.h"
 #endif
 #endif
 
 // Forward declarations.
 namespace llvm {
 // String types
-template <unsigned N>
-class SmallString;
+template <unsigned N> class SmallString;
 class StringRef;
 class StringLiteral;
 class Twine;
 
 // Containers.
 template <typename T> class ArrayRef;
 namespace detail {
 template <typename KeyT, typename ValueT> struct DenseMapPair;
 } // namespace detail
 template <typename KeyT, typename ValueT, typename KeyInfoT, typename BucketT>
 class DenseMap;
-template <typename T>
-struct DenseMapInfo;
-template <typename ValueT, typename ValueInfoT>
-class DenseSet;
+template <typename T> struct DenseMapInfo;
+template <typename ValueT, typename ValueInfoT> class DenseSet;
 class MallocAllocator;
-template <typename T>
-class MutableArrayRef;
-template <typename T>
-class Optional;
-template <typename... PT>
-class PointerUnion;
-template <typename T, unsigned N>
-class SmallPtrSet;
-template <typename T>
-class SmallPtrSetImpl;
-template <typename T, unsigned N>
-class SmallVector;
-template <typename T>
-class SmallVectorImpl;
-template <typename AllocatorTy>
-class StringSet;
-template <typename T, typename R>
-class StringSwitch;
-template <typename T>
-class TinyPtrVector;
-template <typename T, typename ResultT>
-class TypeSwitch;
+template <typename T> class MutableArrayRef;
+template <typename T> class Optional;
+template <typename... PT> class PointerUnion;
+template <typename T, typename Vector, typename Set> class SetVector;
+template <typename T, unsigned N> class SmallPtrSet;
+template <typename T> class SmallPtrSetImpl;
+template <typename T, unsigned N> class SmallVector;
+template <typename T> class SmallVectorImpl;
+template <typename AllocatorTy> class StringSet;
+template <typename T, typename R> class StringSwitch;
+template <typename T> class TinyPtrVector;
+template <typename T, typename ResultT> class TypeSwitch;
 
 // Other common classes.
 class APInt;
 class APFloat;
-template <typename Fn>
-class function_ref;
-template <typename IteratorT>
-class iterator_range;
+template <typename Fn> class function_ref;
+template <typename IteratorT> class iterator_range;
 class raw_ostream;
 } // end namespace llvm
 
 namespace mlir {
 // Casting operators.
 using llvm::cast;
 using llvm::cast_or_null;
 using llvm::dyn_cast;

 using llvm::ArrayRef;
 using llvm::DenseMapInfo;
 template <typename KeyT, typename ValueT,
           typename KeyInfoT = DenseMapInfo<KeyT>,
           typename BucketT = llvm::detail::DenseMapPair<KeyT, ValueT>>
 using DenseMap = llvm::DenseMap<KeyT, ValueT, KeyInfoT, BucketT>;
 template <typename ValueT, typename ValueInfoT = DenseMapInfo<ValueT>>
 using DenseSet = llvm::DenseSet<ValueT, ValueInfoT>;
+template <typename T, typename Vector = std::vector<T>,
+          typename Set = DenseSet<T>>
+using SetVector = llvm::SetVector<T, Vector, Set>;
 template <typename AllocatorTy = llvm::MallocAllocator>
 using StringSet = llvm::StringSet<AllocatorTy>;
 using llvm::MutableArrayRef;
 using llvm::None;
 using llvm::Optional;
 using llvm::PointerUnion;
 using llvm::SmallPtrSet;
 using llvm::SmallPtrSetImpl;
 using llvm::SmallVector;
 using llvm::SmallVectorImpl;
 template <typename T, typename R = T>
 using StringSwitch = llvm::StringSwitch<T, R>;
 using llvm::TinyPtrVector;
 template <typename T, typename ResultT = void>
 using TypeSwitch = llvm::TypeSwitch<T, ResultT>;
 
 // Other common classes.
 using llvm::APFloat;
 using llvm::APInt;
-template <typename Fn>
-using function_ref = llvm::function_ref<Fn>;
+template <typename Fn> using function_ref = llvm::function_ref<Fn>;
 using llvm::iterator_range;
 using llvm::raw_ostream;
 } // namespace mlir
 
 #endif // MLIR_SUPPORT_LLVM_H

mlir/include/mlir/Target/LLVMIR/ModuleTranslation.h

 
 namespace detail {
 /// For all blocks in the region that were converted to LLVM IR using the given
 /// ModuleTranslation, connect the PHI nodes of the corresponding LLVM IR blocks
 /// to the results of preceding blocks.
 void connectPHINodes(Region &region, const ModuleTranslation &state);
 
 /// Get a topologically sorted list of blocks of the given region.
-llvm::SetVector<Block *> getTopologicallySortedBlocks(Region &region);
+SetVector<Block *> getTopologicallySortedBlocks(Region &region);
 
 /// Create an LLVM IR constant of `llvmType` from the MLIR attribute `attr`.
 /// This currently supports integer, floating point, splat and dense element
 /// attributes and combinations thereof.  In case of error, report it to `loc`
 /// and return nullptr.
 llvm::Constant *getLLVMConstant(llvm::Type *llvmType, Attribute attr,
                                 Location loc,
                                 const ModuleTranslation &moduleTranslation);

mlir/include/mlir/Transforms/RegionUtils.h

 /// Calls `callback` for each use of a value within any of the regions provided
 /// that was defined in one of the ancestors.
 void visitUsedValuesDefinedAbove(MutableArrayRef<Region> regions,
                                  function_ref<void(OpOperand *)> callback);
 
 /// Fill `values` with a list of values defined at the ancestors of the `limit`
 /// region and used within `region` or its descendants.
 void getUsedValuesDefinedAbove(Region &region, Region &limit,
-                               llvm::SetVector<Value> &values);
+                               SetVector<Value> &values);
 
 /// Fill `values` with a list of values used within any of the regions provided
 /// but defined in one of the ancestors.
 void getUsedValuesDefinedAbove(MutableArrayRef<Region> regions,
-                               llvm::SetVector<Value> &values);
+                               SetVector<Value> &values);
 
 /// Run a set of structural simplifications over the given regions. This
 /// includes transformations like unreachable block elimination, dead argument
 /// elimination, as well as some other DCE. This function returns success if any
 /// of the regions were simplified, failure otherwise. The provided rewriter is
 /// used to notify callers of operation and block deletion.
 LogicalResult simplifyRegions(RewriterBase &rewriter,
                               MutableArrayRef<Region> regions);
 
 } // namespace mlir
 
 #endif // MLIR_TRANSFORMS_REGIONUTILS_H_

mlir/lib/Analysis/Liveness.cpp

struct BlockInfoBuilder {
   /// The set of all used values.
   ValueSetT useValues;
 };
 } // namespace
 
 /// Builds the internal liveness block mapping.
 static void buildBlockMapping(Operation *operation,
                               DenseMap<Block *, BlockInfoBuilder> &builders) {
-  llvm::SetVector<Block *> toProcess;
+  SetVector<Block *> toProcess;
 
   operation->walk<WalkOrder::PreOrder>([&](Block *block) {
     BlockInfoBuilder &builder =
         builders.try_emplace(block, block).first->second;
 
     if (builder.updateLiveIn())
       toProcess.insert(block->pred_begin(), block->pred_end());
   });

mlir/lib/Analysis/SliceAnalysis.cpp

 #include "llvm/ADT/SetVector.h"
 
 ///
 /// Implements Analysis functions specific to slicing in Function.
 ///
 
 using namespace mlir;
 
-using llvm::SetVector;
-
 static void getForwardSliceImpl(Operation *op,
                                 SetVector<Operation *> *forwardSlice,
                                 TransitiveFilter filter) {
   if (!op)
     return;
 
   // Evaluate whether we should keep this use.
   // This is useful in particular to implement scoping; i.e. return the

mlir/lib/Conversion/PDLToPDLInterp/PDLToPDLInterp.cpp

private:
   SmallVector<Block *, 8> failureBlockStack;
 
   /// A mapping between values defined in a pattern match, and the corresponding
   /// positional value.
   DenseMap<Value, Position *> valueToPosition;
 
   /// The set of operation values whose whose location will be used for newly
   /// generated operations.
-  llvm::SetVector<Value> locOps;
+  SetVector<Value> locOps;
 };
 } // end anonymous namespace
 
 PatternLowering::PatternLowering(FuncOp matcherFunc, ModuleOp rewriterModule)
     : builder(matcherFunc.getContext()), matcherFunc(matcherFunc),
       rewriterModule(rewriterModule), rewriterSymbolTable(rewriterModule) {}
 
 void PatternLowering::lower(ModuleOp module) {

mlir/lib/Dialect/Async/Transforms/AsyncToAsyncRuntime.cpp

 static std::pair<FuncOp, CoroMachinery>
 outlineExecuteOp(SymbolTable &symbolTable, ExecuteOp execute) {
   ModuleOp module = execute->getParentOfType<ModuleOp>();
 
   MLIRContext *ctx = module.getContext();
   Location loc = execute.getLoc();
 
   // Collect all outlined function inputs.
-  llvm::SetVector<mlir::Value> functionInputs(execute.dependencies().begin(),
-                                              execute.dependencies().end());
+  SetVector<mlir::Value> functionInputs(execute.dependencies().begin(),
   functionInputs.insert(execute.operands().begin(), execute.operands().end());
   getUsedValuesDefinedAbove(execute.body(), functionInputs);
 
   // Collect types for the outlined function inputs and outputs.
   auto typesRange = llvm::map_range(
       functionInputs, [](Value value) { return value.getType(); });
   SmallVector<Type, 4> inputTypes(typesRange.begin(), typesRange.end());
   auto outputTypes = execute.getResultTypes();

mlir/lib/Dialect/GPU/Transforms/KernelOutlining.cpp

 /// querying `existingDependencies` and `availableValues`.
 /// If an operand is not yet available, we recursively check whether it can be
 /// made available by siking its defining op.
 /// Operations that are indentified for sinking are added to `beneficiaryOps` in
 /// the order they should appear in the kernel. Furthermore, `availableValues`
 /// is updated with results that will be available after sinking the identified
 /// ops.
 static bool
-extractBeneficiaryOps(Operation *op,
-                      llvm::SetVector<Value> existingDependencies,
-                      llvm::SetVector<Operation *> &beneficiaryOps,
+extractBeneficiaryOps(Operation *op, SetVector<Value> existingDependencies,
+                      SetVector<Operation *> &beneficiaryOps,
                       llvm::SmallPtrSetImpl<Value> &availableValues) {
   if (beneficiaryOps.count(op))
     return true;
 
   if (!isSinkingBeneficiary(op))
     return false;
 
   for (Value operand : op->getOperands()) {
extractBeneficiaryOps(Operation *op, SetVector<Value> existingDependencies,
   return true;
 }
 
 LogicalResult mlir::sinkOperationsIntoLaunchOp(gpu::LaunchOp launchOp) {
   Region &launchOpBody = launchOp.body();
 
   // Identify uses from values defined outside of the scope of the launch
   // operation.
-  llvm::SetVector<Value> sinkCandidates;
+  SetVector<Value> sinkCandidates;
   getUsedValuesDefinedAbove(launchOpBody, sinkCandidates);
 
-  llvm::SetVector<Operation *> toBeSunk;
+  SetVector<Operation *> toBeSunk;
   llvm::SmallPtrSet<Value, 4> availableValues;
   for (Value operand : sinkCandidates) {
     Operation *operandOp = operand.getDefiningOp();
     if (!operandOp)
       continue;
     extractBeneficiaryOps(operandOp, sinkCandidates, toBeSunk, availableValues);
   }
 
LogicalResult mlir::sinkOperationsIntoLaunchOp(gpu::LaunchOp launchOp) {
   }
   return success();
 }
 
 /// Outline the `gpu.launch` operation body into a kernel function. Replace
 /// `gpu.terminator` operations by `gpu.return` in the generated function.
 static gpu::GPUFuncOp outlineKernelFuncImpl(gpu::LaunchOp launchOp,
                                             StringRef kernelFnName,
-                                            llvm::SetVector<Value> &operands) {
+                                            SetVector<Value> &operands) {
   Location loc = launchOp.getLoc();
   // Create a builder with no insertion point, insertion will happen separately
   // due to symbol table manipulation.
   OpBuilder builder(launchOp.getContext());
   Region &launchOpBody = launchOp.body();
 
   // Identify uses from values defined outside of the scope of the launch
   // operation.
static gpu::GPUFuncOp outlineKernelFuncImpl(gpu::LaunchOp launchOp,
   return outlinedFunc;
 }
 
 gpu::GPUFuncOp mlir::outlineKernelFunc(gpu::LaunchOp launchOp,
                                        StringRef kernelFnName,
                                        llvm::SmallVectorImpl<Value> &operands) {
   DenseSet<Value> inputOperandSet;
   inputOperandSet.insert(operands.begin(), operands.end());
-  llvm::SetVector<Value> operandSet(operands.begin(), operands.end());
+  SetVector<Value> operandSet(operands.begin(), operands.end());
   auto funcOp = outlineKernelFuncImpl(launchOp, kernelFnName, operandSet);
   for (auto operand : operandSet) {
     if (!inputOperandSet.count(operand))
       operands.push_back(operand);
   }
   return funcOp;
 }
 

 public:
   void runOnOperation() override {
     SymbolTable symbolTable(getOperation());
     bool modified = false;
     for (auto func : getOperation().getOps<FuncOp>()) {
       // Insert just after the function.
       Block::iterator insertPt(func->getNextNode());
       auto funcWalkResult = func.walk([&](gpu::LaunchOp op) {
-        llvm::SetVector<Value> operands;
+        SetVector<Value> operands;
         std::string kernelFnName =
             Twine(op->getParentOfType<FuncOp>().getName(), "_kernel").str();
 
         // Pull in instructions that can be sunk
         if (failed(sinkOperationsIntoLaunchOp(op)))
           return WalkResult::interrupt();
         gpu::GPUFuncOp outlinedFunc =
             outlineKernelFuncImpl(op, kernelFnName, operands);

mlir/lib/Dialect/LLVMIR/IR/LLVMTypeSyntax.cpp

 static void printStructType(DialectAsmPrinter &printer, LLVMStructType type) {
   // This keeps track of the names of identified structure types that are
   // currently being printed. Since such types can refer themselves, this
   // tracking is necessary to stop the recursion: the current function may be
   // called recursively from DialectAsmPrinter::printType after the appropriate
   // dispatch. We maintain the invariant of this storage being modified
   // exclusively in this function, and at most one name being added per call.
   // TODO: consider having such functionality inside DialectAsmPrinter.
-  thread_local llvm::SetVector<StringRef> knownStructNames;
+  thread_local SetVector<StringRef> knownStructNames;
   unsigned stackSize = knownStructNames.size();
   (void)stackSize;
   auto guard = llvm::make_scope_exit([&]() {
     assert(knownStructNames.size() == stackSize &&
            "malformed identified stack when printing recursive structs");
   });
 
   printer << "<";

 static LLVMStructType parseStructType(DialectAsmParser &parser) {
   // This keeps track of the names of identified structure types that are
   // currently being parsed. Since such types can refer themselves, this
   // tracking is necessary to stop the recursion: the current function may be
   // called recursively from DialectAsmParser::parseType after the appropriate
   // dispatch. We maintain the invariant of this storage being modified
   // exclusively in this function, and at most one name being added per call.
   // TODO: consider having such functionality inside DialectAsmParser.
-  thread_local llvm::SetVector<StringRef> knownStructNames;
+  thread_local SetVector<StringRef> knownStructNames;
   unsigned stackSize = knownStructNames.size();
   (void)stackSize;
   auto guard = llvm::make_scope_exit([&]() {
     assert(knownStructNames.size() == stackSize &&
            "malformed identified stack when parsing recursive structs");
   });
 
   Location loc = parser.getEncodedSourceLoc(parser.getCurrentLocation());

mlir/lib/Dialect/Linalg/Transforms/Hoisting.cpp

func.walk([&](vector::TransferReadOp transferRead) {
       if (failed(moveLoopInvariantCode(
               cast<LoopLikeOpInterface>(loop.getOperation()))))
         llvm_unreachable(
             "Unexpected failure to move invariant code out of loop");
 
       LLVM_DEBUG(DBGS() << "Candidate read: " << *transferRead.getOperation()
                         << "\n");
 
-      llvm::SetVector<Operation *> forwardSlice;
+      SetVector<Operation *> forwardSlice;
       getForwardSlice(transferRead.getOperation(), &forwardSlice);
 
       // Look for the last TransferWriteOp in the forwardSlice of
       // `transferRead` that operates on the same memref.
       vector::TransferWriteOp transferWrite;
       for (auto *sliceOp : llvm::reverse(forwardSlice)) {
         auto candidateWrite = dyn_cast<vector::TransferWriteOp>(sliceOp);
         if (!candidateWrite || candidateWrite.source() != transferRead.source())
void mlir::linalg::hoistRedundantVectorTransfers(FuncOp func) {
   }
 }
 
 /// Return success if `v` is a value that is only transitively defined by ops of
 /// type in `OpTypeList`.
 template <typename... OpTypeList>
 static bool backwardsSliceOnlyHasOpsOfType(scf::ForOp outerLimit, Value v) {
   // Compute a backward slice up to, but not including, `outerLimit`.
-  llvm::SetVector<Operation *> backwardSlice;
+  SetVector<Operation *> backwardSlice;
   getBackwardSlice(v, &backwardSlice, [&](Operation *op) {
     return outerLimit->isProperAncestor(op);
   });
   // Traverse the backward slice and ensure we can perform the computation to
   // hoist.
   for (Operation *op : backwardSlice) {
     if (isa<OpTypeList...>(op))
       continue;
static Value computeLoopIndependentUpperBound(OpBuilder &b, scf::ForOp outer,
 
   bool ok =
       backwardsSliceOnlyHasOpsOfType<scf::ForOp, AffineMinOp, AffineApplyOp>(
           outer, v);
   assert(ok && "expected to only be defined by scf::ForOp and AffineMinOp");
   (void)ok;
 
   // Compute a backward slice up to, but not including, `outer`.
-  llvm::SetVector<Operation *> backwardSlice;
+  SetVector<Operation *> backwardSlice;
   getBackwardSlice(v, &backwardSlice,
                    [&](Operation *op) { return outer->isProperAncestor(op); });
   backwardSlice.insert(v.getDefiningOp());
 
   OpBuilder::InsertionGuard g(b);
   b.setInsertionPoint(outer);
   Value res = v;
   BlockAndValueMapping bvm;

 ///   1. Fill the `backwardSlice` to contain the topologically sorted ops
 ///   dominated by `outermostEnclosingForOp`.
 ///   2. Fill the `packingLoops` to contain only the enclosing loops of
 ///   `backwardSlice` whose IV is actually used in computing padding. Loops that
 ///   remain in `backwardSlice` but that are not in `packingLoops` are
 ///   dimensions of reuse.
 static LogicalResult
 hoistPaddingOnTensorsPrerequisites(linalg::PadTensorOp padTensorOp, int nLevels,
-                                   llvm::SetVector<Operation *> &backwardSlice,
-                                   llvm::SetVector<Operation *> &packingLoops,
+                                   SetVector<Operation *> &backwardSlice,
+                                   SetVector<Operation *> &packingLoops,
                                    SmallVector<Value> &dynamicTensorSizes) {
   // Bail on any use that isn't an input of a Linalg op.
   // Hoisting of inplace updates happens after vectorization.
   for (OpOperand &use : padTensorOp.result().getUses()) {
     auto linalgUser = dyn_cast<linalg::LinalgOp>(use.getOwner());
     if (!linalgUser || !linalgUser.isInputTensor(&use))
       return failure();
   }
hoistPaddingOnTensorsPrerequisites(linalg::PadTensorOp padTensorOp, int nLevels,
   if (!llvm::all_of(dynamicTensorSizes, [](Value v) { return v; }))
     llvm_unreachable("loop independence prerequisite not met");
   return success();
 }
 
 LogicalResult mlir::linalg::hoistPaddingOnTensors(PadTensorOp &padTensorOp,
                                                   unsigned nLoops) {
   SmallVector<Value> dynamicTensorSizes;
-  llvm::SetVector<Operation *> backwardSlice, packingLoops;
+  SetVector<Operation *> backwardSlice, packingLoops;
   if (failed(hoistPaddingOnTensorsPrerequisites(padTensorOp, nLoops,
                                                 backwardSlice, packingLoops,
                                                 dynamicTensorSizes)))
     return failure();
 
   // Update actual number of loops, which may be smaller.
   nLoops = packingLoops.size();
 

mlir/lib/Dialect/Linalg/Transforms/Loops.cpp

return conds.empty() ? readInput
                        : (Value)std_select(conds.back(), padValue, readInput);
 }
 
 namespace {
 
 /// The padding value for a given Op depends on the semantics of the Op.
 /// The identity value for ConvOp and PoolingSumOp is 0, for PoolingMaxOp is
 /// -inf or minInt and for PoolingMinOp is inf or maxInt.
-template <typename OpType>
-Attribute getPadValueAttr(Type type) {
+template <typename OpType> Attribute getPadValueAttr(Type type) {
   llvm_unreachable("Unexpected op type for getPadValueAttr");
   return {};
 }
 
-template <>
-Attribute getPadValueAttr<PoolingMaxOp>(Type type) {
+template <> Attribute getPadValueAttr<PoolingMaxOp>(Type type) {
   auto &b = ScopedContext::getBuilderRef();
   if (auto floatType = type.dyn_cast<FloatType>()) {
     return b.getFloatAttr(
         floatType,
         APFloat::getInf(floatType.getFloatSemantics(), /*Negative*/ true));
   }
   if (auto intType = type.dyn_cast<IntegerType>()) {
     unsigned width = intType.getWidth();
     // The select instruction used to lower the PoolingMin uses a signed
     // comparison, use a signed constant irrespective of the signedness of the
     // integer type.
     return b.getIntegerAttr(intType, APInt::getSignedMinValue(width));
   }
   llvm_unreachable("Unsupported data type for PoolingMaxOp");
   return {};
 }
 
-template <>
-Attribute getPadValueAttr<PoolingMinOp>(Type type) {
+template <> Attribute getPadValueAttr<PoolingMinOp>(Type type) {
   auto &b = ScopedContext::getBuilderRef();
   if (auto floatType = type.dyn_cast<FloatType>()) {
     return b.getFloatAttr(floatType,
                           APFloat::getInf(floatType.getFloatSemantics()));
   }
   if (auto intType = type.dyn_cast<IntegerType>()) {
     unsigned width = intType.getWidth();
     // The select instruction used to lower the PoolingMin uses a signed
     // comparison, use a signed constant irrespective of the signedness of the
     // integer type.
     return b.getIntegerAttr(intType, APInt::getSignedMaxValue(width));
   }
   llvm_unreachable("Unsupported data type for PoolingMinOp");
   return {};
 }
 
-template <>
-Attribute getPadValueAttr<PoolingSumOp>(Type type) {
+template <> Attribute getPadValueAttr<PoolingSumOp>(Type type) {
   auto &b = ScopedContext::getBuilderRef();
   return b.getZeroAttr(type);
 }
 
-template <>
-Attribute getPadValueAttr<ConvOp>(Type type) {
+template <> Attribute getPadValueAttr<ConvOp>(Type type) {
   auto &b = ScopedContext::getBuilderRef();
   return b.getZeroAttr(type);
 }
 
 } // namespace
 
 /// Returns true is `convOp` has a non-zero padding.
 static bool hasPadding(ConvOp convOp) {
Value paddedInput = getPaddedInput<MemRefIndexedValue>(
         {0, static_cast<int>(imIdx.size()) - 1}, padValue);
     O(oIdx) += F(fIdx) * paddedInput;
   } else {
     IndexedValueType I(convOp.input());
     O(oIdx) += F(fIdx) * I(imIdx);
   }
 }
 
-template <typename PoolingOp>
-static bool hasPadding(PoolingOp poolingOp) {
+template <typename PoolingOp> static bool hasPadding(PoolingOp poolingOp) {
   for (unsigned i = 0, e = poolingOp.getNumWindowLoops(); i < e; ++i) {
     if (poolingOp.getLowPad(i) > 0 || poolingOp.getHighPad(i) > 0)
       return true;
   }
   return false;
 }
 
 template <typename IndexedValueType, typename PoolingOp>
GenerateLoopNest<LoopTy>::doit(
                   IndexedGenericOp, LinalgOp>([&](auto op) {
               emitScalarImplementation<IndexedValueTy>(allIvs, op);
             })
             .Default([&](Operation *op) { assert(false && "unexpected op"); });
         return scf::ValueVector{};
       });
   // Number of loop ops might be different from the number of ivs since some
   // loops like affine.parallel and scf.parallel have multiple ivs.
-  llvm::SetVector<Operation *> loopSet;
+  SetVector<Operation *> loopSet;
   for (Value iv : allIvs) {
     if (!iv)
       return {};
     // The induction variable is a block argument of the entry block of the
     // loop operation.
     BlockArgument ivVal = iv.dyn_cast<BlockArgument>();
     if (!ivVal)
       return {};

mlir/lib/Dialect/Linalg/Transforms/Transforms.cpp

static LogicalResult rewriteAsPaddedOp(PatternRewriter &rewriter,
   linalg::LinalgOp paddedOp =
       opToPad.clone(rewriter, loc, resultTensorTypes, newOperands);
 
   // Recover the subtensor out of the new static results. This keeps the
   // original linalg op around because it uses the dims of the original results.
   // This later folds away.
   SmallVector<Value> paddedSubviewResults;
   paddedSubviewResults.reserve(opToPad->getNumResults());
-  llvm::SetVector<Operation *> newUsersOfOpToPad;
+  SetVector<Operation *> newUsersOfOpToPad;
   for (auto it : llvm::zip(opToPad->getResults(), paddedOp->getResults())) {
     auto rank = std::get<0>(it).getType().cast<RankedTensorType>().getRank();
     SmallVector<OpFoldResult> offsets(rank, rewriter.getIndexAttr(0));
     auto sizes = llvm::to_vector<4>(llvm::map_range(
         llvm::seq<unsigned>(0, rank), [&](unsigned d) -> OpFoldResult {
           auto dimOp = rewriter.create<memref::DimOp>(loc, std::get<0>(it), d);
           newUsersOfOpToPad.insert(dimOp);
           return dimOp.getResult();

mlir/lib/Dialect/Linalg/Transforms/Vectorization.cpp

 using namespace mlir::linalg;
 
 using llvm::dbgs;
 
 #define DEBUG_TYPE "linalg-vectorization"
 
 /// Return the unique instance of OpType in `block` if it is indeed unique.
 /// Return null if none or more than 1 instances exist.
-template <typename OpType>
-static OpType getSingleOpOfType(Block &block) {
+template <typename OpType> static OpType getSingleOpOfType(Block &block) {
   OpType res;
   block.walk([&](OpType op) {
     if (res) {
       res = nullptr;
       return WalkResult::interrupt();
     }
     res = op;
     return WalkResult::advance();
LogicalResult vectorizeAsLinalgGeneric(
   // 1. Fail to vectorize if the operation does not have one non-empty region.
   if (linalgOp->getNumRegions() != 1 || linalgOp->getRegion(0).empty())
     return failure();
   auto &block = linalgOp->getRegion(0).front();
 
   BlockAndValueMapping bvm;
   // 2. Values defined above the region can only be broadcast for now. Make them
   // map to themselves.
-  llvm::SetVector<Value> valuesSet;
+  SetVector<Value> valuesSet;
   mlir::getUsedValuesDefinedAbove(linalgOp->getRegion(0), valuesSet);
   bvm.map(valuesSet.getArrayRef(), valuesSet.getArrayRef());
 
   // 3. Turn all BBArgs into vector.transfer_read / load.
   SmallVector<AffineMap> indexings;
   for (auto bbarg : block.getArguments()) {
     Value vectorArg = linalgOp.getShapedOperand(bbarg.getArgNumber());
     AffineMap map;

mlir/lib/Dialect/SCF/Transforms/Utils.cpp

auto outline = [&](Region &ifOrElseRegion, StringRef funcName) {
     assert(!funcName.empty() && "Expected function name for outlining");
     assert(ifOrElseRegion.getBlocks().size() <= 1 &&
            "Expected at most one block");
 
     // Outline before current function.
     OpBuilder::InsertionGuard g(b);
     b.setInsertionPoint(ifOp->getParentOfType<FuncOp>());
 
-    llvm::SetVector<Value> captures;
+    SetVector<Value> captures;
     getUsedValuesDefinedAbove(ifOrElseRegion, captures);
 
     ValueRange values(captures.getArrayRef());
     FunctionType type =
         FunctionType::get(ctx, values.getTypes(), ifOp.getResultTypes());
     auto outlinedFunc = b.create<FuncOp>(loc, funcName, type);
     b.setInsertionPointToStart(outlinedFunc.addEntryBlock());
     BlockAndValueMapping bvm;

mlir/lib/Dialect/SPIRV/IR/SPIRVDialect.cpp

Optional<unsigned> parseAndVerify<unsigned>(SPIRVDialect const &dialect,
   return parseAndVerifyInteger<unsigned>(dialect, parser);
 }
 
 namespace {
 // Functor object to parse a comma separated list of specs. The function
 // parseAndVerify does the actual parsing and verification of individual
 // elements. This is a functor since parsing the last element of the list
 // (termination condition) needs partial specialization.
-template <typename ParseType, typename... Args>
-struct ParseCommaSeparatedList {
+template <typename ParseType, typename... Args> struct ParseCommaSeparatedList {
   Optional<std::tuple<ParseType, Args...>>
   operator()(SPIRVDialect const &dialect, DialectAsmParser &parser) const {
     auto parseVal = parseAndVerify<ParseType>(dialect, parser);
     if (!parseVal)
       return llvm::None;
 
     auto numArgs = std::tuple_size<std::tuple<Args...>>::value;
     if (numArgs != 0 && failed(parser.parseComma()))
       return llvm::None;
     auto remainingValues = ParseCommaSeparatedList<Args...>{}(dialect, parser);
     if (!remainingValues)
       return llvm::None;
     return std::tuple_cat(std::tuple<ParseType>(parseVal.getValue()),
                           remainingValues.getValue());
   }
 };
 
 // Partial specialization of the function to parse a comma separated list of
 // specs to parse the last element of the list.
-template <typename ParseType>
-struct ParseCommaSeparatedList<ParseType> {
+template <typename ParseType> struct ParseCommaSeparatedList<ParseType> {
   Optional<std::tuple<ParseType>> operator()(SPIRVDialect const &dialect,
                                              DialectAsmParser &parser) const {
     if (auto value = parseAndVerify<ParseType>(dialect, parser))
       return std::tuple<ParseType>(value.getValue());
     return llvm::None;
   }
 };
 } // namespace
static Type parseStructType(SPIRVDialect const &dialect,
 
   // To properly resolve recursive references while parsing recursive struct
   // types, we need to maintain a list of enclosing struct type names. This set
   // maintains the names of struct types in which the type we are about to parse
   // is nested.
   //
   // Note: This has to be thread_local to enable multiple threads to safely
   // parse concurrently.
-  thread_local llvm::SetVector<StringRef> structContext;
+  thread_local SetVector<StringRef> structContext;
 
-  static auto removeIdentifierAndFail =
-      [](llvm::SetVector<StringRef> &structContext, StringRef identifier) {
-        if (!identifier.empty())
-          structContext.remove(identifier);
+  static auto removeIdentifierAndFail = [](SetVector<StringRef> &structContext,
+                                           StringRef identifier) {
 
-        return Type();
-      };
 
   if (parser.parseLess())
     return Type();
 
   StringRef identifier;
 
   // Check if this is an identified struct type.
   if (succeeded(parser.parseOptionalKeyword(&identifier))) {
os << "image<" << type.getElementType() << ", " << stringifyDim(type.getDim())
      << stringifyImageFormat(type.getImageFormat()) << ">";
 }
 
 static void print(SampledImageType type, DialectAsmPrinter &os) {
   os << "sampled_image<" << type.getImageType() << ">";
 }
 
 static void print(StructType type, DialectAsmPrinter &os) {
-  thread_local llvm::SetVector<StringRef> structContext;
+  thread_local SetVector<StringRef> structContext;
 
   os << "struct<";
 
   if (type.isIdentified()) {
     os << type.getIdentifier();
 
     if (structContext.count(type.getIdentifier())) {
       os << ">";

mlir/lib/Dialect/SPIRV/IR/SPIRVEnums.cpp

 }
 
 // Pull in utility function definition for implied capabilities
 #include "mlir/Dialect/SPIRV/IR/SPIRVCapabilityImplication.inc"
 
 SmallVector<spirv::Capability, 0>
 spirv::getRecursiveImpliedCapabilities(spirv::Capability cap) {
   ArrayRef<spirv::Capability> directCaps = getDirectImpliedCapabilities(cap);
-  llvm::SetVector<spirv::Capability, SmallVector<spirv::Capability, 0>> allCaps(
+  SetVector<spirv::Capability, SmallVector<spirv::Capability, 0>> allCaps(
       directCaps.begin(), directCaps.end());
 
   // TODO: This is insufficient; find a better way to handle this
   // (e.g., using static lists) if this turns out to be a bottleneck.
   for (unsigned i = 0; i < allCaps.size(); ++i)
     for (Capability c : getDirectImpliedCapabilities(allCaps[i]))
       allCaps.insert(c);
 
   return allCaps.takeVector();
 }

mlir/lib/Dialect/SPIRV/Transforms/LowerABIAttributesPass.cpp

 /// with an spv.EntryPointOp. Traverses the body of a entry function to do so.
 static LogicalResult
 getInterfaceVariables(spirv::FuncOp funcOp,
                       SmallVectorImpl<Attribute> &interfaceVars) {
   auto module = funcOp->getParentOfType<spirv::ModuleOp>();
   if (!module) {
     return failure();
   }
-  llvm::SetVector<Operation *> interfaceVarSet;
+  SetVector<Operation *> interfaceVarSet;
 
   // TODO: This should in reality traverse the entry function
   // call graph and collect all the interfaces. For now, just traverse the
   // instructions in this function.
   funcOp.walk([&](spirv::AddressOfOp addressOfOp) {
     auto var =
         module.lookupSymbol<spirv::GlobalVariableOp>(addressOfOp.variable());
     // TODO: Per SPIR-V spec: "Before version 1.4, the interface’s

mlir/lib/Dialect/SPIRV/Transforms/UpdateVCEPass.cpp

 /// errors attaching to the given `op` on failures.
 ///
 ///  `candidates` is a vector of vector for extension requirements following
 /// ((Extension::A OR Extension::B) AND (Extension::C OR Extension::D))
 /// convention.
 static LogicalResult checkAndUpdateExtensionRequirements(
     Operation *op, const spirv::TargetEnv &targetEnv,
     const spirv::SPIRVType::ExtensionArrayRefVector &candidates,
-    llvm::SetVector<spirv::Extension> &deducedExtensions) {
+    SetVector<spirv::Extension> &deducedExtensions) {
   for (const auto &ors : candidates) {
     if (Optional<spirv::Extension> chosen = targetEnv.allows(ors)) {
       deducedExtensions.insert(*chosen);
     } else {
       SmallVector<StringRef, 4> extStrings;
       for (spirv::Extension ext : ors)
         extStrings.push_back(spirv::stringifyExtension(ext));
 

 /// errors attaching to the given `op` on failures.
 ///
 ///  `candidates` is a vector of vector for capability requirements following
 /// ((Capability::A OR Capability::B) AND (Capability::C OR Capability::D))
 /// convention.
 static LogicalResult checkAndUpdateCapabilityRequirements(
     Operation *op, const spirv::TargetEnv &targetEnv,
     const spirv::SPIRVType::CapabilityArrayRefVector &candidates,
-    llvm::SetVector<spirv::Capability> &deducedCapabilities) {
+    SetVector<spirv::Capability> &deducedCapabilities) {
   for (const auto &ors : candidates) {
     if (Optional<spirv::Capability> chosen = targetEnv.allows(ors)) {
       deducedCapabilities.insert(*chosen);
     } else {
       SmallVector<StringRef, 4> capStrings;
       for (spirv::Capability cap : ors)
         capStrings.push_back(spirv::stringifyCapability(cap));
 
if (!targetAttr) {
     module.emitError("missing 'spv.target_env' attribute");
     return signalPassFailure();
   }
 
   spirv::TargetEnv targetEnv(targetAttr);
   spirv::Version allowedVersion = targetAttr.getVersion();
 
   spirv::Version deducedVersion = spirv::Version::V_1_0;
-  llvm::SetVector<spirv::Extension> deducedExtensions;
-  llvm::SetVector<spirv::Capability> deducedCapabilities;
+  SetVector<spirv::Extension> deducedExtensions;
+  SetVector<spirv::Capability> deducedCapabilities;
 
   // Walk each SPIR-V op to deduce the minimal version/extension/capability
   // requirements.
   WalkResult walkResult = module.walk([&](Operation *op) -> WalkResult {
     // Op min version requirements
     if (auto minVersion = dyn_cast<spirv::QueryMinVersionInterface>(op)) {
       deducedVersion = std::max(deducedVersion, minVersion.getMinVersion());
       if (deducedVersion > allowedVersion) {

mlir/lib/Dialect/Vector/VectorUtils.cpp

 #include "mlir/IR/Operation.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Support/MathExtras.h"
 #include <numeric>
 
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/SetVector.h"
 
-using llvm::SetVector;
-
 using namespace mlir;
 
 /// Return the number of elements of basis, `0` if empty.
 int64_t mlir::computeMaxLinearIndex(ArrayRef<int64_t> basis) {
   if (basis.empty())
     return 0;
   return std::accumulate(basis.begin(), basis.end(), 1,
                          std::multiplies<int64_t>());

mlir/lib/IR/SymbolTable.cpp

 
 /// Collect all of the symbol scopes from 'symbol' to (inclusive) 'limit'.
 static SmallVector<SymbolScope, 2> collectSymbolScopes(Operation *symbol,
                                                        Operation *limit) {
   StringRef symName = SymbolTable::getSymbolName(symbol);
   assert(!symbol->hasTrait<OpTrait::SymbolTable>() || symbol != limit);
 
   // Compute the ancestors of 'limit'.
-  llvm::SetVector<Operation *, SmallVector<Operation *, 4>,
-                  SmallPtrSet<Operation *, 4>>
+  SetVector<Operation *, SmallVector<Operation *, 4>,
       limitAncestors;
   Operation *limitAncestor = limit;
   do {
     // Check to see if 'symbol' is an ancestor of 'limit'.
     if (limitAncestor == symbol) {
       // Check that the nearest symbol table is 'symbol's parent. SymbolRefAttr
       // doesn't support parent references.
       if (SymbolTable::getNearestSymbolTable(limit->getParentOp()) ==
SymbolTable::walkSymbolTables(symbolTableOp, /*allSymUsesVisible=*/false,
                                 walkFn);
 }
 
 void SymbolUserMap::replaceAllUsesWith(Operation *symbol,
                                        StringRef newSymbolName) {
   auto it = symbolToUsers.find(symbol);
   if (it == symbolToUsers.end())
     return;
-  llvm::SetVector<Operation *> &users = it->second;
+  SetVector<Operation *> &users = it->second;
 
   // Replace the uses within the users of `symbol`.
   for (Operation *user : users)
     (void)SymbolTable::replaceAllSymbolUses(symbol, newSymbolName, user);
 
   // Move the current users of `symbol` to the new symbol if it is in the
   // symbol table.
   Operation *newSymbol =

mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp

llvm::BasicBlock *llvmBB = llvm::BasicBlock::Create(
         llvmContext, blockName, builder.GetInsertBlock()->getParent());
     moduleTranslation.mapBlock(&bb, llvmBB);
   }
 
   llvm::Instruction *sourceTerminator = sourceBlock.getTerminator();
 
   // Convert blocks one by one in topological order to ensure
   // defs are converted before uses.
-  llvm::SetVector<Block *> blocks =
+  SetVector<Block *> blocks =
       LLVM::detail::getTopologicallySortedBlocks(region);
   for (Block *bb : blocks) {
     llvm::BasicBlock *llvmBB = moduleTranslation.lookupBlock(bb);
     // Retarget the branch of the entry block to the entry block of the
     // converted region (regions are single-entry).
     if (bb->isEntryBlock()) {
       assert(sourceTerminator->getNumSuccessors() == 1 &&
              "provided entry block has multiple successors");

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

for (auto &numberedPhiNode : llvm::enumerate(phis)) {
             state.lookupValue(getPHISourceValue(bb, pred, numArguments, index)),
             terminator->getParent());
       }
     }
   }
 }
 
 /// Sort function blocks topologically.
-llvm::SetVector<Block *>
+SetVector<Block *>
 mlir::LLVM::detail::getTopologicallySortedBlocks(Region &region) {
   // For each block that has not been visited yet (i.e. that has no
   // predecessors), add it to the list as well as its successors.
-  llvm::SetVector<Block *> blocks;
+  SetVector<Block *> blocks;
   for (Block &b : region) {
     if (blocks.count(&b) == 0) {
       llvm::ReversePostOrderTraversal<Block *> traversal(&b);
       blocks.insert(traversal.begin(), traversal.end());
     }
   }
   assert(blocks.size() == region.getBlocks().size() &&
          "some blocks are not sorted");

mlir/lib/Target/SPIRV/Deserialization/Deserializer.h

private:
   // spv.ExecutionMode) need these references resolved. So these instructions
   // are deserialized and stored for processing once the entire binary is
   // processed.
   SmallVector<std::pair<spirv::Opcode, ArrayRef<uint32_t>>, 4>
       deferredInstructions;
 
   /// A list of IDs for all types forward-declared through OpTypeForwardPointer
   /// instructions.
-  llvm::SetVector<uint32_t> typeForwardPointerIDs;
+  SetVector<uint32_t> typeForwardPointerIDs;
 
   /// A list of all structs which have unresolved member types.
   SmallVector<DeferredStructTypeInfo, 0> deferredStructTypesInfos;
 };
 
 } // namespace spirv
 } // namespace mlir
 
 #endif // MLIR_TARGET_SPIRV_DESERIALIZER_H

mlir/lib/Target/SPIRV/Deserialization/Deserializer.cpp

private:
   uint32_t control;
 
   spirv::BlockMergeInfoMap &blockMergeInfo;
 
   Block *headerBlock;
   Block *mergeBlock;
   Block *continueBlock; // nullptr for spv.mlir.selection
 
-  llvm::SetVector<Block *> constructBlocks;
+  SetVector<Block *> constructBlocks;
 };
 } // namespace
 
 spirv::SelectionOp
 ControlFlowStructurizer::createSelectionOp(uint32_t selectionControl) {
   // Create a builder and set the insertion point to the beginning of the
   // merge block so that the newly created SelectionOp will be inserted there.
   OpBuilder builder(&mergeBlock->front());

mlir/lib/Target/SPIRV/Serialization/Serializer.h

private:
   /// Returns true if the given type is a pointer type to a struct in some
   /// interface storage class.
   bool isInterfaceStructPtrType(Type type) const;
 
   /// Main dispatch method for serializing a type. The result <id> of the
   /// serialized type will be returned as `typeID`.
   LogicalResult processType(Location loc, Type type, uint32_t &typeID);
   LogicalResult processTypeImpl(Location loc, Type type, uint32_t &typeID,
-                                llvm::SetVector<StringRef> &serializationCtx);
+                                SetVector<StringRef> &serializationCtx);
 
   /// Method for preparing basic SPIR-V type serialization. Returns the type's
   /// opcode and operands for the instruction via `typeEnum` and `operands`.
   LogicalResult prepareBasicType(Location loc, Type type, uint32_t resultID,
                                  spirv::Opcode &typeEnum,
                                  SmallVectorImpl<uint32_t> &operands,
                                  bool &deferSerialization,
-                                 llvm::SetVector<StringRef> &serializationCtx);
+                                 SetVector<StringRef> &serializationCtx);
 
   LogicalResult prepareFunctionType(Location loc, FunctionType type,
                                     spirv::Opcode &typeEnum,
                                     SmallVectorImpl<uint32_t> &operands);
 
   //===--------------------------------------------------------------------===//
   // Constant
   //===--------------------------------------------------------------------===//
private:
   /// dialect that is a mirror of an instruction in the SPIR-V spec. This is
   /// auto-generated from ODS. Dispatch is handled for all operations in SPIR-V
   /// dialect that have hasOpcode == 1.
   LogicalResult dispatchToAutogenSerialization(Operation *op);
 
   /// Serializes an operation in the SPIR-V dialect that is a mirror of an
   /// instruction in the SPIR-V spec. This is auto generated if hasOpcode == 1
   /// and autogenSerialization == 1 in ODS.
-  template <typename OpTy>
-  LogicalResult processOp(OpTy op) {
+  template <typename OpTy> LogicalResult processOp(OpTy op) {
     return op.emitError("unsupported op serialization");
   }
 
   //===--------------------------------------------------------------------===//
   // Utilities
   //===--------------------------------------------------------------------===//
 
   /// Emits an OpDecorate instruction to decorate the given `target` with the

mlir/lib/Target/SPIRV/Serialization/Serializer.cpp

bool Serializer::isInterfaceStructPtrType(Type type) const {
   }
   return false;
 }
 
 LogicalResult Serializer::processType(Location loc, Type type,
                                       uint32_t &typeID) {
   // Maintains a set of names for nested identified struct types. This is used
   // to properly serialize recursive references.
-  llvm::SetVector<StringRef> serializationCtx;
+  SetVector<StringRef> serializationCtx;
   return processTypeImpl(loc, type, typeID, serializationCtx);
 }
 
 LogicalResult
 Serializer::processTypeImpl(Location loc, Type type, uint32_t &typeID,
-                            llvm::SetVector<StringRef> &serializationCtx) {
+                            SetVector<StringRef> &serializationCtx) {
   typeID = getTypeID(type);
   if (typeID) {
     return success();
   }
   typeID = getNextID();
   SmallVector<uint32_t, 4> operands;
 
   operands.push_back(typeID);
Serializer::processTypeImpl(Location loc, Type type, uint32_t &typeID,
   }
 
   return failure();
 }
 
 LogicalResult Serializer::prepareBasicType(
     Location loc, Type type, uint32_t resultID, spirv::Opcode &typeEnum,
     SmallVectorImpl<uint32_t> &operands, bool &deferSerialization,
-    llvm::SetVector<StringRef> &serializationCtx) {
+    SetVector<StringRef> &serializationCtx) {
   deferSerialization = false;
 
   if (isVoidType(type)) {
     typeEnum = spirv::Opcode::OpTypeVoid;
     return success();
   }
 
   if (auto intType = type.dyn_cast<IntegerType>()) {

mlir/lib/Transforms/LoopFusion.cpp

 #include "llvm/ADT/SetVector.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include <iomanip>
 #include <sstream>
 #define DEBUG_TYPE "affine-loop-fusion"
 
-using llvm::SetVector;
-
 using namespace mlir;
 
 namespace {
 /// Loop fusion pass. This pass currently supports a greedy fusion policy,
 /// which fuses loop nests with single-writer/single-reader memref dependences
 /// with the goal of improving locality.
 
 // TODO: Support fusion of source loop nests which write to multiple

mlir/lib/Transforms/Utils/DialectConversion.cpp

computeConversionSet(iterator_range<Region::iterator> region,
   if (llvm::any_of(llvm::drop_begin(region, 1),
                    [&](Block &block) { return !visitedBlocks.count(&block); }))
     return emitError(regionLoc, "unreachable blocks were not converted");
   return success();
 }
 
 /// A utility function to log a successful result for the given reason.
 template <typename... Args>
-static void logSuccess(llvm::ScopedPrinter &os, StringRef fmt,
-                       Args &&... args) {
+static void logSuccess(llvm::ScopedPrinter &os, StringRef fmt, Args &&...args) {
   LLVM_DEBUG({
     os.unindent();
     os.startLine() << "} -> SUCCESS";
     if (!fmt.empty())
       os.getOStream() << " : "
                       << llvm::formatv(fmt.data(), std::forward<Args>(args)...);
     os.getOStream() << "\n";
   });
 }
 
 /// A utility function to log a failure result for the given reason.
 template <typename... Args>
-static void logFailure(llvm::ScopedPrinter &os, StringRef fmt,
-                       Args &&... args) {
+static void logFailure(llvm::ScopedPrinter &os, StringRef fmt, Args &&...args) {
   LLVM_DEBUG({
     os.unindent();
     os.startLine() << "} -> FAILURE : "
                    << llvm::formatv(fmt.data(), std::forward<Args>(args)...)
                    << "\n";
   });
 }
 
struct ConversionPatternRewriterImpl {
   /// but were not directly replace/erased/etc. by a pattern. These are
   /// generally child operations of other operations who were
   /// replaced/erased/etc. This is not meant to be an exhaustive list of all
   /// operations, but the minimal set that can be used to detect if a given
   /// operation should be `ignored`. For example, we may add the operations that
   /// define non-empty regions to the set, but not any of the others. This
   /// simplifies the amount of memory needed as we can query if the parent
   /// operation was ignored.
-  llvm::SetVector<Operation *> ignoredOps;
+  SetVector<Operation *> ignoredOps;
 
   /// A transaction state for each of operations that were updated in-place.
   SmallVector<OperationTransactionState, 4> rootUpdates;
 
   /// A vector of indices into `replacements` of operations that were replaced
   /// with values with different result types than the original operation, e.g.
   /// 1->N conversion of some kind.
   SmallVector<unsigned, 4> operationsWithChangedResults;
void OperationLegalizer::buildLegalizationGraph(
     LegalizationPatterns &anyOpLegalizerPatterns,
     DenseMap<OperationName, LegalizationPatterns> &legalizerPatterns) {
   // A mapping between an operation and a set of operations that can be used to
   // generate it.
   DenseMap<OperationName, SmallPtrSet<OperationName, 2>> parentOps;
   // A mapping between an operation and any currently invalid patterns it has.
   DenseMap<OperationName, SmallPtrSet<const Pattern *, 2>> invalidPatterns;
   // A worklist of patterns to consider for legality.
-  llvm::SetVector<const Pattern *> patternWorklist;
+  SetVector<const Pattern *> patternWorklist;
 
   // Build the mapping from operations to the parent ops that may generate them.
   applicator.walkAllPatterns([&](const Pattern &pattern) {
     Optional<OperationName> root = pattern.getRootKind();
 
     // If the pattern has no specific root, we can't analyze the relationship
     // between the root op and generated operations. Given that, add all such
     // patterns to the legalization set.

mlir/lib/Transforms/Utils/LoopUtils.cpp

 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
 #define DEBUG_TYPE "LoopUtils"
 
 using namespace mlir;
-using llvm::SetVector;
 using llvm::SmallMapVector;
 
 namespace {
 // This structure is to pass and return sets of loop parameters without
 // confusing the order.
 struct LoopParams {
   Value lowerBound;
   Value upperBound;

mlir/lib/Transforms/Utils/RegionUtils.cpp

 
 void mlir::visitUsedValuesDefinedAbove(
     MutableArrayRef<Region> regions, function_ref<void(OpOperand *)> callback) {
   for (Region &region : regions)
     visitUsedValuesDefinedAbove(region, region, callback);
 }
 
 void mlir::getUsedValuesDefinedAbove(Region &region, Region &limit,
-                                     llvm::SetVector<Value> &values) {
+                                     SetVector<Value> &values) {
   visitUsedValuesDefinedAbove(region, limit, [&](OpOperand *operand) {
     values.insert(operand->get());
   });
 }
 
 void mlir::getUsedValuesDefinedAbove(MutableArrayRef<Region> regions,
-                                     llvm::SetVector<Value> &values) {
+                                     SetVector<Value> &values) {
   for (Region &region : regions)
     getUsedValuesDefinedAbove(region, region, values);
 }
 
 //===----------------------------------------------------------------------===//
 // Unreachable Block Elimination
 //===----------------------------------------------------------------------===//
 

mlir/test/lib/Dialect/Affine/TestVectorizationUtils.cpp

 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 
 #define DEBUG_TYPE "affine-super-vectorizer-test"
 
 using namespace mlir;
 
-using llvm::SetVector;
-
 static llvm::cl::OptionCategory clOptionsCategory(DEBUG_TYPE " options");
 
 static llvm::cl::list<int> clTestVectorShapeRatio(
     "vector-shape-ratio",
     llvm::cl::desc("Specify the HW vector size for vectorization"),
     llvm::cl::ZeroOrMore, llvm::cl::cat(clOptionsCategory));
 static llvm::cl::opt<bool> clTestForwardSlicingAnalysis(
     "forward-slicing",

mlir/test/lib/Dialect/Test/TestTypes.cpp

 void TestDialect::registerTypes() {
   addTypes<TestRecursiveType,
 #define GET_TYPEDEF_LIST
 #include "TestTypeDefs.cpp.inc"
            >();
 }
 
 static Type parseTestType(MLIRContext *ctxt, DialectAsmParser &parser,
-                          llvm::SetVector<Type> &stack) {
+                          SetVector<Type> &stack) {
   StringRef typeTag;
   if (failed(parser.parseKeyword(&typeTag)))
     return Type();
 
   {
     Type genType;
     auto parseResult = generatedTypeParser(ctxt, parser, typeTag, genType);
     if (parseResult.hasValue())
static Type parseTestType(MLIRContext *ctxt, DialectAsmParser &parser,
   stack.pop_back();
   if (!subtype || failed(parser.parseGreater()) || failed(rec.setBody(subtype)))
     return Type();
 
   return rec;
 }
 
 Type TestDialect::parseType(DialectAsmParser &parser) const {
-  llvm::SetVector<Type> stack;
+  SetVector<Type> stack;
   return parseTestType(getContext(), parser, stack);
 }
 
 static void printTestType(Type type, DialectAsmPrinter &printer,
-                          llvm::SetVector<Type> &stack) {
+                          SetVector<Type> &stack) {
   if (succeeded(generatedTypePrinter(type, printer)))
     return;
 
   auto rec = type.cast<TestRecursiveType>();
   printer << "test_rec<" << rec.getName();
   if (!stack.contains(rec)) {
     printer << ", ";
     stack.insert(rec);
     printTestType(rec.getBody(), printer, stack);
     stack.pop_back();
   }
   printer << ">";
 }
 
 void TestDialect::printType(Type type, DialectAsmPrinter &printer) const {
-  llvm::SetVector<Type> stack;
+  SetVector<Type> stack;
   printTestType(type, printer, stack);
 }

mlir/test/lib/IR/TestSlicing.cpp

static LogicalResult createBackwardSliceFunction(Operation *op,
   Location loc = op->getLoc();
   std::string clonedFuncOpName = parentFuncOp.getName().str() + suffix.str();
   FuncOp clonedFuncOp =
       builder.create<FuncOp>(loc, clonedFuncOpName, parentFuncOp.getType());
   BlockAndValueMapping mapper;
   builder.setInsertionPointToEnd(clonedFuncOp.addEntryBlock());
   for (auto arg : enumerate(parentFuncOp.getArguments()))
     mapper.map(arg.value(), clonedFuncOp.getArgument(arg.index()));
-  llvm::SetVector<Operation *> slice;
+  SetVector<Operation *> slice;
   getBackwardSlice(op, &slice);
   for (Operation *slicedOp : slice)
     builder.clone(*slicedOp, mapper);
   builder.create<ReturnOp>(loc);
   return success();
 }
 
 namespace {

mlir/test/lib/Transforms/TestLinalgElementwiseFusion.cpp

 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "llvm/ADT/TypeSwitch.h"
 
 namespace mlir {
 
-static void addOperands(Operation *op, llvm::SetVector<Value> &operandSet) {
+static void addOperands(Operation *op, SetVector<Value> &operandSet) {
   if (!op)
     return;
   TypeSwitch<Operation *, void>(op)
       .Case<linalg::LinalgOp>([&](linalg::LinalgOp linalgOp) {
         operandSet.insert(linalgOp.getInputs().begin(),
                           linalgOp.getInputs().end());
       })
       .Default([&](Operation *operation) {
         operandSet.insert(operation->operand_begin(), operation->operand_end());
       });
 }
 
 template <int limit = 3>
 static bool setFusedOpOperandLimit(const OpResult &producer,
                                    const OpOperand &consumer) {
-  llvm::SetVector<Value> fusedOpOperands;
+  SetVector<Value> fusedOpOperands;
   if (producer.getOwner()->getNumResults() != 1)
     return false;
   addOperands(consumer.getOwner(), fusedOpOperands);
   fusedOpOperands.remove(producer);
   addOperands(producer.getOwner(), fusedOpOperands);
   return fusedOpOperands.size() <= limit;
 }
 

mlir/tools/mlir-linalg-ods-gen/mlir-linalg-ods-gen.cpp

genODSImpl("gen-impl", llvm::cl::desc("Emit the ops implementations"),
                llvm::cl::init(false), llvm::cl::cat(ODSGenCat));
 
 static llvm::cl::opt<bool> testEmitIncludeTdHeader(
     "test-emit-include-td-header",
     llvm::cl::desc("Include LinalgStructuredOps.td for end-to-end "
                    "tblgen testing."),
     llvm::cl::init(false), llvm::cl::cat(ODSGenCat));
 
-using llvm::SetVector;
 using llvm::SMLoc;
 using llvm::StringRef;
 using llvm::Twine;
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // Lexer
struct TensorUse : public Expression {
   }
 
   bool operator==(const TensorUse &other) const {
     return tensorId == other.tensorId && indexingMap == other.indexingMap;
   }
 
   /// Visitation function. Performs preorder or postorder traversal depending on
   /// `PreOrder` and applies `callback` on each node.
-  template <typename Lambda, bool PreOrder>
-  void visit(Lambda callback) const;
+  template <typename Lambda, bool PreOrder> void visit(Lambda callback) const;
 
   StringRef tensorId;
   AffineMap indexingMap;
 };
 
 /// Encodes a tensor expression of the form:
 ///
 ///   op-spec ::= bare-id `<` reduction-dims-list `>`
bool operator==(const TensorExpr &other) const {
     for (unsigned i = 0, e = reductionDimensions.size(); i < e; ++i)
       if (reductionDimensions[i] != other.reductionDimensions[i])
         return false;
     return true;
   }
 
   /// Visitation function. Performs preorder or postorder traversal depending on
   /// `PreOrder` and applies `callback` on each node.
-  template <typename Lambda, bool PreOrder>
-  void visit(Lambda callback) const;
+  template <typename Lambda, bool PreOrder> void visit(Lambda callback) const;
 
   StringRef operationName;
   SmallVector<std::unique_ptr<Expression>, 4> expressions;
   SetVector<unsigned> reductionDimensions;
 };
 
 /// This is a specialized parser for a TCDef.
 /// This maintains the dims it finds in an eager fashion.
private:
   StringRef docString;
 
   Parser &parser;
 };
 } // namespace
 
 namespace llvm {
 
-template <>
-struct DenseMapInfo<TensorUse> {
+template <> struct DenseMapInfo<TensorUse> {
   static TensorUse getEmptyKey() { return TensorUse("", AffineMap()); }
   static TensorUse getTombstoneKey() {
     return TensorUse(DenseMapInfo<StringRef>::getTombstoneKey(),
                      DenseMapInfo<AffineMap>::getTombstoneKey());
   }
   static unsigned getHashValue(const TensorUse &val) {
     return ::llvm::hash_value(val.tensorId); // don't care about collisions.
   }