[MLIR] Add convenience specializations of OpBuilder create() and friends

[jurahul]

Summary

• Add template specialization of OpBuilder::create() and similar functions in PatternRewriter to allow calling create without having to cast collective arguments to ArrayRef<> of the corresponding type.

[rriddle]

I'm not really convinced that this is a win given the use of macros.

mlir/include/mlir/IR/Builders.h

14

Please remove the use of macros, this is highly polluting of all namespaces and is especially bad because this is such a highly included file.

[jurahul]

Note, there can be more specializations that can be added, but I wanted to get this out to get some feedback. Some next items to handle are (1) canonicalize various CallOp build parameters (some have function followed by result types, and other result types followed by functions) and then add a specialization for that, and (2) one for branch instructions. The goal is to make the calls to create/replace etc slightly simpler and eliminate/reduce the need to type ArrayRef<Type> or ArrayRef<Value> in front of a collection of types or values passed into these functions.

[jurahul]

mlir/include/mlir/IR/Builders.h

14

I was concerned as well here, other option is to not use macro's and do this manually (which is what I had done). Assuming a small set of specializations may cover a lot of ground, may be worth concerning. I know typing ArrayRef<>{} does not sound that bad, but I think if we could remove this noise, it should help readability slightly.

[rriddle]

mlir/include/mlir/IR/Builders.h

14

Slightly related, but we need to move the uses of ArrayRef<Type>/ArrayRef<Value> -> TypeRange/ValueRange which are also slightly easier to type.

[jurahul]

mlir/include/mlir/IR/Builders.h

14

Yes, TypeRange and ValueRange is shorter, but not by that much. I was hoping to avoid typing either. It seems all the builders need to move to use TypeRange and ValueRange regardless (which will be a separate change, likely before something like this change).

Unless I am missing some C++ feature, I am assuming the alternative to macros is manually writing them out.

[jurahul]

mlir/include/mlir/IR/Builders.h

14

Filed https://bugs.llvm.org/show_bug.cgi?id=46769 to track the use of ValueRange and TypeRange in the build methods.

[jurahul]

Eliminate macros

[jurahul]

This is my attempt to remove the use of Macros. With this, we essentially need one specialization class for each function we want to specialize. I tried to go down a different route as well, creating an instance of an (empty) specialization object with a templated () operator. The hope was that we can define this class just once, and say the builder has an instance of this class called 'create' and we could do something like

builder.create<Scf::Yield>(...);

and hoping the templated operator() gets called. However, it seems C++ does not allow this directly for a templated operator() and the syntax would be:

builder.create.operator()<Scf::Yield>(...)

which does not look great. So the fallback is this method. We would probably want to move these specialization classes into their owe header so at least when someone adds a new specialization, all the specializations are in a single file, so they could all be updated together. The drawback is that we will still need another copy for each new function name that we want to specialize (like createChecked etc).

[jurahul]

Cleanup leftover macro code

[ftynse]

IMO, sometimes an explicit TypeRange() is better than {}. But I am supportive of the effort to reduce the verbosity of builder API.

---

On a slightly related note, some time ago, I posted a longish text reflecting on the evolution on builders. One of the ideas was to generate non-template builder functions in per-dialect classes as follows

struct SCFBuilder {
  YieldOp Yield(Location loc, ValueRange operands) { return b.build<YieldOp>(loc, operands); }
  ForOp For(Location loc, Value lb, Value ub, Value step) { return b.build<ForOp>(loc, lb, ub, step); }

  OpBuilder &b;
};

and use these as

OpBuilder builder(...);
SCFBuilder scf(builder);
scf.For(loc, lb, ub, step);
/* ... */
scf.Yield(loc, {operand, operand});

More information in the DSL-style builders section of https://llvm.discourse.group/t/evolving-builder-apis-based-on-lessons-learned-from-edsc/879.

