diff --git a/mlir/examples/toy/Ch6/mlir/LowerToLLVM.cpp b/mlir/examples/toy/Ch6/mlir/LowerToLLVM.cpp
--- a/mlir/examples/toy/Ch6/mlir/LowerToLLVM.cpp
+++ b/mlir/examples/toy/Ch6/mlir/LowerToLLVM.cpp
@@ -153,7 +153,7 @@
         builder.getIntegerAttr(builder.getIndexType(), 0));
     return builder.create<LLVM::GEPOp>(
         loc, LLVM::LLVMType::getInt8PtrTy(llvmDialect), globalPtr,
-        ArrayRef<Value>({cst0, cst0}));
+        {cst0, cst0});
   }
 };
 } // end anonymous namespace
diff --git a/mlir/examples/toy/Ch7/mlir/LowerToLLVM.cpp b/mlir/examples/toy/Ch7/mlir/LowerToLLVM.cpp
--- a/mlir/examples/toy/Ch7/mlir/LowerToLLVM.cpp
+++ b/mlir/examples/toy/Ch7/mlir/LowerToLLVM.cpp
@@ -153,7 +153,7 @@
         builder.getIntegerAttr(builder.getIndexType(), 0));
     return builder.create<LLVM::GEPOp>(
         loc, LLVM::LLVMType::getInt8PtrTy(llvmDialect), globalPtr,
-        ArrayRef<Value>({cst0, cst0}));
+        {cst0, cst0});
   }
 };
 } // end anonymous namespace
diff --git a/mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td b/mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td
--- a/mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td
+++ b/mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td
@@ -307,9 +307,8 @@
     "unsigned alignment = 0",
     [{
       if (alignment == 0)
-        return build(b, result, ArrayRef<Type>{}, value, addr, IntegerAttr());
-      build(b, result, ArrayRef<Type>{}, value, addr, 
-            b.getI64IntegerAttr(alignment));
+        return build(b, result, {}, value, addr, IntegerAttr());
+      build(b, result, {}, value, addr, b.getI64IntegerAttr(alignment));
     }]
   >];
   let parser = [{ return parseStoreOp(parser, result); }];
