[MLIR][NFC] Adopt use of TypeRange in build() methods.

[jurahul]

Summary

• Use TypeRange instead of ArrayRef<Type> where possible.
• Change some of the custom builders to also use TypeRange

Depends On D87926

[jurahul]

Rebase

mlir/include/mlir/Dialect/Affine/IR/AffineOps.td

let arguments = (ins
      AffineMapAttr:$upperBoundsMap,
      I64ArrayAttr:$steps,
      Variadic<Index>:$mapOperands);
   let results = (outs Variadic<AnyType>:$results);
   let regions = (region SizedRegion<1>:$region);
 
   let builders = [
     OpBuilder<"OpBuilder &builder, OperationState &result, "
-              "ArrayRef<Type> resultTypes, "
+              "TypeRange resultTypes, "
               "ArrayRef<AtomicRMWKind> reductions, "
               "ArrayRef<int64_t> ranges">,
     OpBuilder<"OpBuilder &builder, OperationState &result, "
-              "ArrayRef<Type> resultTypes, "
+              "TypeRange resultTypes, "
               "ArrayRef<AtomicRMWKind> reductions, "
               "AffineMap lbMap, ValueRange lbArgs, "
               "AffineMap ubMap, ValueRange ubArgs">,
     OpBuilder<"OpBuilder &builder, OperationState &result, "
-              "ArrayRef<Type> resultTypes, "
+              "TypeRange resultTypes, "
               "ArrayRef<AtomicRMWKind> reductions, "
               "AffineMap lbMap, ValueRange lbArgs, "
               "AffineMap ubMap, ValueRange ubArgs, "
               "ArrayRef<int64_t> steps">
   ];
 
   let extraClassDeclaration = [{
     /// Get the number of dimensions.

mlir/include/mlir/Dialect/GPU/GPUOps.td

def GPU_GPUFuncOp : GPU_Op<"func", [HasParent<"GPUModuleOp">,
   }];
 
   let regions = (region AnyRegion:$body);
 
   let skipDefaultBuilders = 1;
 
   let builders = [
     OpBuilder<"OpBuilder &builder, OperationState &result, StringRef name, "
-              "FunctionType type, ArrayRef<Type> workgroupAttributions = {}, "
-              "ArrayRef<Type> privateAttributions = {}, "
+              "FunctionType type, TypeRange workgroupAttributions = {}, "
+              "TypeRange privateAttributions = {}, "
               "ArrayRef<NamedAttribute> attrs = {}">
   ];
 
   let extraClassDeclaration = [{
     /// Returns `true` if the GPU function defined by this Op is a kernel, i.e.
     /// it is intended to be launched from host.
     bool isKernel() {
       return getAttrOfType<UnitAttr>(GPUDialect::getKernelFuncAttrName()) !=

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

def LLVM_InvokeOp : LLVM_Op<"invoke", [
                                Variadic<LLVM_Type>:$operands,
                                Variadic<LLVM_Type>:$normalDestOperands,
                                Variadic<LLVM_Type>:$unwindDestOperands)>,
                     Results<(outs Variadic<LLVM_Type>)> {
   let successors = (successor AnySuccessor:$normalDest,
                               AnySuccessor:$unwindDest);
 
   let builders = [OpBuilder<
-    "OpBuilder &b, OperationState &result, ArrayRef<Type> tys, "
+    "OpBuilder &b, OperationState &result, TypeRange tys, "
     "FlatSymbolRefAttr callee, ValueRange ops, Block* normal, "
     "ValueRange normalOps, Block* unwind, ValueRange unwindOps",
     [{
       result.addAttribute("callee", callee);
       build(b, result, tys, ops, normal, normalOps, unwind, unwindOps);
     }]>,
     OpBuilder<
-    "OpBuilder &b, OperationState &result, ArrayRef<Type> tys, "
+    "OpBuilder &b, OperationState &result, TypeRange tys, "
     "ValueRange ops, Block* normal, "
     "ValueRange normalOps, Block* unwind, ValueRange unwindOps",
     [{
       build(b, result, tys, /*callee=*/FlatSymbolRefAttr(), ops, normalOps,
             unwindOps, normal, unwind);
     }]>];
   let verifier = [{ return ::verify(*this);  }];
   let parser = [{ return parseInvokeOp(parser, result); }];

mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOps.td

let description = [{
     ```
     where symbol s0 will be substituted with `dim %filter, %c0` i.e. the first
     and only dimension of the second operand as specified by the symbol_source
     attribute.
   }];
 
   let builders = [
     OpBuilder<
-      "OpBuilder &builder, OperationState &result, ArrayRef<Type> resultTensorTypes,"
+      "OpBuilder &builder, OperationState &result, TypeRange resultTensorTypes,"
       "ValueRange inputs, ValueRange outputBuffers, ValueRange initTensors, "
       "ArrayRef<AffineMap> indexingMaps, ArrayRef<StringRef> iteratorTypes, "
       "StringRef doc, StringRef libraryCall, IntegerAttr symbolSource, "
       "function_ref<void(OpBuilder &, Location, ValueRange)> = nullptr">,
     OpBuilder<
       "OpBuilder &builder, OperationState &result, "
       "ValueRange inputs, ValueRange outputBuffers, "
       "ArrayRef<AffineMap> indexingMaps, ArrayRef<StringRef> iteratorTypes, "
       "StringRef doc, StringRef libraryCall, IntegerAttr symbolSource, "
       "function_ref<void(OpBuilder &, Location, ValueRange)> = nullptr">,
     OpBuilder<
-      "OpBuilder &builder, OperationState &result, ArrayRef<Type> resultTensorTypes,"
+      "OpBuilder &builder, OperationState &result, TypeRange resultTensorTypes,"
       "ValueRange inputs, ValueRange outputBuffers, ValueRange initTensors, "
       "ArrayRef<AffineMap> indexingMaps, ArrayRef<StringRef> iteratorTypes, "
       "function_ref<void(OpBuilder &, Location, ValueRange)> = nullptr">,
     OpBuilder<
       "OpBuilder &builder, OperationState &result, ValueRange inputs, "
       "ValueRange outputBuffers, ArrayRef<AffineMap> indexingMaps, "
       "ArrayRef<StringRef> iteratorTypes, "
       "function_ref<void(OpBuilder &, Location, ValueRange)> = nullptr">
let description = [{
     ```
     where symbol s0 will be substituted with `dim %filter, %c0` i.e. the first
     and only dimension of the second operand as specified by the symbol_source
     attribute.
   }];
 
   let builders = [
     OpBuilder<
-      "OpBuilder &builder, OperationState &result, ArrayRef<Type> resultTensorTypes,"
+      "OpBuilder &builder, OperationState &result, TypeRange resultTensorTypes,"
       "ValueRange inputs, ValueRange outputBuffers, ValueRange initTensors, "
       "ArrayRef<AffineMap> indexingMaps, ArrayRef<StringRef> iteratorTypes, "
       "StringRef doc, StringRef libraryCall, IntegerAttr symbolSource, "
       "function_ref<void(OpBuilder &, Location, ValueRange, ValueRange)> = nullptr">,
     OpBuilder<
       "OpBuilder &builder, OperationState &result, "
       "ValueRange inputs, ValueRange outputBuffers, "
       "ArrayRef<AffineMap> indexingMaps, ArrayRef<StringRef> iteratorTypes, "
       "StringRef doc, StringRef libraryCall, IntegerAttr symbolSource, "
       "function_ref<void(OpBuilder &, Location, ValueRange, ValueRange)> = nullptr">,
     OpBuilder<
-      "OpBuilder &builder, OperationState &result, ArrayRef<Type> resultTensorTypes,"
+      "OpBuilder &builder, OperationState &result, TypeRange resultTensorTypes,"
       "ValueRange inputs, ValueRange outputBuffers, ValueRange initTensors, "
       "ArrayRef<AffineMap> indexingMaps, ArrayRef<StringRef> iteratorTypes, "
       "function_ref<void(OpBuilder &, Location, ValueRange, ValueRange)> = nullptr">,
     OpBuilder<
       "OpBuilder &builder, OperationState &result, ValueRange inputs, "
       "ValueRange outputBuffers, ArrayRef<AffineMap> indexingMaps, "
       "ArrayRef<StringRef> iteratorTypes, "
       "function_ref<void(OpBuilder &, Location, ValueRange, ValueRange)> = nullptr">

mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOpsInterface.td

StaticInterfaceMethod<
         Create an operation of the current type with the given location,
         operands, and attributes.
       }],
       /*retTy=*/"Operation *",
       /*methodName=*/"create",
       (ins "OpBuilder &":$builder, "Location":$loc,
            "ValueRange":$operands,
            "ArrayRef<NamedAttribute>":$attributes), [{
-        return builder.create<ConcreteOp>(loc, ArrayRef<Type>{}, operands,
+        return builder.create<ConcreteOp>(loc, TypeRange{}, operands,
                                           attributes);
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Clone the current operation with the given location and operands. This
         is used to abstract away the optional underlying region creation.
       }],

mlir/include/mlir/Dialect/StandardOps/IR/Ops.td

def CallOp : Std_Op<"call", [CallOpInterface, MemRefsNormalizable]> {
   let builders = [OpBuilder<
     "OpBuilder &builder, OperationState &result, FuncOp callee,"
     "ValueRange operands = {}", [{
       result.addOperands(operands);
       result.addAttribute("callee", builder.getSymbolRefAttr(callee));
       result.addTypes(callee.getType().getResults());
   }]>, OpBuilder<
     "OpBuilder &builder, OperationState &result, SymbolRefAttr callee,"
-    "ArrayRef<Type> results, ValueRange operands = {}", [{
+    "TypeRange results, ValueRange operands = {}", [{
       result.addOperands(operands);
       result.addAttribute("callee", callee);
       result.addTypes(results);
   }]>, OpBuilder<
     "OpBuilder &builder, OperationState &result, StringRef callee,"
-    "ArrayRef<Type> results, ValueRange operands = {}", [{
+    "TypeRange results, ValueRange operands = {}", [{
       build(builder, result, builder.getSymbolRefAttr(callee), results,
             operands);
   }]>];
 
   let extraClassDeclaration = [{
     StringRef getCallee() { return callee(); }
     FunctionType getCalleeType();
 
let arguments = (ins
     Variadic<Index>:$strides,
     I64ArrayAttr:$static_offsets,
     I64ArrayAttr:$static_sizes,
     I64ArrayAttr:$static_strides
   );
   let results = (outs AnyMemRef:$result);
 
   let builders = [
-    // Build a SubViewOp with mized static and dynamic entries.
+    // Build a SubViewOp with mixed static and dynamic entries.
     OpBuilder<
       "OpBuilder &b, OperationState &result, Value source, "
       "ArrayRef<int64_t> staticOffsets, ArrayRef<int64_t> staticSizes,"
       "ArrayRef<int64_t> staticStrides, ValueRange offsets, ValueRange sizes, "
       "ValueRange strides, ArrayRef<NamedAttribute> attrs = {}">,
     // Build a SubViewOp with all dynamic entries.
     OpBuilder<
       "OpBuilder &b, OperationState &result, Value source, "

mlir/lib/Conversion/GPUToVulkan/ConvertGPULaunchFuncToVulkanLaunchFunc.cpp

SmallVector<Value, 8> vulkanLaunchOperands(
       gpuLaunchOperands.begin(),
       gpuLaunchOperands.begin() + kVulkanLaunchNumConfigOperands);
   vulkanLaunchOperands.append(gpuLaunchOperands.begin() +
                                   gpu::LaunchOp::kNumConfigOperands,
                               gpuLaunchOperands.end());
 
   // Create vulkan launch call op.
   auto vulkanLaunchCallOp = builder.create<CallOp>(
-      loc, ArrayRef<Type>{}, builder.getSymbolRefAttr(kVulkanLaunch),
+      loc, TypeRange{}, builder.getSymbolRefAttr(kVulkanLaunch),
       vulkanLaunchOperands);
 
   // Set SPIR-V binary shader data as an attribute.
   vulkanLaunchCallOp.setAttr(
       kSPIRVBlobAttrName,
       StringAttr::get({binary.data(), binary.size()}, loc->getContext()));
 
   // Set entry point name as an attribute.

mlir/lib/Conversion/GPUToVulkan/ConvertLaunchFuncToVulkanCalls.cpp

for (auto en :
     if (type.isHalfTy()) {
       auto memRefTy =
           getMemRefType(rank, LLVM::LLVMType::getInt16Ty(&getContext()));
       ptrToMemRefDescriptor = builder.create<LLVM::BitcastOp>(
           loc, memRefTy.getPointerTo(), ptrToMemRefDescriptor);
     }
     // Create call to `bindMemRef`.
     builder.create<LLVM::CallOp>(
-        loc, ArrayRef<Type>{getVoidType()},
+        loc, TypeRange{getVoidType()},
         builder.getSymbolRefAttr(
             StringRef(symbolName.data(), symbolName.size())),
-        ArrayRef<Value>{vulkanRuntime, descriptorSet, descriptorBinding,
-                        ptrToMemRefDescriptor});
+        ValueRange{vulkanRuntime, descriptorSet, descriptorBinding,
   }
 }
 
 LogicalResult VulkanLaunchFuncToVulkanCallsPass::deduceMemRefRankAndType(
     Value ptrToMemRefDescriptor, uint32_t &rank, LLVM::LLVMType &type) {
   auto llvmPtrDescriptorTy =
       ptrToMemRefDescriptor.getType().dyn_cast<LLVM::LLVMType>();
   if (!llvmPtrDescriptorTy)

 }
 
 void VulkanLaunchFuncToVulkanCallsPass::translateVulkanLaunchCall(
     LLVM::CallOp cInterfaceVulkanLaunchCallOp) {
   OpBuilder builder(cInterfaceVulkanLaunchCallOp);
   Location loc = cInterfaceVulkanLaunchCallOp.getLoc();
   // Create call to `initVulkan`.
   auto initVulkanCall = builder.create<LLVM::CallOp>(
-      loc, ArrayRef<Type>{getPointerType()},
-      builder.getSymbolRefAttr(kInitVulkan), ArrayRef<Value>{});
+      loc, TypeRange{getPointerType()}, builder.getSymbolRefAttr(kInitVulkan),
+      ValueRange{});
   // The result of `initVulkan` function is a pointer to Vulkan runtime, we
   // need to pass that pointer to each Vulkan runtime call.
   auto vulkanRuntime = initVulkanCall.getResult(0);
 
   // Create LLVM global with SPIR-V binary data, so we can pass a pointer with
   // that data to runtime call.
   Value ptrToSPIRVBinary = LLVM::createGlobalString(
       loc, builder, kSPIRVBinary, spirvAttributes.first.getValue(),
       LLVM::Linkage::Internal);
 
   // Create LLVM constant for the size of SPIR-V binary shader.
   Value binarySize = builder.create<LLVM::ConstantOp>(
       loc, getInt32Type(),
       builder.getI32IntegerAttr(spirvAttributes.first.getValue().size()));
 
   // Create call to `bindMemRef` for each memref operand.
   createBindMemRefCalls(cInterfaceVulkanLaunchCallOp, vulkanRuntime);
 
   // Create call to `setBinaryShader` runtime function with the given pointer to
   // SPIR-V binary and binary size.
   builder.create<LLVM::CallOp>(
-      loc, ArrayRef<Type>{getVoidType()},
-      builder.getSymbolRefAttr(kSetBinaryShader),
-      ArrayRef<Value>{vulkanRuntime, ptrToSPIRVBinary, binarySize});
+      loc, TypeRange{getVoidType()}, builder.getSymbolRefAttr(kSetBinaryShader),
+      ValueRange{vulkanRuntime, ptrToSPIRVBinary, binarySize});
   // Create LLVM global with entry point name.
   Value entryPointName = createEntryPointNameConstant(
       spirvAttributes.second.getValue(), loc, builder);
   // Create call to `setEntryPoint` runtime function with the given pointer to
   // entry point name.
-  builder.create<LLVM::CallOp>(loc, ArrayRef<Type>{getVoidType()},
+  builder.create<LLVM::CallOp>(loc, TypeRange{getVoidType()},
                                builder.getSymbolRefAttr(kSetEntryPoint),
-                               ArrayRef<Value>{vulkanRuntime, entryPointName});
+                               ValueRange{vulkanRuntime, entryPointName});
 
   // Create number of local workgroup for each dimension.
   builder.create<LLVM::CallOp>(
-      loc, ArrayRef<Type>{getVoidType()},
+      loc, TypeRange{getVoidType()},
       builder.getSymbolRefAttr(kSetNumWorkGroups),
-      ArrayRef<Value>{vulkanRuntime, cInterfaceVulkanLaunchCallOp.getOperand(0),
-                      cInterfaceVulkanLaunchCallOp.getOperand(1),
-                      cInterfaceVulkanLaunchCallOp.getOperand(2)});
+      ValueRange{vulkanRuntime, cInterfaceVulkanLaunchCallOp.getOperand(0),
 
   // Create call to `runOnVulkan` runtime function.
-  builder.create<LLVM::CallOp>(loc, ArrayRef<Type>{getVoidType()},
+  builder.create<LLVM::CallOp>(loc, TypeRange{getVoidType()},
                                builder.getSymbolRefAttr(kRunOnVulkan),
-                               ArrayRef<Value>{vulkanRuntime});
+                               ValueRange{vulkanRuntime});
 
   // Create call to 'deinitVulkan' runtime function.
-  builder.create<LLVM::CallOp>(loc, ArrayRef<Type>{getVoidType()},
+  builder.create<LLVM::CallOp>(loc, TypeRange{getVoidType()},
                                builder.getSymbolRefAttr(kDeinitVulkan),
-                               ArrayRef<Value>{vulkanRuntime});
+                               ValueRange{vulkanRuntime});
 
   // Declare runtime functions.
   declareVulkanFunctions(loc);
 
   cInterfaceVulkanLaunchCallOp.erase();
 }
 
 std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>>
 mlir::createConvertVulkanLaunchFuncToVulkanCallsPass() {
   return std::make_unique<VulkanLaunchFuncToVulkanCallsPass>();
 }

mlir/lib/Conversion/LinalgToStandard/LinalgToStandard.cpp

public:
 
   LogicalResult matchAndRewrite(LinalgOp op,
                                 PatternRewriter &rewriter) const override {
     auto libraryCallName = getLibraryCallSymbolRef<LinalgOp>(op, rewriter);
     if (!libraryCallName)
       return failure();
 
     rewriter.replaceOpWithNewOp<mlir::CallOp>(
-        op, libraryCallName.getValue(), ArrayRef<Type>{},
+        op, libraryCallName.getValue(), TypeRange(),
         createTypeCanonicalizedMemRefOperands(rewriter, op.getLoc(),
                                               op.getOperands()));
     return success();
   }
 };
 
 /// Conversion pattern specialization for CopyOp. This kicks in when both input
 /// and output permutations are left unspecified or are the identity.
LogicalResult matchAndRewrite(CopyOp op,
     if (outputPerm.hasValue() && !outputPerm->isIdentity())
       return failure();
 
     auto libraryCallName = getLibraryCallSymbolRef<CopyOp>(op, rewriter);
     if (!libraryCallName)
       return failure();
 
     rewriter.replaceOpWithNewOp<mlir::CallOp>(
-        op, libraryCallName.getValue(), ArrayRef<Type>{},
+        op, libraryCallName.getValue(), TypeRange(),
         createTypeCanonicalizedMemRefOperands(rewriter, op.getLoc(),
                                               op.getOperands()));
     return success();
   }
 };
 
 /// Conversion pattern specialization for IndexedGenericOp.
 template <>
LogicalResult matchAndRewrite(IndexedGenericOp op,
     auto numLoops = indexedGenericOp.getNumLoops();
     SmallVector<Value, 4> operands;
     operands.reserve(numLoops + op.getNumOperands());
     for (unsigned i = 0; i < numLoops; ++i)
       operands.push_back(zero);
     for (auto operand : op.getOperands())
       operands.push_back(operand);
     rewriter.replaceOpWithNewOp<mlir::CallOp>(
-        op, libraryCallName.getValue(), ArrayRef<Type>{},
+        op, libraryCallName.getValue(), TypeRange(),
         createTypeCanonicalizedMemRefOperands(rewriter, op.getLoc(), operands));
     return success();
   }
 };
 
 /// A non-conversion rewrite pattern kicks in to convert CopyOp with
 /// permutations into a sequence of TransposeOp and permutation-free CopyOp.
 /// This interplays together with TransposeOpConversion and

mlir/lib/Conversion/OpenMPToLLVM/OpenMPToLLVM.cpp

explicit ParallelOpConversion(MLIRContext *context,
                                 LLVMTypeConverter &typeConverter)
       : ConvertToLLVMPattern(omp::ParallelOp::getOperationName(), context,
                              typeConverter) {}
 
   LogicalResult
   matchAndRewrite(Operation *op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     auto curOp = cast<omp::ParallelOp>(op);
-    auto newOp = rewriter.create<omp::ParallelOp>(
-        curOp.getLoc(), ArrayRef<Type>(), operands, curOp.getAttrs());
+    auto newOp = rewriter.create<omp::ParallelOp>(curOp.getLoc(), TypeRange(),
+                                                  operands, curOp.getAttrs());
     rewriter.inlineRegionBefore(curOp.region(), newOp.region(),
                                 newOp.region().end());
     if (failed(rewriter.convertRegionTypes(&newOp.region(), typeConverter)))
       return failure();
 
     rewriter.eraseOp(op);
     return success();
   }

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

if (!freeFunc) {
                                         /*isVarArg=*/false));
     }
 
     MemRefDescriptor memref(transformed.memref());
     Value casted = rewriter.create<LLVM::BitcastOp>(
         op->getLoc(), getVoidPtrType(),
         memref.allocatedPtr(rewriter, op->getLoc()));
     rewriter.replaceOpWithNewOp<LLVM::CallOp>(
-        op, ArrayRef<Type>(), rewriter.getSymbolRefAttr(freeFunc), casted);
+        op, TypeRange(), rewriter.getSymbolRefAttr(freeFunc), casted);
     return success();
   }
 };
 
 // A `rsqrt` is converted into `1 / sqrt`.
 struct RsqrtOpLowering : public ConvertOpToLLVMPattern<RsqrtOp> {
   using ConvertOpToLLVMPattern<RsqrtOp>::ConvertOpToLLVMPattern;
 
matchAndRewrite(Operation *op, ArrayRef<Value> operands,
     unsigned numArguments = op->getNumOperands();
     auto updatedOperands = llvm::to_vector<4>(operands);
     copyUnrankedDescriptors(rewriter, op->getLoc(), typeConverter,
                             op->getOperands().getTypes(), updatedOperands,
                             /*toDynamic=*/true);
 
     // If ReturnOp has 0 or 1 operand, create it and return immediately.
     if (numArguments == 0) {
-      rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(
-          op, ArrayRef<Type>(), ArrayRef<Value>(), op->getAttrs());
+      rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(op, TypeRange(), ValueRange(),
+                                                  op->getAttrs());
       return success();
     }
     if (numArguments == 1) {
       rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(
-          op, ArrayRef<Type>(), updatedOperands, op->getAttrs());
+          op, TypeRange(), updatedOperands, op->getAttrs());
       return success();
     }
 
     // Otherwise, we need to pack the arguments into an LLVM struct type before
     // returning.
     auto packedType = typeConverter.packFunctionResults(
         llvm::to_vector<4>(op->getOperandTypes()));
 
     Value packed = rewriter.create<LLVM::UndefOp>(op->getLoc(), packedType);
     for (unsigned i = 0; i < numArguments; ++i) {
       packed = rewriter.create<LLVM::InsertValueOp>(
           op->getLoc(), packedType, packed, updatedOperands[i],
           rewriter.getI64ArrayAttr(i));
     }
-    rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(op, ArrayRef<Type>(), packed,
+    rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(op, TypeRange(), packed,
                                                 op->getAttrs());
     return success();
   }
 };
 
 // FIXME: this should be tablegen'ed as well.
 struct BranchOpLowering
     : public OneToOneLLVMTerminatorLowering<BranchOp, LLVM::BrOp> {

mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp

for (int64_t d = 0; d < dim; ++d) {
         emitCall(rewriter, loc, printComma);
     }
     emitCall(rewriter, loc, getPrintClose(op));
   }
 
   // Helper to emit a call.
   static void emitCall(ConversionPatternRewriter &rewriter, Location loc,
                        Operation *ref, ValueRange params = ValueRange()) {
-    rewriter.create<LLVM::CallOp>(loc, ArrayRef<Type>{},
+    rewriter.create<LLVM::CallOp>(loc, TypeRange(),
                                   rewriter.getSymbolRefAttr(ref), params);
   }
 
   // Helper for printer method declaration (first hit) and lookup.
   static Operation *getPrint(Operation *op, StringRef name,
                              ArrayRef<LLVM::LLVMType> params) {
     auto module = op->getParentOfType<ModuleOp>();
     auto func = module.lookupSymbol<LLVM::LLVMFuncOp>(name);

mlir/lib/Dialect/Affine/IR/AffineOps.cpp

LogicalResult AffinePrefetchOp::fold(ArrayRef<Attribute> cstOperands,
   return foldMemRefCast(*this);
 }
 
 //===----------------------------------------------------------------------===//
 // AffineParallelOp
 //===----------------------------------------------------------------------===//
 
 void AffineParallelOp::build(OpBuilder &builder, OperationState &result,
-                             ArrayRef<Type> resultTypes,
+                             TypeRange resultTypes,
                              ArrayRef<AtomicRMWKind> reductions,
                              ArrayRef<int64_t> ranges) {
   SmallVector<AffineExpr, 8> lbExprs(ranges.size(),
                                      builder.getAffineConstantExpr(0));
   auto lbMap = AffineMap::get(0, 0, lbExprs, builder.getContext());
   SmallVector<AffineExpr, 8> ubExprs;
   for (int64_t range : ranges)
     ubExprs.push_back(builder.getAffineConstantExpr(range));
   auto ubMap = AffineMap::get(0, 0, ubExprs, builder.getContext());
   build(builder, result, resultTypes, reductions, lbMap, /*lbArgs=*/{}, ubMap,
         /*ubArgs=*/{});
 }
 
 void AffineParallelOp::build(OpBuilder &builder, OperationState &result,
-                             ArrayRef<Type> resultTypes,
+                             TypeRange resultTypes,
                              ArrayRef<AtomicRMWKind> reductions,
                              AffineMap lbMap, ValueRange lbArgs,
                              AffineMap ubMap, ValueRange ubArgs) {
   auto numDims = lbMap.getNumResults();
   // Verify that the dimensionality of both maps are the same.
   assert(numDims == ubMap.getNumResults() &&
          "num dims and num results mismatch");
   // Make default step sizes of 1.
   SmallVector<int64_t, 8> steps(numDims, 1);
   build(builder, result, resultTypes, reductions, lbMap, lbArgs, ubMap, ubArgs,
         steps);
 }
 
 void AffineParallelOp::build(OpBuilder &builder, OperationState &result,
-                             ArrayRef<Type> resultTypes,
+                             TypeRange resultTypes,
                              ArrayRef<AtomicRMWKind> reductions,
                              AffineMap lbMap, ValueRange lbArgs,
                              AffineMap ubMap, ValueRange ubArgs,
                              ArrayRef<int64_t> steps) {
   auto numDims = lbMap.getNumResults();
   // Verify that the dimensionality of the maps matches the number of steps.
   assert(numDims == ubMap.getNumResults() &&
          "num dims and num results mismatch");

mlir/lib/Dialect/GPU/IR/GPUDialect.cpp

 BlockArgument GPUFuncOp::addPrivateAttribution(Type type) {
   // Buffers on the private memory always come after buffers on the workgroup
   // memory.
   return getBody().addArgument(type);
 }
 
 void GPUFuncOp::build(OpBuilder &builder, OperationState &result,
                       StringRef name, FunctionType type,
-                      ArrayRef<Type> workgroupAttributions,
-                      ArrayRef<Type> privateAttributions,
+                      TypeRange workgroupAttributions,
+                      TypeRange privateAttributions,
                       ArrayRef<NamedAttribute> attrs) {
   result.addAttribute(SymbolTable::getSymbolAttrName(),
                       builder.getStringAttr(name));
   result.addAttribute(getTypeAttrName(), TypeAttr::get(type));
   result.addAttribute(getNumWorkgroupAttributionsAttrName(),
                       builder.getI64IntegerAttr(workgroupAttributions.size()));
   result.addAttributes(attrs);
   Region *body = result.addRegion();

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

 //===----------------------------------------------------------------------===//
 // Builder, printer and parser for LLVM::StoreOp.
 //===----------------------------------------------------------------------===//
 
 void StoreOp::build(OpBuilder &builder, OperationState &result, Value value,
                     Value addr, unsigned alignment, bool isVolatile,
                     bool isNonTemporal) {
   result.addOperands({value, addr});
-  result.addTypes(ArrayRef<Type>{});
+  result.addTypes({});
   if (isVolatile)
     result.addAttribute(kVolatileAttrName, builder.getUnitAttr());
   if (isNonTemporal)
     result.addAttribute(kNonTemporalAttrName, builder.getUnitAttr());
   if (alignment != 0)
     result.addAttribute("alignment", builder.getI64IntegerAttr(alignment));
 }
 
auto global = moduleBuilder.create<LLVM::GlobalOp>(
       builder.getStringAttr(value));
 
   // Get the pointer to the first character in the global string.
   Value globalPtr = builder.create<LLVM::AddressOfOp>(loc, global);
   Value cst0 = builder.create<LLVM::ConstantOp>(
       loc, LLVM::LLVMType::getInt64Ty(ctx),
       builder.getIntegerAttr(builder.getIndexType(), 0));
   return builder.create<LLVM::GEPOp>(loc, LLVM::LLVMType::getInt8PtrTy(ctx),
-                                     globalPtr, ArrayRef<Value>({cst0, cst0}));
+                                     globalPtr, ValueRange{cst0, cst0});
 }
 
 bool mlir::LLVM::satisfiesLLVMModule(Operation *op) {
   return op->hasTrait<OpTrait::SymbolTable>() &&
          op->hasTrait<OpTrait::IsIsolatedFromAbove>();
 }

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

 // For such operations that do not correspond to library calls (i.e. defined in
 // LinalgOps.td), we define an overloaded `print` function and a
 // parse`className` function.
 
 //===----------------------------------------------------------------------===//
 // GenericOps
 //===----------------------------------------------------------------------===//
 void GenericOp::build(
     OpBuilder &builder, OperationState &result,
-    ArrayRef<Type> resultTensorTypes, ValueRange inputs,
+    TypeRange resultTensorTypes, ValueRange inputs,
     ValueRange outputBuffers, ValueRange initTensors,
     ArrayRef<AffineMap> indexingMaps, ArrayRef<StringRef> iteratorTypes,
     StringRef doc, StringRef libraryCall, IntegerAttr symbolSource,
     function_ref<void(OpBuilder &, Location, ValueRange)> bodyBuild) {
   build(builder, result, resultTensorTypes, inputs, outputBuffers, initTensors,
         builder.getAffineMapArrayAttr(indexingMaps),
         builder.getStrArrayAttr(iteratorTypes),
         doc.empty() ? StringAttr() : builder.getStringAttr(doc),

 }
 
 void GenericOp::build(
     OpBuilder &builder, OperationState &result, ValueRange inputs,
     ValueRange outputBuffers, ArrayRef<AffineMap> indexingMaps,
     ArrayRef<StringRef> iteratorTypes, StringRef doc, StringRef libraryCall,
     IntegerAttr symbolSource,
     function_ref<void(OpBuilder &, Location, ValueRange)> bodyBuild) {
-  build(builder, result, ArrayRef<Type>{}, inputs, outputBuffers, ValueRange{},
+  build(builder, result, TypeRange{}, inputs, outputBuffers, ValueRange{},
         indexingMaps, iteratorTypes, doc, libraryCall, symbolSource, bodyBuild);
 }
 
 void GenericOp::build(
     OpBuilder &builder, OperationState &result, ValueRange inputs,
     ValueRange outputBuffers, ArrayRef<AffineMap> indexingMaps,
     ArrayRef<StringRef> iteratorTypes,
     function_ref<void(OpBuilder &, Location, ValueRange)> bodyBuild) {
   build(builder, result, inputs, outputBuffers, indexingMaps, iteratorTypes,
         /*doc=*/"",
         /*libraryCall=*/"",
         /*symbolSource=*/IntegerAttr(), bodyBuild);
 }
 
 void GenericOp::build(
     OpBuilder &builder, OperationState &result,
-    ArrayRef<Type> resultTensorTypes, ValueRange inputs,
+    TypeRange resultTensorTypes, ValueRange inputs,
     ValueRange outputBuffers, ValueRange initTensors,
     ArrayRef<AffineMap> indexingMaps, ArrayRef<StringRef> iteratorTypes,
     function_ref<void(OpBuilder &, Location, ValueRange)> bodyBuild) {
   build(builder, result, resultTensorTypes, inputs, outputBuffers, initTensors,
         indexingMaps, iteratorTypes,
         /*doc=*/"",
         /*libraryCall=*/"",
         /*symbolSource=*/IntegerAttr(), bodyBuild);
 }
 
 void IndexedGenericOp::build(
     OpBuilder &builder, OperationState &result,
-    ArrayRef<Type> resultTensorTypes, ValueRange inputs,
+    TypeRange resultTensorTypes, ValueRange inputs,
     ValueRange outputBuffers, ValueRange initTensors,
     ArrayRef<AffineMap> indexingMaps, ArrayRef<StringRef> iteratorTypes,
     StringRef doc, StringRef libraryCall, IntegerAttr symbolSource,
     function_ref<void(OpBuilder &, Location, ValueRange, ValueRange)>
         bodyBuild) {
   build(builder, result, resultTensorTypes, inputs, outputBuffers, initTensors,
         builder.getAffineMapArrayAttr(indexingMaps),
         builder.getStrArrayAttr(iteratorTypes),

 
 void IndexedGenericOp::build(
     OpBuilder &builder, OperationState &result, ValueRange inputs,
     ValueRange outputBuffers, ArrayRef<AffineMap> indexingMaps,
     ArrayRef<StringRef> iteratorTypes, StringRef doc, StringRef libraryCall,
     IntegerAttr symbolSource,
     function_ref<void(OpBuilder &, Location, ValueRange, ValueRange)>
         bodyBuild) {
-  build(builder, result, ArrayRef<Type>{}, inputs, outputBuffers, ValueRange{},
+  build(builder, result, TypeRange{}, inputs, outputBuffers, ValueRange{},
         indexingMaps, iteratorTypes, doc, libraryCall, symbolSource, bodyBuild);
 }
 
 void IndexedGenericOp::build(
     OpBuilder &builder, OperationState &result, ValueRange inputs,
     ValueRange outputBuffers, ArrayRef<AffineMap> indexingMaps,
     ArrayRef<StringRef> iteratorTypes,
     function_ref<void(OpBuilder &, Location, ValueRange, ValueRange)>
         bodyBuild) {
   build(builder, result, inputs, outputBuffers, indexingMaps, iteratorTypes,
         /*doc=*/"",
         /*libraryCall=*/"",
         /*symbolSource=*/IntegerAttr(), bodyBuild);
 }
 
 void IndexedGenericOp::build(
     OpBuilder &builder, OperationState &result,
-    ArrayRef<Type> resultTensorTypes, ValueRange inputs,
+    TypeRange resultTensorTypes, ValueRange inputs,
     ValueRange outputBuffers, ValueRange initTensors,
     ArrayRef<AffineMap> indexingMaps, ArrayRef<StringRef> iteratorTypes,
     function_ref<void(OpBuilder &, Location, ValueRange, ValueRange)>
         bodyBuild) {
   build(builder, result, resultTensorTypes, inputs, outputBuffers, initTensors,
         indexingMaps, iteratorTypes,
         /*doc=*/"",
         /*libraryCall=*/"",

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

 //===----------------------------------------------------------------------===//
 
 namespace {
 struct FoldToCallOpPattern : public OpRewritePattern<FoldToCallOp> {
   using OpRewritePattern<FoldToCallOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(FoldToCallOp op,
                                 PatternRewriter &rewriter) const override {
-    rewriter.replaceOpWithNewOp<CallOp>(op, ArrayRef<Type>(), op.calleeAttr(),
+    rewriter.replaceOpWithNewOp<CallOp>(op, TypeRange(), op.calleeAttr(),
                                         ValueRange());
     return success();
   }
 };
 } // end anonymous namespace
 
 void FoldToCallOp::getCanonicalizationPatterns(
     OwningRewritePatternList &results, MLIRContext *context) {

mlir/unittests/TableGen/OpBuildGen.cpp

void verifyOp(OpTy &&concreteOp, std::vector<Type> resultTypes,
     concreteOp.erase();
   }
 
   // Helper method to test ops with inferred result types and single variadic
   // input.
   template <typename OpTy>
   void testSingleVariadicInputInferredType() {
     // Test separate arg, separate param build method.
-    auto op = builder.create<OpTy>(loc, i32Ty, ArrayRef<Value>{cstI32, cstI32});
+    auto op = builder.create<OpTy>(loc, i32Ty, ValueRange{cstI32, cstI32});
     verifyOp(std::move(op), {i32Ty}, {cstI32, cstI32}, noAttrs);
 
     // Test collective params build method.
-    op = builder.create<OpTy>(loc, ArrayRef<Type>{i32Ty},
-                              ArrayRef<Value>{cstI32, cstI32});
+    op =
+        builder.create<OpTy>(loc, TypeRange{i32Ty}, ValueRange{cstI32, cstI32});
     verifyOp(std::move(op), {i32Ty}, {cstI32, cstI32}, noAttrs);
 
     // Test build method with no result types, default value of attributes.
-    op = builder.create<OpTy>(loc, ArrayRef<Value>{cstI32, cstI32});
+    op = builder.create<OpTy>(loc, ValueRange{cstI32, cstI32});
     verifyOp(std::move(op), {i32Ty}, {cstI32, cstI32}, noAttrs);
 
     // Test build method with no result types and supplied attributes.
-    op = builder.create<OpTy>(loc, ArrayRef<Value>{cstI32, cstI32}, attrs);
+    op = builder.create<OpTy>(loc, ValueRange{cstI32, cstI32}, attrs);
     verifyOp(std::move(op), {i32Ty}, {cstI32, cstI32}, attrs);
   }
 
 protected:
   MLIRContext &ctx;
   OpBuilder builder;
   Location loc;
   Type i32Ty;
   Type f32Ty;
   TableGenConstant cstI32;
   TableGenConstant cstF32;
 
   ArrayRef<NamedAttribute> noAttrs;
   std::vector<NamedAttribute> attrStorage;
   ArrayRef<NamedAttribute> attrs;
 };
 
 /// Test basic build methods.
 TEST_F(OpBuildGenTest, BasicBuildMethods) {
   // Test separate args, separate results build method.
   auto op = builder.create<TableGenBuildOp0>(loc, i32Ty, cstI32);
   verifyOp(op, {i32Ty}, {cstI32}, noAttrs);
 
   // Test separate args, collective results build method.
-  op = builder.create<TableGenBuildOp0>(loc, ArrayRef<Type>{i32Ty}, cstI32);
+  op = builder.create<TableGenBuildOp0>(loc, TypeRange{i32Ty}, cstI32);
   verifyOp(op, {i32Ty}, {cstI32}, noAttrs);
 
   // Test collective args, collective params build method.
-  op = builder.create<TableGenBuildOp0>(loc, ArrayRef<Type>{i32Ty},
-                                        ArrayRef<Value>{cstI32});
+  op = builder.create<TableGenBuildOp0>(loc, TypeRange{i32Ty},
+                                        ValueRange{cstI32});
   verifyOp(op, {i32Ty}, {cstI32}, noAttrs);
 
   // Test collective args, collective results, non-empty attributes
-  op = builder.create<TableGenBuildOp0>(loc, ArrayRef<Type>{i32Ty},
-                                        ArrayRef<Value>{cstI32}, attrs);
+  op = builder.create<TableGenBuildOp0>(loc, TypeRange{i32Ty},
+                                        ValueRange{cstI32}, attrs);
   verifyOp(op, {i32Ty}, {cstI32}, attrs);
 }
 
 /// The following 3 tests exercise build methods generated for operations
 /// with a combination of:
 ///
 /// single variadic arg x
 /// {single variadic result, non-variadic result, multiple variadic results}
 ///
 /// Specifically to test that that ODS framework does not generate ambiguous
 /// build() methods that fail to compile.
 
 /// Test build methods for an Op with a single varadic arg and a single
 /// variadic result.
 TEST_F(OpBuildGenTest, BuildMethodsSingleVariadicArgAndResult) {
   // Test collective args, collective results method, building a unary op.
-  auto op = builder.create<TableGenBuildOp1>(loc, ArrayRef<Type>{i32Ty},
-                                             ArrayRef<Value>{cstI32});
+  auto op = builder.create<TableGenBuildOp1>(loc, TypeRange{i32Ty},
+                                             ValueRange{cstI32});
   verifyOp(std::move(op), {i32Ty}, {cstI32}, noAttrs);
 
   // Test collective args, collective results method, building a unary op with
   // named attributes.
-  op = builder.create<TableGenBuildOp1>(loc, ArrayRef<Type>{i32Ty},
-                                        ArrayRef<Value>{cstI32}, attrs);
+  op = builder.create<TableGenBuildOp1>(loc, TypeRange{i32Ty},
+                                        ValueRange{cstI32}, attrs);
   verifyOp(std::move(op), {i32Ty}, {cstI32}, attrs);
 
   // Test collective args, collective results method, building a binary op.
-  op = builder.create<TableGenBuildOp1>(loc, ArrayRef<Type>{i32Ty, f32Ty},
-                                        ArrayRef<Value>{cstI32, cstF32});
+  op = builder.create<TableGenBuildOp1>(loc, TypeRange{i32Ty, f32Ty},
+                                        ValueRange{cstI32, cstF32});
   verifyOp(std::move(op), {i32Ty, f32Ty}, {cstI32, cstF32}, noAttrs);
 
   // Test collective args, collective results method, building a binary op with
   // named attributes.
-  op = builder.create<TableGenBuildOp1>(loc, ArrayRef<Type>{i32Ty, f32Ty},
-                                        ArrayRef<Value>{cstI32, cstF32}, attrs);
+  op = builder.create<TableGenBuildOp1>(loc, TypeRange{i32Ty, f32Ty},
+                                        ValueRange{cstI32, cstF32}, attrs);
   verifyOp(std::move(op), {i32Ty, f32Ty}, {cstI32, cstF32}, attrs);
 }
 
 /// Test build methods for an Op with a single varadic arg and a non-variadic
 /// result.
 TEST_F(OpBuildGenTest, BuildMethodsSingleVariadicArgNonVariadicResults) {
   // Test separate arg, separate param build method.
-  auto op =
-      builder.create<TableGenBuildOp1>(loc, i32Ty, ArrayRef<Value>{cstI32});
+  auto op = builder.create<TableGenBuildOp1>(loc, i32Ty, ValueRange{cstI32});
   verifyOp(std::move(op), {i32Ty}, {cstI32}, noAttrs);
 
   // Test collective params build method, no attributes.
-  op = builder.create<TableGenBuildOp1>(loc, ArrayRef<Type>{i32Ty},
-                                        ArrayRef<Value>{cstI32});
+  op = builder.create<TableGenBuildOp1>(loc, TypeRange{i32Ty},
+                                        ValueRange{cstI32});
   verifyOp(std::move(op), {i32Ty}, {cstI32}, noAttrs);
 
   // Test collective params build method no attributes, 2 inputs.
-  op = builder.create<TableGenBuildOp1>(loc, ArrayRef<Type>{i32Ty},
-                                        ArrayRef<Value>{cstI32, cstF32});
+  op = builder.create<TableGenBuildOp1>(loc, TypeRange{i32Ty},
+                                        ValueRange{cstI32, cstF32});
   verifyOp(std::move(op), {i32Ty}, {cstI32, cstF32}, noAttrs);
 
   // Test collective params build method, non-empty attributes.
-  op = builder.create<TableGenBuildOp1>(loc, ArrayRef<Type>{i32Ty},
-                                        ArrayRef<Value>{cstI32, cstF32}, attrs);
+  op = builder.create<TableGenBuildOp1>(loc, TypeRange{i32Ty},
+                                        ValueRange{cstI32, cstF32}, attrs);
   verifyOp(std::move(op), {i32Ty}, {cstI32, cstF32}, attrs);
 }
 
 /// Test build methods for an Op with a single varadic arg and multiple variadic
 /// result.
 TEST_F(OpBuildGenTest,
        BuildMethodsSingleVariadicArgAndMultipleVariadicResults) {
   // Test separate arg, separate param build method.
-  auto op = builder.create<TableGenBuildOp3>(loc, ArrayRef<Type>{i32Ty},
-                                             ArrayRef<Type>{f32Ty},
-                                             ArrayRef<Value>{cstI32});
+  auto op = builder.create<TableGenBuildOp3>(
+      loc, TypeRange{i32Ty}, TypeRange{f32Ty}, ValueRange{cstI32});
   verifyOp(std::move(op), {i32Ty, f32Ty}, {cstI32}, noAttrs);
 
   // Test collective params build method, no attributes.
-  op = builder.create<TableGenBuildOp3>(loc, ArrayRef<Type>{i32Ty, f32Ty},
-                                        ArrayRef<Value>{cstI32});
+  op = builder.create<TableGenBuildOp3>(loc, TypeRange{i32Ty, f32Ty},
+                                        ValueRange{cstI32});
   verifyOp(std::move(op), {i32Ty, f32Ty}, {cstI32}, noAttrs);
 
   // Test collective params build method, with attributes.
-  op = builder.create<TableGenBuildOp3>(loc, ArrayRef<Type>{i32Ty, f32Ty},
-                                        ArrayRef<Value>{cstI32}, attrs);
+  op = builder.create<TableGenBuildOp3>(loc, TypeRange{i32Ty, f32Ty},
+                                        ValueRange{cstI32}, attrs);
   verifyOp(std::move(op), {i32Ty, f32Ty}, {cstI32}, attrs);
 }
 
 // The next 2 tests test supression of ambiguous build methods for ops that
 // have a single variadic input, and single non-variadic result, and which
 // support the SameOperandsAndResultType trait and and optionally the
 // InferOpTypeInterface interface. For such ops, the ODS framework generates
 // build methods with no result types as they are inferred from the input types.