This was also addressing the issue with verbosity of builder API and achieves what you seem to be shooting for here: remove the mix of function overloading and variadic templates that suppress some implicit casting rules in a non-trivial way. (There was one time when I literally had to look into clang internals to understand how overload resolution works in presence of template argument packs, and it's a particular kind of hell.) It also has some nice effects like working auto-complete with documentation, but also some drawbacks, in particular storing the OpBuilder in potentially multiple dialect specific-builders. May be it is worth exploring again.

[jurahul]

Agreed, in certain instances if clarity is desired, an explicit TypeRange{} can be still be added. But in many cases, things may be clear enough that the extra 'TypeRange{}' or ValueRange{} may be just noise, which is what I am attempting to address here. We have some instances within MLIR, but I suspect several out-of-tree instances that would read easier without these casts.

I'll go over your discourse thread, but something like builder.createFor()... instead of builder.create<SCF::For> sounds interesting as well, and I agree that it can also address this issue of verbosity.

[jurahul]

@ftynse, I read your document a bit, but another idea came to my mind which seems like an incremental change. Instead of the per-dialect builder you had suggested:

OpBuilder builder(...);
SCFBuilder scf(builder);
scf.For(loc, lb, ub, step);
/* ... */
scf.Yield(loc, {operand, operand});

what if in addition to the build() methods, ODS framework defines a static create method corresponding to each of the build methods? In that case, the code above will look like:

OpBuilder builder(...);
scf::YieldOp::create(builder, loc, {operand, operand});

This should be doable without a dialect specific builder and breaking any existing API. For generality, internally create() will just do what it does today, call:builder.create<YieldOp>(...); For what I am attempting to to, in addition to create, we may also want to define other create-like methods like createOrFold, replaceOpWithNewOp() etc. It seems emitting them on the ODS side should be straightforward and easily extensible (without needing redundant C++ specialization classes for each methods that needs specialization). I think this will still retain some of the advantages you mentioned earlier (auto-correct) without the drawback of a new builder class and carrying around the OpBuilder. Please let me know what you think, and the change would be incremental in nature.

[ftynse]

@jurahul let's factor out this discussion to the forum, I don't think enough people follow individual review threads.

One of the issues EDSC builders try to solve is the verbosity and boilerplateness of the API. Having Dialect::Op::create(builder, loc, ...) looks equally, if not more, verbose than the existing builder, so it will likely end up as the third way of constructing ops (in addition to Builder.create and EDSC).

mlir/examples/toy/Ch6/mlir/LowerToLLVM.cpp

static Value getOrCreateGlobalString(Location loc, OpBuilder &builder,
 
     // 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(llvmDialect),
         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
 
 //===----------------------------------------------------------------------===//
 // ToyToLLVMLoweringPass
 //===----------------------------------------------------------------------===//
 

mlir/examples/toy/Ch7/mlir/LowerToLLVM.cpp

static Value getOrCreateGlobalString(Location loc, OpBuilder &builder,
 
     // 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(llvmDialect),
         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
 
 //===----------------------------------------------------------------------===//
 // ToyToLLVMLoweringPass
 //===----------------------------------------------------------------------===//
 

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

string llvmBuilder = [{
     auto *inst = builder.CreateStore($value, $addr);
   }] # setAlignmentCode;
   let builders = [
     OpBuilder<
     "OpBuilder &b, OperationState &result, Value value, Value addr, "
     "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); }];
   let printer = [{ printStoreOp(p, *this); }];
   let verifier = alignmentVerifierCode;
 }
 
 // Casts.
def LLVM_LandingpadOp : LLVM_OneResultOp<"landingpad">,
   let printer = [{ printLandingpadOp(p, *this); }];
 }
 
 def LLVM_CallOp : LLVM_Op<"call">,
                   Arguments<(ins OptionalAttr<FlatSymbolRefAttr>:$callee,
                              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();
       if (!resultType.isVoidTy())
         result.addTypes(resultType);
       result.addAttribute("callee", builder.getSymbolRefAttr(func));
       result.addAttributes(attributes);
       result.addOperands(operands);

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

let methods = [
     StaticInterfaceMethod<[{
         Create an operation of the current type with the given location,
         operands, and attributes.
       }],
       "Operation *", "create",
       (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);
       }]
     >,
     InterfaceMethod<[{
         Clone the current operation with the given location and operands. This
         is used to abstract away the optional underlying region creation.
       }],
       "Operation *", "clone",

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

let description = [{
     %2 = call @my_add(%0, %1) : (f32, f32) -> f32
     ```
   }];
 
   let arguments = (ins FlatSymbolRefAttr:$callee, Variadic<AnyType>:$operands);
   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);
   }]>];
 
   let extraClassDeclaration = [{
     StringRef getCallee() { return callee(); }
     FunctionType getCalleeType();

mlir/include/mlir/IR/Builders.h

 //===- Builders.h - Helpers for constructing MLIR Classes -------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_IR_BUILDERS_H
 #define MLIR_IR_BUILDERS_H
 
 #include "mlir/IR/OpDefinition.h"
 
 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;
 class UnknownLoc;
 class FileLineColLoc;
 class Type;
 class PrimitiveType;
 class IntegerType;
public:
   AffineMap getShiftedAffineMap(AffineMap map, int64_t shift);
 
 protected:
   MLIRContext *context;
 };
 
 /// 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;
 
   /// Create a builder with the given context.
   explicit OpBuilder(MLIRContext *ctx, Listener *listener = nullptr)
       : Builder(ctx), listener(listener) {}
 
   /// Create a builder and set the insertion point to the start of the region.
public:
   //===--------------------------------------------------------------------===//
 
   /// Insert the given operation at the current insertion point and return it.
   Operation *insert(Operation *op);
 
   /// 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.
   template <typename OpTy, typename... Args>
   void createOrFold(SmallVectorImpl<Value> &results, Location location,
                     Args &&... args) {
     // Create the operation without using 'createOperation' as we don't want to
     // insert it yet.

 private:
   /// The current block this builder is inserting into.
   Block *block = nullptr;
   /// The insertion point within the block that this builder is inserting
   /// before.
   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
 
 #endif

mlir/include/mlir/IR/Operation.h

public:
   /// Returns the region to which the instruction belongs. Returns nullptr if
   /// the instruction is unlinked.
   Region *getParentRegion();
 
   /// Returns the closest surrounding operation that contains this operation
   /// 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()))
       if (auto parentOp = dyn_cast<OpTy>(op))
         return parentOp;
     return OpTy();
   }
 

mlir/include/mlir/IR/PatternMatch.h

 ///
 /// These class serves two purposes:
 ///  1) it is the interface that patterns interact with to make mutations to the
 ///     IR they are being applied to.
 ///  2) It is a base class that clients of the PatternMatcher use when they want
 ///     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
   /// and return null.
   template <typename OpTy, typename... Args>
   OpTy createChecked(Location location, Args... args) {
     OperationState state(location, OpTy::getOperationName());
     OpTy::build(*this, state, args...);
void cloneRegionBefore(Region &region, Region &parent,
                          Region::iterator before);
   void cloneRegionBefore(Region &region, Block *before);
 
   /// This method performs the final replacement for a pattern, where the
   /// results of the operation are updated to use the specified list of SSA
   /// 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);
 
   /// This method erases all operations in a block.
   virtual void eraseBlock(Block *block);
 
   /// Merge the operations of block 'source' into the end of block 'dest'.
   /// 'source's predecessors must either be empty or only contain 'dest`.
notifyMatchFailure(Operation *op,
                      function_ref<void(Diagnostic &)> reasonCallback) {
     return failure();
   }
 
 private:
   /// '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());
+  }
 };
 
 //===----------------------------------------------------------------------===//
 // Pattern-driven rewriters
 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // OwningRewritePatternList

mlir/lib/Conversion/GPUCommon/ConvertLaunchFuncToRuntimeCalls.cpp

auto memLocation = builder.create<LLVM::AllocaOp>(
       loc, param.getType().cast<LLVM::LLVMType>().getPointerTo(), one,
       /*alignment=*/1);
   builder.create<LLVM::StoreOp>(loc, param, memLocation);
   auto casted =
       builder.create<LLVM::BitcastOp>(loc, getPointerType(), memLocation);
 
   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);
 }
 
 // Generates a parameters array to be used with a CUDA / ROCm (HIP) kernel
 // launch call. The arguments are extracted from the launchOp.
 // The generated code is essentially as follows:
 //
 // %array = alloca(numparams * sizeof(void *))