@@ -389,7 +388,7 @@
                              Variadic<LLVM_Type>)>,
                   Results<(outs Variadic<LLVM_Type>)> {
   let builders = [OpBuilder<
-    "OpBuilder &builder, OperationState &result, LLVMFuncOp func,"
+    "OpBuilder &builder, OperationState &result, LLVMFuncOp func, "
     "ValueRange operands, ArrayRef<NamedAttribute> attributes = {}",
     [{
       LLVMType resultType = func.getType().getFunctionResultType();
diff --git a/mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOpsInterface.td b/mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOpsInterface.td
--- a/mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOpsInterface.td
+++ b/mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOpsInterface.td
@@ -188,7 +188,7 @@
       (ins "OpBuilder &":$builder, "Location":$loc,
            "ValueRange":$operands,
            "ArrayRef<NamedAttribute>":$attributes), [{
-        return builder.create<ConcreteOp>(loc, ArrayRef<Type>{}, operands,
+        return builder.create<ConcreteOp>(loc, {}, operands,
                                           attributes);
       }]
     >,
diff --git a/mlir/include/mlir/Dialect/StandardOps/IR/Ops.td b/mlir/include/mlir/Dialect/StandardOps/IR/Ops.td
--- a/mlir/include/mlir/Dialect/StandardOps/IR/Ops.td
+++ b/mlir/include/mlir/Dialect/StandardOps/IR/Ops.td
@@ -677,19 +677,19 @@
   let results = (outs Variadic<AnyType>);
 
   let builders = [OpBuilder<
-    "OpBuilder &builder, OperationState &result, FuncOp callee,"
+    "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,"
+    "OpBuilder &builder, OperationState &result, SymbolRefAttr callee, "
     "ArrayRef<Type> results, ValueRange operands = {}", [{
       result.addOperands(operands);
       result.addAttribute("callee", callee);
       result.addTypes(results);
   }]>, OpBuilder<
-    "OpBuilder &builder, OperationState &result, StringRef callee,"
+    "OpBuilder &builder, OperationState &result, StringRef callee, "
     "ArrayRef<Type> results, ValueRange operands = {}", [{
       build(builder, result, builder.getSymbolRefAttr(callee), results,
             operands);
diff --git a/mlir/include/mlir/IR/Builders.h b/mlir/include/mlir/IR/Builders.h
--- a/mlir/include/mlir/IR/Builders.h
+++ b/mlir/include/mlir/IR/Builders.h
@@ -13,6 +13,128 @@
 
 namespace mlir {
 
+namespace detail {
+
+// Provides specializations for Derived::createImpl template member function.
+template <typename Derived, typename... PrefixArgs>
+class CreateSpecializations {
+public:
+  using Types = ArrayRef<Type>;
+  using Values = ArrayRef<Value>;
+
+  // Basic
+  template <typename OpTy, typename... Args>
+  auto create(PrefixArgs... prefixArgs, Args &&... args) {
+    return this->derived().template createImpl<OpTy>(
+        std::forward<PrefixArgs>(prefixArgs)..., std::forward<Args>(args)...);
+  }
+
+  template <typename OpTy, typename... Args>
+  auto create(PrefixArgs... prefixArgs, Types resultTypes, Args &&... args) {
+    return this->derived().template createImpl<OpTy>(
+        std::forward<PrefixArgs>(prefixArgs)..., resultTypes,
+        std::forward<Args>(args)...);
+  }
+
+  template <typename OpTy, typename... Args>
+  auto create(PrefixArgs... prefixArgs, Types resultTypes, Values operands,
+              Args &&... args) {
+    return this->derived().template createImpl<OpTy>(
+        std::forward<PrefixArgs>(prefixArgs)..., resultTypes, operands,
+        std::forward<Args>(args)...);
+  }
+
+  template <typename OpTy, typename... Args>
+  auto create(PrefixArgs... prefixArgs, Type resultType, Value arg0,
+              Values rest, Args &&... args) {
+    return this->derived().template createImpl<OpTy>(
+        std::forward<PrefixArgs>(prefixArgs)..., resultType, arg0, rest,
+        std::forward<Args>(args)...);
+  }
+
+  template <typename OpTy, typename... Args>
+  auto create(PrefixArgs... prefixArgs, FlatSymbolRefAttr sym,
+              Types resultTypes, Values operands, Args &&... args) {
+    return this->derived().template createImpl<OpTy>(
+        std::forward<PrefixArgs>(prefixArgs)..., sym, resultTypes, operands,
+        std::forward<Args>(args)...);
+  }
+
+  template <typename OpTy, typename... Args>
+  auto create(PrefixArgs... prefixArgs, StringRef sym, Types resultTypes,
+              Values operands, Args &&... args) {
+    return this->derived().template createImpl<OpTy>(
+        std::forward<PrefixArgs>(prefixArgs)..., sym, resultTypes, operands,
+        std::forward<Args>(args)...);
+  }
+
+private:
+  Derived &derived() { return *static_cast<Derived *>(this); }
+};
+
+template <typename Derived, typename... PrefixArgs>
+class ReplaceOpWithNewOpSpecializations {
+public:
+  using Types = ArrayRef<Type>;
+  using Values = ArrayRef<Value>;
+
+  // Basic
+  template <typename OpTy, typename... Args>
+  auto replaceOpWithNewOp(PrefixArgs... prefixArgs, Args &&... args) {
+    return this->derived().template replaceOpWithNewOpImpl<OpTy>(
+        std::forward<PrefixArgs>(prefixArgs)..., std::forward<Args>(args)...);
+  }
+
+  template <typename OpTy, typename... Args>
+  auto replaceOpWithNewOp(PrefixArgs... prefixArgs, Types resultTypes,
+                          Args &&... args) {
+    return this->derived().template replaceOpWithNewOpImpl<OpTy>(
+        std::forward<PrefixArgs>(prefixArgs)..., resultTypes,
+        std::forward<Args>(args)...);
+  }
+
+  template <typename OpTy, typename... Args>
+  auto replaceOpWithNewOp(PrefixArgs... prefixArgs, Types resultTypes,
+                          Values operands, Args &&... args) {
+    return this->derived().template replaceOpWithNewOpImpl<OpTy>(
+        std::forward<PrefixArgs>(prefixArgs)..., resultTypes, operands,
+        std::forward<Args>(args)...);
+  }
+
+  template <typename OpTy, typename... Args>
+  auto replaceOpWithNewOp(PrefixArgs... prefixArgs, Type resultType, Value arg0,
+                          Values rest, Args &&... args) {
+    return this->derived().template replaceOpWithNewOpImpl<OpTy>(
+        std::forward<PrefixArgs>(prefixArgs)..., resultType, arg0, rest,
+        std::forward<Args>(args)...);
+  }
+
+  template <typename OpTy, typename... Args>
+  auto replaceOpWithNewOp(PrefixArgs... prefixArgs, FlatSymbolRefAttr sym,
+                          Types resultTypes, Values operands, Args &&... args) {
+    return this->derived().template replaceOpWithNewOpImpl<OpTy>(
+        std::forward<PrefixArgs>(prefixArgs)..., sym, resultTypes, operands,
+        std::forward<Args>(args)...);
+  }
+
+  template <typename OpTy, typename... Args>
+  auto replaceOpWithNewOp(PrefixArgs... prefixArgs, StringRef sym,
+                          Types resultTypes, Values operands, Args &&... args) {
+    return this->derived().template replaceOpWithNewOpImpl<OpTy>(
+        std::forward<PrefixArgs>(prefixArgs)..., sym, resultTypes, operands,
+        std::forward<Args>(args)...);
+  }
+
+private:
+  Derived &derived() { return *static_cast<Derived *>(this); }
+};
+
+} // namespace detail
+
+} // namespace mlir
+
+namespace mlir {
+
 class AffineExpr;
 class BlockAndValueMapping;
 class ModuleOp;
@@ -174,7 +296,8 @@
 
 /// This class helps build Operations. Operations that are created are
 /// automatically inserted at an insertion point. The builder is copyable.
-class OpBuilder : public Builder {
+class OpBuilder : public Builder,
+                  public detail::CreateSpecializations<OpBuilder, Location> {
 public:
   struct Listener;
 
@@ -371,21 +494,6 @@
   /// Creates an operation given the fields represented as an OperationState.
   Operation *createOperation(const OperationState &state);
 
-  /// Create an operation of specific op type at the current insertion point.
-  template <typename OpTy, typename... Args>
-  OpTy create(Location location, Args &&... args) {
-    OperationState state(location, OpTy::getOperationName());
-    if (!state.name.getAbstractOperation())
-      llvm::report_fatal_error("Building op `" +
-                               state.name.getStringRef().str() +
-                               "` but it isn't registered in this MLIRContext");
-    OpTy::build(*this, state, std::forward<Args>(args)...);
-    auto *op = createOperation(state);
-    auto result = dyn_cast<OpTy>(op);
-    assert(result && "builder didn't return the right type");
-    return result;
-  }
-
   /// Create an operation of specific op type at the current insertion point,
   /// and immediately try to fold it. This functions populates 'results' with
   /// the results after folding the operation.
@@ -469,6 +577,22 @@
   Block::iterator insertPoint;
   /// The optional listener for events of this builder.
   Listener *listener;
+
+public:
+  /// Create an operation of specific op type at the current insertion point.
+  template <typename OpTy, typename... Args>
+  OpTy createImpl(Location location, Args &&... args) {
+    OperationState state(location, OpTy::getOperationName());
+    if (!state.name.getAbstractOperation())
+      llvm::report_fatal_error("Building op `" +
+                               state.name.getStringRef().str() +
+                               "` but it isn't registered in this MLIRContext");
+    OpTy::build(*this, state, std::forward<Args>(args)...);
+    auto *op = createOperation(state);
+    auto result = dyn_cast<OpTy>(op);
+    assert(result && "builder didn't return the right type");
+    return result;
+  }
 };
 
 } // namespace mlir
diff --git a/mlir/include/mlir/IR/Operation.h b/mlir/include/mlir/IR/Operation.h
--- a/mlir/include/mlir/IR/Operation.h
+++ b/mlir/include/mlir/IR/Operation.h
@@ -113,7 +113,7 @@
   /// or nullptr if this is a top-level operation.
   Operation *getParentOp();
 
-  /// Return the closest surrounding parent operation that is of type 'OpTy'.
+  /// Return the closest surrounding parent operation that is of type `OpTy`.
   template <typename OpTy> OpTy getParentOfType() {
     auto *op = this;
     while ((op = op->getParentOp()))
diff --git a/mlir/include/mlir/IR/PatternMatch.h b/mlir/include/mlir/IR/PatternMatch.h
--- a/mlir/include/mlir/IR/PatternMatch.h
+++ b/mlir/include/mlir/IR/PatternMatch.h
@@ -245,19 +245,14 @@
 ///     to apply patterns and observe their effects (e.g. to keep worklists or
 ///     other data structures up to date).
 ///
-class PatternRewriter : public OpBuilder, public OpBuilder::Listener {
+class PatternRewriter
+    : public OpBuilder,
+      public OpBuilder::Listener,
+      public detail::CreateSpecializations<PatternRewriter, Location>,
+      public detail::ReplaceOpWithNewOpSpecializations<PatternRewriter,
+                                                       Operation *> {
 public:
-  /// Create operation of specific op type at the current insertion point
-  /// without verifying to see if it is valid.
-  template <typename OpTy, typename... Args>
-  OpTy create(Location location, Args... args) {
-    OperationState state(location, OpTy::getOperationName());
-    OpTy::build(*this, state, args...);
-    auto *op = createOperation(state);
-    auto result = dyn_cast<OpTy>(op);
-    assert(result && "Builder didn't return the right type");
-    return result;
-  }
+  using detail::CreateSpecializations<PatternRewriter, Location>::create;
 
   /// Creates an operation of specific op type at the current insertion point.
   /// If the result is an invalid op (the verifier hook fails), emit an error
@@ -305,14 +300,6 @@
   /// values.
   virtual void replaceOp(Operation *op, ValueRange newValues);
 
-  /// Replaces the result op with a new op that is created without verification.
-  /// The result values of the two ops must be the same types.
-  template <typename OpTy, typename... Args>
-  void replaceOpWithNewOp(Operation *op, Args &&... args) {
-    auto newOp = create<OpTy>(op->getLoc(), std::forward<Args>(args)...);
-    replaceOpWithResultsOfAnotherOp(op, newOp.getOperation());
-  }
-
   /// This method erases an operation that is known to have no uses.
   virtual void eraseOp(Operation *op);
 
@@ -412,6 +399,27 @@
   /// 'op' and 'newOp' are known to have the same number of results, replace the
   /// uses of op with uses of newOp.
   void replaceOpWithResultsOfAnotherOp(Operation *op, Operation *newOp);
+
+public:
+  /// Create operation of specific op type at the current insertion point
+  /// without verifying to see if it is valid.
+  template <typename OpTy, typename... Args>
+  OpTy createImpl(Location location, Args... args) {
+    OperationState state(location, OpTy::getOperationName());
+    OpTy::build(*this, state, args...);
+    auto *op = createOperation(state);
+    auto result = dyn_cast<OpTy>(op);
+    assert(result && "Builder didn't return the right type");
+    return result;
+  }
+
+  /// Replaces the result op with a new op that is created without verification.
+  /// The result values of the two ops must be the same types.
+  template <typename OpTy, typename... Args>
+  void replaceOpWithNewOpImpl(Operation *op, Args &&... args) {
+    auto newOp = create<OpTy>(op->getLoc(), std::forward<Args>(args)...);
+    replaceOpWithResultsOfAnotherOp(op, newOp.getOperation());
+  }
 };
 
 //===----------------------------------------------------------------------===//
diff --git a/mlir/lib/Conversion/GPUCommon/ConvertLaunchFuncToRuntimeCalls.cpp b/mlir/lib/Conversion/GPUCommon/ConvertLaunchFuncToRuntimeCalls.cpp
--- a/mlir/lib/Conversion/GPUCommon/ConvertLaunchFuncToRuntimeCalls.cpp
+++ b/mlir/lib/Conversion/GPUCommon/ConvertLaunchFuncToRuntimeCalls.cpp
@@ -265,8 +265,8 @@
 
   auto index = builder.create<LLVM::ConstantOp>(loc, getInt32Type(),
                                                 builder.getI32IntegerAttr(pos));
-  auto gep = builder.create<LLVM::GEPOp>(loc, getPointerPointerType(), list,
-                                         ArrayRef<Value>{index});
+  auto gep =
+      builder.create<LLVM::GEPOp>(loc, getPointerPointerType(), list, {index});
   builder.create<LLVM::StoreOp>(loc, casted, gep);
 }
 
@@ -408,9 +408,10 @@
   auto gpuModule = allocatePointer(builder, loc);
   auto gpuModuleLoad =
       getOperation().lookupSymbol<LLVM::LLVMFuncOp>(kGpuModuleLoadName);
-  builder.create<LLVM::CallOp>(loc, ArrayRef<Type>{getGpuRuntimeResultType()},
+  builder.create<LLVM::CallOp>(loc, {getGpuRuntimeResultType()},
                                builder.getSymbolRefAttr(gpuModuleLoad),
                                ArrayRef<Value>{gpuModule, data});
+  TypeRange{getGpuRuntimeResultType()};
   // Get the function from the module. The name corresponds to the name of
   // the kernel function.
   auto gpuOwningModuleRef =
@@ -421,15 +422,15 @@
   auto gpuModuleGetFunction =
       getOperation().lookupSymbol<LLVM::LLVMFuncOp>(kGpuModuleGetFunctionName);
   builder.create<LLVM::CallOp>(
-      loc, ArrayRef<Type>{getGpuRuntimeResultType()},
+      loc, {getGpuRuntimeResultType()},
       builder.getSymbolRefAttr(gpuModuleGetFunction),
       ArrayRef<Value>{gpuFunction, gpuOwningModuleRef, kernelName});
   // Grab the global stream needed for execution.
   auto gpuGetStreamHelper =
       getOperation().lookupSymbol<LLVM::LLVMFuncOp>(kGpuGetStreamHelperName);
   auto gpuStream = builder.create<LLVM::CallOp>(
-      loc, ArrayRef<Type>{getPointerType()},
-      builder.getSymbolRefAttr(gpuGetStreamHelper), ArrayRef<Value>{});
+      loc, {getPointerType()}, builder.getSymbolRefAttr(gpuGetStreamHelper),
+      ArrayRef<Value>{});
   // Invoke the function with required arguments.
   auto gpuLaunchKernel =
       getOperation().lookupSymbol<LLVM::LLVMFuncOp>(kGpuLaunchKernelName);
@@ -443,7 +444,7 @@
   auto nullpointer =
       builder.create<LLVM::IntToPtrOp>(loc, getPointerPointerType(), zero);
   builder.create<LLVM::CallOp>(
-      loc, ArrayRef<Type>{getGpuRuntimeResultType()},
+      loc, {getGpuRuntimeResultType()},
       builder.getSymbolRefAttr(gpuLaunchKernel),
       ArrayRef<Value>{gpuFunctionRef, launchOp.getOperand(0),
                       launchOp.getOperand(1), launchOp.getOperand(2),
@@ -455,9 +456,9 @@
   // Sync on the stream to make it synchronous.
   auto gpuStreamSync =
       getOperation().lookupSymbol<LLVM::LLVMFuncOp>(kGpuStreamSynchronizeName);
-  builder.create<LLVM::CallOp>(loc, ArrayRef<Type>{getGpuRuntimeResultType()},
+  builder.create<LLVM::CallOp>(loc, {getGpuRuntimeResultType()},
                                builder.getSymbolRefAttr(gpuStreamSync),
-                               ArrayRef<Value>(gpuStream.getResult(0)));
+                               (gpuStream.getResult(0)));
   launchOp.erase();
 }
 
diff --git a/mlir/lib/Conversion/GPUCommon/GPUOpsLowering.h b/mlir/lib/Conversion/GPUCommon/GPUOpsLowering.h
--- a/mlir/lib/Conversion/GPUCommon/GPUOpsLowering.h
+++ b/mlir/lib/Conversion/GPUCommon/GPUOpsLowering.h
@@ -101,7 +101,7 @@
         auto elementType = global.getType().getArrayElementType();
         Value memory = rewriter.create<LLVM::GEPOp>(
             loc, elementType.getPointerTo(global.addr_space().getZExtValue()),
-            address, ArrayRef<Value>{zero, zero});
+            address, {zero, zero});
 
         // Build a memref descriptor pointing to the buffer to plug with the
         // existing memref infrastructure. This may use more registers than
diff --git a/mlir/lib/Conversion/GPUToVulkan/ConvertGPULaunchFuncToVulkanLaunchFunc.cpp b/mlir/lib/Conversion/GPUToVulkan/ConvertGPULaunchFuncToVulkanLaunchFunc.cpp
--- a/mlir/lib/Conversion/GPUToVulkan/ConvertGPULaunchFuncToVulkanLaunchFunc.cpp
+++ b/mlir/lib/Conversion/GPUToVulkan/ConvertGPULaunchFuncToVulkanLaunchFunc.cpp
@@ -172,8 +172,7 @@
 
   // Create vulkan launch call op.
   auto vulkanLaunchCallOp = builder.create<CallOp>(
-      loc, ArrayRef<Type>{}, builder.getSymbolRefAttr(kVulkanLaunch),
-      vulkanLaunchOperands);
+      loc, {}, builder.getSymbolRefAttr(kVulkanLaunch), vulkanLaunchOperands);
 
   // Set SPIR-V binary shader data as an attribute.
   vulkanLaunchCallOp.setAttr(
diff --git a/mlir/lib/Conversion/GPUToVulkan/ConvertLaunchFuncToVulkanCalls.cpp b/mlir/lib/Conversion/GPUToVulkan/ConvertLaunchFuncToVulkanCalls.cpp
--- a/mlir/lib/Conversion/GPUToVulkan/ConvertLaunchFuncToVulkanCalls.cpp
+++ b/mlir/lib/Conversion/GPUToVulkan/ConvertLaunchFuncToVulkanCalls.cpp
@@ -255,7 +255,7 @@
     }
     // Create call to `bindMemRef`.
     builder.create<LLVM::CallOp>(
-        loc, ArrayRef<Type>{getVoidType()},
+        loc, {getVoidType()},
         builder.getSymbolRefAttr(
             StringRef(symbolName.data(), symbolName.size())),
         ArrayRef<Value>{vulkanRuntime, descriptorSet, descriptorBinding,
@@ -382,8 +382,8 @@
   Location loc = cInterfaceVulkanLaunchCallOp.getLoc();
   // Create call to `initVulkan`.
   auto initVulkanCall = builder.create<LLVM::CallOp>(
-      loc, ArrayRef<Type>{getPointerType()},
-      builder.getSymbolRefAttr(kInitVulkan), ArrayRef<Value>{});
+      loc, {getPointerType()}, builder.getSymbolRefAttr(kInitVulkan),
+      ArrayRef<Value>{});
   // 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);
@@ -405,33 +405,31 @@
   // 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),
+      loc, {getVoidType()}, builder.getSymbolRefAttr(kSetBinaryShader),
       ArrayRef<Value>{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, {getVoidType()},
                                builder.getSymbolRefAttr(kSetEntryPoint),
                                ArrayRef<Value>{vulkanRuntime, entryPointName});
 
   // Create number of local workgroup for each dimension.
   builder.create<LLVM::CallOp>(
-      loc, ArrayRef<Type>{getVoidType()},
-      builder.getSymbolRefAttr(kSetNumWorkGroups),
+      loc, {getVoidType()}, builder.getSymbolRefAttr(kSetNumWorkGroups),
       ArrayRef<Value>{vulkanRuntime, cInterfaceVulkanLaunchCallOp.getOperand(0),
                       cInterfaceVulkanLaunchCallOp.getOperand(1),
                       cInterfaceVulkanLaunchCallOp.getOperand(2)});
 
   // Create call to `runOnVulkan` runtime function.
-  builder.create<LLVM::CallOp>(loc, ArrayRef<Type>{getVoidType()},
+  builder.create<LLVM::CallOp>(loc, {getVoidType()},
                                builder.getSymbolRefAttr(kRunOnVulkan),
                                ArrayRef<Value>{vulkanRuntime});
 
   // Create call to 'deinitVulkan' runtime function.
-  builder.create<LLVM::CallOp>(loc, ArrayRef<Type>{getVoidType()},
+  builder.create<LLVM::CallOp>(loc, {getVoidType()},
                                builder.getSymbolRefAttr(kDeinitVulkan),
                                ArrayRef<Value>{vulkanRuntime});
 
diff --git a/mlir/lib/Conversion/LinalgToStandard/LinalgToStandard.cpp b/mlir/lib/Conversion/LinalgToStandard/LinalgToStandard.cpp
--- a/mlir/lib/Conversion/LinalgToStandard/LinalgToStandard.cpp
+++ b/mlir/lib/Conversion/LinalgToStandard/LinalgToStandard.cpp
@@ -151,7 +151,7 @@
       return failure();
 
     rewriter.replaceOpWithNewOp<mlir::CallOp>(
-        op, libraryCallName.getValue(), ArrayRef<Type>{},
+        op, {}, libraryCallName.getValue(),
         createTypeCanonicalizedMemRefOperands(rewriter, op.getLoc(),
                                               op.getOperands()));
     return success();
diff --git a/mlir/lib/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVM.cpp b/mlir/lib/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVM.cpp
--- a/mlir/lib/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVM.cpp
+++ b/mlir/lib/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVM.cpp
@@ -561,8 +561,7 @@
   LogicalResult
   matchAndRewrite(spirv::ReturnOp returnOp, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
-    rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(returnOp, ArrayRef<Type>(),
-                                                ArrayRef<Value>());
+    rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(returnOp, {}, {});
     return success();
   }
 };
@@ -574,8 +573,7 @@
   LogicalResult
   matchAndRewrite(spirv::ReturnValueOp returnValueOp, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
-    rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(returnValueOp, ArrayRef<Type>(),
-                                                operands);
+    rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(returnValueOp, operands);
     return success();
   }
 };
diff --git a/mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp b/mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp
--- a/mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp
+++ b/mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp
@@ -857,10 +857,10 @@
 
   Value linearized = indices.front();
   for (int i = 1, nSizes = allocSizes.size(); i < nSizes; ++i) {
-    linearized = builder.create<LLVM::MulOp>(
-        loc, this->getIndexType(), ArrayRef<Value>{linearized, allocSizes[i]});
-    linearized = builder.create<LLVM::AddOp>(
-        loc, this->getIndexType(), ArrayRef<Value>{linearized, indices[i]});
+    linearized = builder.create<LLVM::MulOp>(loc, this->getIndexType(),
+                                             linearized, allocSizes[i]);
+    linearized = builder.create<LLVM::AddOp>(loc, this->getIndexType(),
+                                             linearized, indices[i]);
   }
   return linearized;
 }
@@ -1647,8 +1647,8 @@
       Value offset = createBumpToAlign(loc, rewriter, intVal, accessAlignment);
       Value aligned = rewriter.create<LLVM::GEPOp>(
           loc, allocatedBytePtr.getType(), allocatedBytePtr, offset);
-      alignedBytePtr = rewriter.create<LLVM::BitcastOp>(
-          loc, elementPtrType, ArrayRef<Value>(aligned));
+      alignedBytePtr =
+          rewriter.create<LLVM::BitcastOp>(loc, elementPtrType, aligned);
     }
     memRefDescriptor.setAlignedPtr(rewriter, loc, alignedBytePtr);
 
@@ -1705,8 +1705,8 @@
     // Compute the total number of memref elements.
     cumulativeSize = sizes.front();
     for (unsigned i = 1, e = sizes.size(); i < e; ++i)
-      cumulativeSize = rewriter.create<LLVM::MulOp>(
-          loc, getIndexType(), ArrayRef<Value>{cumulativeSize, sizes[i]});
+      cumulativeSize = rewriter.create<LLVM::MulOp>(loc, getIndexType(),
+                                                    cumulativeSize, sizes[i]);
 
     // Compute the size of an individual element. This emits the MLIR equivalent
     // of the following sizeof(...) implementation in LLVM IR:
@@ -1719,12 +1719,12 @@
                                 .getPointerTo();
     auto nullPtr = rewriter.create<LLVM::NullOp>(loc, convertedPtrType);
     one = createIndexConstant(rewriter, loc, 1);
-    auto gep = rewriter.create<LLVM::GEPOp>(loc, convertedPtrType,
-                                            ArrayRef<Value>{nullPtr, one});
+    auto gep =
+        rewriter.create<LLVM::GEPOp>(loc, convertedPtrType, nullPtr, {one});
     auto elementSize =
         rewriter.create<LLVM::PtrToIntOp>(loc, getIndexType(), gep);
-    cumulativeSize = rewriter.create<LLVM::MulOp>(
-        loc, getIndexType(), ArrayRef<Value>{cumulativeSize, elementSize});
+    cumulativeSize = rewriter.create<LLVM::MulOp>(loc, getIndexType(),
+                                                  cumulativeSize, elementSize);
   }
 
   /// Returns the type of a pointer to an element of the memref.
@@ -2135,7 +2135,7 @@
         op->getLoc(), getVoidPtrType(),
         memref.allocatedPtr(rewriter, op->getLoc()));
     rewriter.replaceOpWithNewOp<LLVM::CallOp>(
-        op, ArrayRef<Type>(), rewriter.getSymbolRefAttr(freeFunc), casted);
+        op, {}, rewriter.getSymbolRefAttr(freeFunc), casted);
     return success();
   }
 };
@@ -2575,13 +2575,12 @@
 
     // 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, {}, {}, op->getAttrs());
       return success();
     }
     if (numArguments == 1) {
-      rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(
-          op, ArrayRef<Type>(), updatedOperands, op->getAttrs());
+      rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(op, {}, updatedOperands,
+                                                  op->getAttrs());
       return success();
     }
 
@@ -2596,8 +2595,7 @@
           op->getLoc(), packedType, packed, updatedOperands[i],
           rewriter.getI64ArrayAttr(i));
     }