Value data = LLVM::createGlobalString(
       loc, builder, nameBuffer.str(), binaryAttr.getValue(),
       LLVM::Linkage::Internal, getLLVMDialect());
 
   // Emit the load module call to load the module data. Error checking is done
   // in the called helper function.
   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 =
       builder.create<LLVM::LoadOp>(loc, getPointerType(), gpuModule);
   auto kernelName = generateKernelNameConstant(
       launchOp.getKernelModuleName(), launchOp.getKernelName(), loc, builder);
   auto gpuFunction = allocatePointer(builder, loc);
   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);
   auto gpuFunctionRef =
       builder.create<LLVM::LoadOp>(loc, getPointerType(), gpuFunction);
   auto paramsArray = setupParamsArray(launchOp, builder);
   if (!paramsArray) {
     launchOp.emitOpError() << "cannot pass given parameters to the kernel";
     return signalPassFailure();
   }
   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),
                       launchOp.getOperand(3), launchOp.getOperand(4),
                       launchOp.getOperand(5), zero, /* sharedMemBytes */
                       gpuStream.getResult(0),       /* stream */
                       paramsArray,                  /* kernel params */
                       nullpointer /* extra */});
   // 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();
 }
 
 std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>>
 mlir::createConvertGpuLaunchFuncToGpuRuntimeCallsPass(
     StringRef gpuBinaryAnnotation) {
   if (gpuBinaryAnnotation.empty())
     return std::make_unique<GpuLaunchFuncToGpuRuntimeCallsPass>();
   return std::make_unique<GpuLaunchFuncToGpuRuntimeCallsPass>(
       gpuBinaryAnnotation);
 }

mlir/lib/Conversion/GPUCommon/GPUOpsLowering.h

auto llvmFuncOp = rewriter.create<LLVM::LLVMFuncOp>(
         zero = rewriter.create<LLVM::ConstantOp>(loc, i32Type,
                                                  rewriter.getI32IntegerAttr(0));
       for (auto en : llvm::enumerate(workgroupBuffers)) {
         LLVM::GlobalOp global = en.value();
         Value address = rewriter.create<LLVM::AddressOfOp>(loc, global);
         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
         // otherwise necessary given that memref sizes are fixed, but we can try
         // and canonicalize that away later.
         Value attribution = gpuFuncOp.getWorkgroupAttributions()[en.index()];
         auto type = attribution.getType().cast<MemRefType>();
         auto descr = MemRefDescriptor::fromStaticShape(

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),
-      vulkanLaunchOperands);
+      loc, {}, 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.
   vulkanLaunchCallOp.setAttr(

mlir/lib/Conversion/GPUToVulkan/ConvertLaunchFuncToVulkanCalls.cpp

for (auto en :
     if (type.isHalfTy()) {
       auto memRefTy =
           getMemRefType(rank, LLVM::LLVMType::getInt16Ty(llvmDialect));
       ptrToMemRefDescriptor = builder.create<LLVM::BitcastOp>(
           loc, memRefTy.getPointerTo(), ptrToMemRefDescriptor);
     }
     // 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,
                         ptrToMemRefDescriptor});
   }
 }
 
 LogicalResult VulkanLaunchFuncToVulkanCallsPass::deduceMemRefRankAndType(

 }
 
 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, {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);
 
   // 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, getLLVMDialect());
 
   // 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),
+      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});
 
   // 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

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(),
         createTypeCanonicalizedMemRefOperands(rewriter, op.getLoc(),
                                               op.getOperands()));
     return success();
   }
 };
 
 /// Conversion pattern specialization for IndexedGenericOp.
 template <>