-    rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(op, ArrayRef<Type>(), packed,
-                                                op->getAttrs());
+    rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(op, {}, packed, op->getAttrs());
     return success();
   }
 };
diff --git a/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp b/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp
--- a/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp
+++ b/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp
@@ -2003,9 +2003,8 @@
   Value cst0 = builder.create<LLVM::ConstantOp>(
       loc, LLVM::LLVMType::getInt64Ty(llvmDialect),
       builder.getIntegerAttr(builder.getIndexType(), 0));
-  return builder.create<LLVM::GEPOp>(loc,
-                                     LLVM::LLVMType::getInt8PtrTy(llvmDialect),
-                                     globalPtr, ArrayRef<Value>({cst0, cst0}));
+  return builder.create<LLVM::GEPOp>(
+      loc, LLVM::LLVMType::getInt8PtrTy(llvmDialect), globalPtr, {cst0, cst0});
 }
 
 bool mlir::LLVM::satisfiesLLVMModule(Operation *op) {
diff --git a/mlir/lib/Dialect/SCF/SCF.cpp b/mlir/lib/Dialect/SCF/SCF.cpp
--- a/mlir/lib/Dialect/SCF/SCF.cpp
+++ b/mlir/lib/Dialect/SCF/SCF.cpp
@@ -804,7 +804,7 @@
 
   OpBuilder::InsertionGuard guard(builder);
   Region *bodyRegion = result.addRegion();
-  Block *body = builder.createBlock(bodyRegion, {}, ArrayRef<Type>{type, type});
+  Block *body = builder.createBlock(bodyRegion, {}, {type, type});
   if (bodyBuilderFn)
     bodyBuilderFn(builder, result.location, body->getArgument(0),
                   body->getArgument(1));