mlir/lib/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVM.cpp

 
 class ReturnPattern : public SPIRVToLLVMConversion<spirv::ReturnOp> {
 public:
   using SPIRVToLLVMConversion<spirv::ReturnOp>::SPIRVToLLVMConversion;
 
   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();
   }
 };
 
 class ReturnValuePattern : public SPIRVToLLVMConversion<spirv::ReturnValueOp> {
 public:
   using SPIRVToLLVMConversion<spirv::ReturnValueOp>::SPIRVToLLVMConversion;
 
   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();
   }
 };
 
 /// Converts SPIR-V shift ops to LLVM shift ops. Since LLVM dialect
 /// puts a restriction on `Shift` and `Base` to have the same bit width,
 /// `Shift` is zero or sign extended to match this specification. Cases when
 /// `Shift` bit width > `Base` bit width are considered to be illegal.

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

Value ConvertToLLVMPattern::linearizeSubscripts(
     ConversionPatternRewriter &builder, Location loc, ArrayRef<Value> indices,
     ArrayRef<Value> allocSizes) const {
   assert(indices.size() == allocSizes.size() &&
          "mismatching number of indices and allocation sizes");
   assert(!indices.empty() && "cannot linearize a 0-dimensional access");
 
   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;
 }
 
 Value ConvertToLLVMPattern::getStridedElementPtr(
     Location loc, Type elementTypePtr, Value descriptor, ValueRange indices,
     ArrayRef<int64_t> strides, int64_t offset,
     ConversionPatternRewriter &rewriter) const {
MemRefDescriptor createMemRefDescriptor(
     Value alignedBytePtr = allocatedTypePtr;
     if (accessAlignment) {
       // offset = (align - (ptr % align))% align
       Value intVal = rewriter.create<LLVM::PtrToIntOp>(
           loc, this->getIndexType(), allocatedBytePtr);
       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);
 
     // Field 3: Offset in aligned pointer.
     memRefDescriptor.setOffset(rewriter, loc,
                                createIndexConstant(rewriter, loc, offset));
 
     if (memRefType.getRank() == 0)
for (int64_t s : memRefType.getShape())
       sizes.push_back(s == -1 ? operands[i++]
                               : createIndexConstant(rewriter, loc, s));
     if (sizes.empty())
       sizes.push_back(createIndexConstant(rewriter, loc, 1));
 
     // 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:
     //   %0 = getelementptr %elementType* null, %indexType 1
     //   %1 = ptrtoint %elementType* %0 to %indexType
     // which is a common pattern of getting the size of a type in bytes.
     auto elementType = memRefType.getElementType();
     auto convertedPtrType = typeConverter.convertType(elementType)
                                 .template cast<LLVM::LLVMType>()
                                 .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.
   Type getElementPtrType(MemRefType memRefType) const {
     auto elementType = memRefType.getElementType();
     auto structElementType = typeConverter.convertType(elementType);
     return structElementType.template cast<LLVM::LLVMType>().getPointerTo(
         memRefType.getMemorySpace());
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, {}, 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, {}, {}, 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();
     }
 
     // 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,
-                                                op->getAttrs());
+    rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(op, {}, packed, op->getAttrs());
     return success();
   }
 };
 
 // FIXME: this should be tablegen'ed as well.
 struct BranchOpLowering
     : public OneToOneLLVMTerminatorLowering<BranchOp, LLVM::BrOp> {
   using Super::Super;

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

auto global = moduleBuilder.create<LLVM::GlobalOp>(
       loc, type, /*isConstant=*/true, linkage, name,
       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(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) {
   return op->hasTrait<OpTrait::SymbolTable>() &&
          op->hasTrait<OpTrait::IsIsolatedFromAbove>();
 }
 
 std::unique_ptr<llvm::Module>

mlir/lib/Dialect/SCF/SCF.cpp

 void ReduceOp::build(
     OpBuilder &builder, OperationState &result, Value operand,
     function_ref<void(OpBuilder &, Location, Value, Value)> bodyBuilderFn) {
   auto type = operand.getType();
   result.addOperands(operand);
 
   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));
 }
 
 static LogicalResult verify(ReduceOp op) {
   // The region of a ReduceOp has two arguments of the same type as its operand.
   auto type = op.operand().getType();