[mlir] Make OpBuilder::createOperation to accept raw inputs

[Chia-hungDuan]

Summary

This provides a way to create an operation without manipulating
OperationState directly. This is useful for creating unregistered ops.

[jpienaar]

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

798–799

Is SmallVector / temporary needed or is this for readability? (e.g., could we use {lhs, rhs} below instead of innerOperands and let ValueRange's constructor take care of it).

[Chia-hungDuan]

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

798–799

Yes, it just for readability. Or i would use /*operands=*/{lhs, rhs}, either way should be fine.

[rriddle]

A part of me wants to ask what the trade off of this is vs just doing createOperation(OperationState(...))? Well we could also rename createOperation to create(to match the other API), which would make create(OperationState(...)) less redundant to read.

Either way, if we think this is a common enough use case I would be okay with adding the API for it.

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

798–799

I would rather inline it. As an aside, if we want to temp variable, we should use an array instead of SmallVector.

[Chia-hungDuan]

In D120787#3355227, @rriddle wrote:

A part of me wants to ask what the trade off of this is vs just doing createOperation(OperationState(...))? Well we could also rename createOperation to create(to match the other API), which would make create(OperationState(...)) less redundant to read.

Either way, if we think this is a common enough use case I would be okay with adding the API for it.

OperationState is more like an implementation detail thing and having this makes the preparation of creating operation the same in between registered and unregistered op. I mean, when a user wants to create an unregistered op, they don't need to know there's a OperationState structure to work with. They could have same experience of creating operation. So far, I'm not sure if there's anything bad if we provide this.

I think we can make the createOperation(OperationState) private and having create(...) as public. Or do you think it's better to have both of them for users? I.e., have both create(OperationState) and create(...) in public?

[rriddle]

In D120787#3356135, @Chia-hungDuan wrote:

In D120787#3355227, @rriddle wrote:

A part of me wants to ask what the trade off of this is vs just doing createOperation(OperationState(...))? Well we could also rename createOperation to create(to match the other API), which would make create(OperationState(...)) less redundant to read.

Either way, if we think this is a common enough use case I would be okay with adding the API for it.

OperationState is more like an implementation detail thing and having this makes the preparation of creating operation the same in between registered and unregistered op. I mean, when a user wants to create an unregistered op, they don't need to know there's a OperationState structure to work with. They could have same experience of creating operation. So far, I'm not sure if there's anything bad if we provide this.

I think we can make the createOperation(OperationState) private and having create(...) as public. Or do you think it's better to have both of them for users? I.e., have both create(OperationState) and create(...) in public?

OperationState isn't really just an implementation detail though, given that it is heavily exposed (e.g. all builders use it, parsers use it, etc.).

[Chia-hungDuan]

In D120787#3356136, @rriddle wrote:

In D120787#3356135, @Chia-hungDuan wrote:

In D120787#3355227, @rriddle wrote:

A part of me wants to ask what the trade off of this is vs just doing createOperation(OperationState(...))? Well we could also rename createOperation to create(to match the other API), which would make create(OperationState(...)) less redundant to read.

Either way, if we think this is a common enough use case I would be okay with adding the API for it.

OperationState is more like an implementation detail thing and having this makes the preparation of creating operation the same in between registered and unregistered op. I mean, when a user wants to create an unregistered op, they don't need to know there's a OperationState structure to work with. They could have same experience of creating operation. So far, I'm not sure if there's anything bad if we provide this.

I think we can make the createOperation(OperationState) private and having create(...) as public. Or do you think it's better to have both of them for users? I.e., have both create(OperationState) and create(...) in public?

OperationState isn't really just an implementation detail though, given that it is heavily exposed (e.g. all builders use it, parsers use it, etc.).

Sorry, I didn't say it clearly. For user's perspective, writing pass or patterns, they don't need to know OperationState if they only work on registered op.

[mehdi_amini]

LGTM: it is nicer to write than the having to explicitly wrap into an OperationState.

But please remove the SmallVector!
(and wait for River's approval as well)

mlir/include/mlir/IR/Builders.h

418

I would take a StringAttr instead of a StringRef: it encourages a more efficient API

[Chia-hungDuan]

Use StringAttr instead and updated some cases to use the create without OperationState

[Chia-hungDuan]

Also changed the createOperation to create.

After checking some cases, OperationState is useful when building some complicated cases. For example, they don't need to allocate individual containers for each argument. So I think having both of them will be better.

[Chia-hungDuan]

@rriddle, a gentle ping!

[Chia-hungDuan]

Rebase

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

InterfaceMethod<
            "ValueRange":$operands),
       [{
         BlockAndValueMapping bvm;
         OperationState state(
           loc, ConcreteOp::getOperationName(), operands, resultTypes,
           $_op->getAttrs());
         for (Region &r : $_op->getRegions())
           r.cloneInto(state.addRegion(), bvm);
-        return b.createOperation(state);
+        return b.create(state);
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Clone the current operation with the given location, operands
         and BlockAndValueMapping. This is used to abstract away the
         optional underlying region creation. This does not change the
         balance between input, output_buffer and init_tensors
         operands.
       }],
       /*retTy=*/"Operation *",
       /*methodName=*/"cloneWithMapper",
       (ins "OpBuilder &":$b, "Location":$loc, "TypeRange":$resultTypes,
            "ValueRange":$operands, "BlockAndValueMapping &":$bvm),
       [{
         OperationState state(
           loc, ConcreteOp::getOperationName(), operands, resultTypes,
           $_op->getAttrs());
         for (Region &r : $_op->getRegions())
           r.cloneInto(state.addRegion(), bvm);
-        return b.createOperation(state);
+        return b.create(state);
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Clone the current operation with the given location, operands
         and BlockAndValueMapping but leave the regions empty. This is
         used to abstract away the optional underlying region creation.
         This does not change the balance between input, output_buffer
         and init_tensors operands.
       }],
       /*retTy=*/"Operation *",
       /*methodName=*/"cloneWithoutRegions",
       (ins "OpBuilder &":$b, "Location":$loc, "TypeRange":$resultTypes,
            "ValueRange":$operands),
       [{
         OperationState state(
           loc, ConcreteOp::getOperationName(), operands, resultTypes,
           $_op->getAttrs());
         for (size_t cnt = 0, e = $_op->getNumRegions(); cnt < e; ++cnt)
           state.addRegion();
-        return b.createOperation(state);
+        return b.create(state);
       }]
     >,
     StaticInterfaceMethod<
       /*desc=*/[{
         Returns the region builder for constructing the body for linalg.generic.
         Returns a null function if this named op does not define a region
         builder.
       }],

mlir/include/mlir/IR/Builders.h

public:
   //===--------------------------------------------------------------------===//
   // Operation Creation
   //===--------------------------------------------------------------------===//
 
   /// 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);
+  Operation *create(const OperationState &state);
+
+  /// Creates an operation with the given fields.
+  Operation *create(Location loc, StringAttr opName, ValueRange operands,
+                    TypeRange types, ArrayRef<NamedAttribute> attributes = {},
+                    BlockRange successors = {},
+                    MutableArrayRef<std::unique_ptr<Region>> regions = {});
 
 private:
   /// Helper for sanity checking preconditions for create* methods below.
   template <typename OpT>
   RegisteredOperationName getCheckRegisteredInfo(MLIRContext *ctx) {
     Optional<RegisteredOperationName> opName =
         RegisteredOperationName::lookup(OpT::getOperationName(), ctx);
     if (LLVM_UNLIKELY(!opName)) {
       llvm::report_fatal_error(
           "Building op `" + OpT::getOperationName() +
           "` but it isn't registered in this MLIRContext: the dialect may not "
           "be loaded or this operation isn't registered by the dialect. See "
           "also https://mlir.llvm.org/getting_started/Faq/"
           "#registered-loaded-dependent-whats-up-with-dialects-management");
     }
     return *opName;
   }
 
 public:
   /// 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,
                          getCheckRegisteredInfo<OpTy>(location.getContext()));
     OpTy::build(*this, state, std::forward<Args>(args)...);
-    auto *op = createOperation(state);
+    auto *op = create(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
+    // Create the operation without using 'create' as we don't want to
     // insert it yet.
     OperationState state(location,
                          getCheckRegisteredInfo<OpTy>(location.getContext()));
     OpTy::build(*this, state, std::forward<Args>(args)...);
     Operation *op = Operation::create(state);
 
     // Fold the operation. If successful destroy it, otherwise insert it.
     if (succeeded(tryFold(op, results)))

mlir/lib/Conversion/LLVMCommon/Pattern.cpp

 //===- Pattern.cpp - Conversion pattern to the LLVM dialect ---------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/LLVMCommon/Pattern.h"
 #include "mlir/Dialect/LLVMIR/FunctionCallUtils.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/LLVMIR/LLVMTypes.h"
 #include "mlir/IR/AffineMap.h"
+#include "mlir/IR/BuiltinAttributes.h"
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // ConvertToLLVMPattern
 //===----------------------------------------------------------------------===//
 
 ConvertToLLVMPattern::ConvertToLLVMPattern(StringRef rootOpName,
LogicalResult LLVM::detail::oneToOneRewrite(
   Type packedType;
   if (numResults != 0) {
     packedType = typeConverter.packFunctionResults(op->getResultTypes());
     if (!packedType)
       return failure();
   }
 
   // Create the operation through state since we don't know its C++ type.
-  OperationState state(op->getLoc(), targetOp);
-  state.addTypes(packedType);
-  state.addOperands(operands);
-  state.addAttributes(op->getAttrs());
-  Operation *newOp = rewriter.createOperation(state);
+  Operation *newOp =
+      rewriter.create(op->getLoc(), rewriter.getStringAttr(targetOp), operands,
+                      packedType, op->getAttrs());
 
   // If the operation produced 0 or 1 result, return them immediately.
   if (numResults == 0)
     return rewriter.eraseOp(op), success();
   if (numResults == 1)
     return rewriter.replaceOp(op, newOp->getResult(0)), success();
 
   // Otherwise, it had been converted to an operation producing a structure.

mlir/lib/Conversion/LLVMCommon/VectorPattern.cpp

if (!llvm::all_of(operands.getTypes(),
     return failure();
 
   auto llvmNDVectorTy = operands[0].getType();
   if (!llvmNDVectorTy.isa<LLVM::LLVMArrayType>())
     return oneToOneRewrite(op, targetOp, operands, typeConverter, rewriter);
 
   auto callback = [op, targetOp, &rewriter](Type llvm1DVectorTy,
                                             ValueRange operands) {
-    OperationState state(op->getLoc(), targetOp);
-    state.addTypes(llvm1DVectorTy);
-    state.addOperands(operands);
-    state.addAttributes(op->getAttrs());
-    return rewriter.createOperation(state)->getResult(0);
+    return rewriter
+        .create(op->getLoc(), rewriter.getStringAttr(targetOp), operands,
+                llvm1DVectorTy, op->getAttrs())
+        ->getResult(0);
   };
 
   return handleMultidimensionalVectors(op, operands, typeConverter, callback,
                                        rewriter);
 }

mlir/lib/Dialect/Affine/Transforms/SuperVectorize.cpp

for (Value operand : op->getOperands()) {
     vectorOperands.push_back(vecOperand);
   }
 
   // Create a clone of the op with the proper operands and return types.
   // TODO: The following assumes there is always an op with a fixed
   // name that works both in scalar mode and vector mode.
   // TODO: Is it worth considering an Operation.clone operation which
   // changes the type so we can promote an Operation with less boilerplate?
-  OperationState vecOpState(op->getLoc(), op->getName(), vectorOperands,
-                            vectorTypes, op->getAttrs(), /*successors=*/{},
-                            /*regions=*/{});
-  Operation *vecOp = state.builder.createOperation(vecOpState);
+  Operation *vecOp =
+      state.builder.create(op->getLoc(), op->getName().getIdentifier(),
+                           vectorOperands, vectorTypes, op->getAttrs());
   state.registerOpVectorReplacement(op, vecOp);
   return vecOp;
 }
 
 /// Vectorizes a yield operation by widening its types. The builder's insertion
 /// point is set after the vectorized parent op to continue vectorizing the
 /// operations after the parent op. When vectorizing a reduction loop a mask may
 /// be used to prevent adding garbage values to the accumulator.

mlir/lib/Dialect/Affine/Utils/Utils.cpp

LogicalResult mlir::replaceAllMemRefUsesWith(Value oldMemRef, Value newMemRef,
   for (auto namedAttr : op->getAttrs()) {
     if (namedAttr.getName() == oldMapAttrPair.getName())
       state.attributes.push_back({namedAttr.getName(), newMapAttr});
     else
       state.attributes.push_back(namedAttr);
   }
 
   // Create the new operation.
-  auto *repOp = builder.createOperation(state);
+  auto *repOp = builder.create(state);
   op->replaceAllUsesWith(repOp);
   op->erase();
 
   return success();
 }
 
 LogicalResult mlir::replaceAllMemRefUsesWith(
     Value oldMemRef, Value newMemRef, ArrayRef<Value> extraIndices,

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

LogicalResult matchAndRewrite(Operation *op,
     rewriter.replaceOpWithNewOp<linalg::GenericOp>(
         op, /*resultTensorTypes=*/op->getResultTypes(),
         /*inputs=*/op->getOperands(),
         /*outputs=*/outputs,
         /*indexingMaps=*/indexingMaps,
         /*iteratorTypes=*/iteratorTypes,
         /*bodyBuilder=*/
         [&](OpBuilder &builder, Location loc, ValueRange regionArgs) {
-          OperationState state(loc, op->getName());
-          state.addAttributes(op->getAttrs());
-          // Only take the input operands in the cloned elementwise op.
-          state.addOperands(regionArgs.take_front(op->getNumOperands()));
           auto resultTypes = llvm::to_vector<6>(
               llvm::map_range(op->getResultTypes(), [](Type type) {
                 return type.cast<TensorType>().getElementType();
               }));
-          state.addTypes(resultTypes);
-          auto *scalarOp = builder.createOperation(state);
+          auto *scalarOp =
+              builder.create(loc, op->getName().getIdentifier(),
+                             regionArgs.take_front(op->getNumOperands()),
+                             resultTypes, op->getAttrs());
           builder.create<linalg::YieldOp>(loc, scalarOp->getResults());
         });
     return success();
   }
 };
 } // namespace
 
 void mlir::linalg::populateElementwiseToLinalgConversionPatterns(

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

static VectorizationResult vectorizeLinalgIndex(OpBuilder &b, Operation *op,
   SmallVector<int64_t> transposition =
       llvm::to_vector<16>(llvm::seq<int64_t>(0, linalgOp.getNumLoops()));
   std::swap(transposition.back(), transposition[indexOp.dim()]);
   auto transposeOp =
       b.create<vector::TransposeOp>(loc, broadCastOp, transposition);
   return VectorizationResult{VectorizationStatus::NewOp, transposeOp};
 }
 
-/// Create a new vectorized verstion of `op` with the given operands and types.
-static Operation *createVectorizedOp(OpBuilder &b, Operation *op,
-                                     ValueRange newOperands,
-                                     ArrayRef<Type> types) {
-  OperationState state(op->getLoc(), op->getName());
-  state.addAttributes(op->getAttrs());
-  state.addOperands(newOperands);
-  state.addTypes(types);
-  return b.createOperation(state);
-}
-
 /// Emit reduction operations if the shapes of the value to reduce is different
 /// that the result shape.
 static Operation *reduceIfNeeded(OpBuilder &b, LinalgOp linalgOp, Operation *op,
                                  Value reduceValue, Value initialValue,
                                  const BlockAndValueMapping &bvm) {
   Value reduceVec = bvm.lookup(reduceValue);
   Value outputVec = bvm.lookup(initialValue);
   auto reduceType = reduceVec.getType().dyn_cast<VectorType>();
   auto outputType = outputVec.getType().dyn_cast<VectorType>();
   // Reduce only if needed as the value may already have been reduce for
   // contraction vectorization.
   if (!reduceType ||
       (outputType && reduceType.getShape() == outputType.getShape()))
     return nullptr;
   SmallVector<bool> reductionMask = getReductionMask(linalgOp);
   Value reduce = buildMultiDimReduce(b, op, reduceVec, reductionMask);
-  return createVectorizedOp(b, op, {reduce, outputVec}, reduce.getType());
+  return b.create(op->getLoc(), op->getName().getIdentifier(),
+                  /*operands=*/{reduce, outputVec}, reduce.getType(),
+                  op->getAttrs());
 }
 
 /// Generic vectorization for a single operation `op`, given already vectorized
 /// operands carried by `bvm`. Vectorization occurs as follows:
 ///   1. Try to apply any of the `customVectorizationHooks` and return its
 ///   result on success.
 ///   2. Clone any constant in the current scope without vectorization: each
 ///   consumer of the constant will later determine the shape to which the
auto returnTypes = llvm::map_range(op->getResultTypes(), [&](Type t) {
     return firstMaxRankedShape.empty()
                ? t
                : VectorType::get(firstMaxRankedShape, t);
   });
 
   // Build and return the new op.
   return VectorizationResult{
       VectorizationStatus::NewOp,
-      createVectorizedOp(b, op, llvm::to_vector<4>(vectorizedOperands),
-                         llvm::to_vector<4>(returnTypes))};
+      b.create(op->getLoc(), op->getName().getIdentifier(),
+               llvm::to_vector<4>(vectorizedOperands),
+               llvm::to_vector<4>(returnTypes), op->getAttrs())};
 }
 
 /// Detect whether `r` has only ConstantOp, ElementwiseMappable and YieldOp.
 static bool hasOnlyScalarElementwiseOp(Region &r) {
   if (!llvm::hasSingleElement(r))
     return false;
   for (Operation &op : r.front()) {
     if (!(isa<arith::ConstantOp, func::ConstantOp, linalg::YieldOp,

mlir/lib/Dialect/MemRef/Transforms/NormalizeMemRefs.cpp

Operation *NormalizeMemRefs::createOpResultsNormalized(FuncOp funcOp,
   // When all of the results of `oldOp` have no memrefs or memrefs without
   // affine map, `oldOp` is returned without modification.
   if (resultTypeNormalized) {
     OpBuilder bb(oldOp);
     for (auto &oldRegion : oldOp->getRegions()) {
       Region *newRegion = result.addRegion();
       newRegion->takeBody(oldRegion);
     }
-    return bb.createOperation(result);
+    return bb.create(result);
   }
   return oldOp;
 }

mlir/lib/Dialect/Vector/Transforms/VectorDropLeadUnitDim.cpp

LogicalResult matchAndRewrite(Operation *op,
     for (Value operand : op->getOperands()) {
       if (auto opVecType = operand.getType().dyn_cast<VectorType>()) {
         newOperands.push_back(rewriter.create<vector::ExtractOp>(
             op->getLoc(), operand, splatZero(dropDim)));
       } else {
         newOperands.push_back(operand);
       }
     }
-    OperationState state(op->getLoc(), op->getName());
-    state.addAttributes(op->getAttrs());
-    state.addOperands(newOperands);
-    state.addTypes(newVecType);
-    Operation *newOp = rewriter.createOperation(state);
+    Operation *newOp =
+        rewriter.create(op->getLoc(), op->getName().getIdentifier(),
+                        newOperands, newVecType, op->getAttrs());
     rewriter.replaceOpWithNewOp<vector::BroadcastOp>(op, vecType,
                                                      newOp->getResult(0));
     return success();
   }
 };
 
 } // namespace
 

mlir/lib/Dialect/Vector/Transforms/VectorUnrollDistribute.cpp

 }
 
 // Clones `op` into a new operations that takes `operands` and returns
 // `resultTypes`.
 static Operation *cloneOpWithOperandsAndTypes(OpBuilder &builder, Location loc,
                                               Operation *op,
                                               ArrayRef<Value> operands,
                                               ArrayRef<Type> resultTypes) {
-  OperationState res(loc, op->getName(), operands, resultTypes, op->getAttrs());
-  return builder.createOperation(res);
+  return builder.create(loc, op->getName().getIdentifier(), operands,
+                        resultTypes, op->getAttrs());
 }
 
 /// Return the target shape for unrolling for the given `op`. Return llvm::None
 /// if the op shouldn't be or cannot be unrolled.
 static Optional<SmallVector<int64_t, 4>>
 getTargetShape(const vector::UnrollVectorOptions &options, Operation *op) {
   if (options.filterConstraint && failed(options.filterConstraint(op)))
     return llvm::None;

mlir/lib/IR/Builders.cpp

 Block *OpBuilder::createBlock(Block *insertBefore, TypeRange argTypes,
                               ArrayRef<Location> locs) {
   assert(insertBefore && "expected valid insertion block");
   return createBlock(insertBefore->getParent(), Region::iterator(insertBefore),
                      argTypes, locs);
 }
 
 /// Create an operation given the fields represented as an OperationState.
-Operation *OpBuilder::createOperation(const OperationState &state) {
+Operation *OpBuilder::create(const OperationState &state) {
   return insert(Operation::create(state));
 }
 
+/// Creates an operation with the given fields.
+Operation *OpBuilder::create(Location loc, StringAttr opName,
+                             ValueRange operands, TypeRange types,
+                             ArrayRef<NamedAttribute> attributes,
+                             BlockRange successors,
+                             MutableArrayRef<std::unique_ptr<Region>> regions) {
+  OperationState state(loc, opName, operands, types, attributes, successors,
+                       regions);
+  return create(state);
+}
+
 /// Attempts to fold the given operation and places new results within
 /// 'results'. Returns success if the operation was folded, failure otherwise.
 /// Note: This function does not erase the operation on a successful fold.
 LogicalResult OpBuilder::tryFold(Operation *op,
                                  SmallVectorImpl<Value> &results) {
   ResultRange opResults = op->getResults();
 
   results.reserve(opResults.size());

mlir/lib/Parser/Parser.cpp

Operation *OperationParser::parseGenericOperation() {
   // If we are populating the parser state, start a new operation definition.
   if (state.asmState)
     state.asmState->startOperationDefinition(result.name);
 
   if (parseGenericOperationAfterOpName(result))
     return nullptr;
 
   // Create the operation and try to parse a location for it.
-  Operation *op = opBuilder.createOperation(result);
+  Operation *op = opBuilder.create(result);
   if (parseTrailingLocationSpecifier(op))
     return nullptr;
   return op;
 }
 
 Operation *OperationParser::parseGenericOperation(Block *insertBlock,
                                                   Block::iterator insertPt) {
   Token nameToken = getToken();
OperationParser::parseCustomOperation(ArrayRef<ResultRecord> resultIDs) {
   if (opAsmParser.parseOperation(opState))
     return nullptr;
 
   // If it emitted an error, we failed.
   if (opAsmParser.didEmitError())
     return nullptr;
 
   // Otherwise, create the operation and try to parse a location for it.
-  Operation *op = opBuilder.createOperation(opState);
+  Operation *op = opBuilder.create(opState);
   if (parseTrailingLocationSpecifier(op))
     return nullptr;
   return op;
 }
 
 ParseResult OperationParser::parseLocationAlias(LocationAttr &loc) {
   Token tok = getToken();
   consumeToken(Token::hash_identifier);

mlir/lib/Rewrite/ByteCode.cpp

for (unsigned i = 0, e = read(); i != e; ++i) {
     if (failed(inferInterface->inferReturnTypes(
             state.getContext(), state.location, state.operands,
             state.attributes.getDictionary(state.getContext()), state.regions,
             state.types)))
       return;
     break;
   }
 
-  Operation *resultOp = rewriter.createOperation(state);
+  Operation *resultOp = rewriter.create(state);
   memory[memIndex] = resultOp;
 
   LLVM_DEBUG({
     llvm::dbgs() << "  * Attributes: "
                  << state.attributes.getDictionary(state.getContext())
                  << "\n  * Operands: ";
     llvm::interleaveComma(state.operands, llvm::dbgs());
     llvm::dbgs() << "\n  * Result Types: ";

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

 Value Importer::processValue(llvm::Value *value) {
   auto it = instMap.find(value);
   if (it != instMap.end())
     return it->second;
 
   // We don't expect to see instructions in dominator order. If we haven't seen
   // this instruction yet, create an unknown op and remap it later.
   if (isa<llvm::Instruction>(value)) {
-    OperationState state(UnknownLoc::get(context), "llvm.unknown");
     Type type = processType(value->getType());
     if (!type)
       return nullptr;
-    state.addTypes(type);
-    unknownInstMap[value] = b.createOperation(state);
+    unknownInstMap[value] =
+        b.create(UnknownLoc::get(context), b.getStringAttr("llvm.unknown"),
+                 /*operands=*/{}, type);
     return unknownInstMap[value]->getResult(0);
   }
 
   if (auto *c = dyn_cast<llvm::Constant>(value))
     return processConstant(c);
 
   emitError(unknownLoc) << "unhandled value: " << diag(*value);
   return nullptr;
case llvm::Instruction::BitCast: {
     }
     state.addOperands(ops);
     if (!inst->getType()->isVoidTy()) {
       Type type = processType(inst->getType());
       if (!type)
         return failure();
       state.addTypes(type);
     }
-    Operation *op = b.createOperation(state);
+    Operation *op = b.create(state);
     if (!inst->getType()->isVoidTy())
       v = op->getResult(0);
     return success();
   }
   case llvm::Instruction::ICmp: {
     Value lhs = processValue(inst->getOperand(0));
     Value rhs = processValue(inst->getOperand(1));
     if (!lhs || !rhs)
for (int i : llvm::seq<int>(0, brInst->getNumSuccessors())) {
       operandSegmentSizes[i + 1] = blockArguments.size();
     }
 
     if (brInst->isConditional()) {
       state.addAttribute(LLVM::CondBrOp::getOperandSegmentSizeAttr(),
                          b.getI32VectorAttr(operandSegmentSizes));
     }
 
-    b.createOperation(state);
+    b.create(state);
     return success();
   }
   case llvm::Instruction::PHI: {
     Type type = processType(inst->getType());
     if (!type)
       return failure();
     v = b.getInsertionBlock()->addArgument(
         type, processDebugLoc(inst->getDebugLoc(), inst));

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

LogicalResult spirv::Deserializer::processOpWithoutGrammarAttr(
 
   // Create the op and update bookkeeping maps
   Location loc = createFileLineColLoc(opBuilder);
   OperationState opState(loc, opName);
   opState.addOperands(operands);
   if (hasResult)
     opState.addTypes(resultTypes);
   opState.addAttributes(attributes);
-  Operation *op = opBuilder.createOperation(opState);
+  Operation *op = opBuilder.create(opState);
   if (hasResult)
     valueMap[valueID] = op->getResult(0);
 
   if (op->hasTrait<OpTrait::IsTerminator>())
     clearDebugLine();
 
   return success();
 }

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

ParseResult PrettyPrintedRegionOp::parse(OpAsmParser &parser,
   if (!succeeded(parser.parseOptionalKeyword("start")))
     return parser.parseGenericOperationAfterOpName(
         result, llvm::makeArrayRef(operands));
 
   FailureOr<OperationName> parseOpNameInfo = parser.parseCustomOperationName();
   if (failed(parseOpNameInfo))
     return failure();
 
-  StringRef innerOpName = parseOpNameInfo->getStringRef();
+  StringAttr innerOpName = parseOpNameInfo->getIdentifier();
 
   FunctionType opFntype;
   Optional<Location> explicitLoc;
   if (parser.parseKeyword("end") || parser.parseColon() ||
       parser.parseType(opFntype) ||
       parser.parseOptionalLocationSpecifier(explicitLoc))
     return failure();
 
ParseResult PrettyPrintedRegionOp::parse(OpAsmParser &parser,
   // result and operand types all same as the test-op's first operand.
   Type innerOpType = opFntype.getInput(0);
   Value lhs = block.addArgument(innerOpType, opLoc);
   Value rhs = block.addArgument(innerOpType, opLoc);
 
   OpBuilder builder(parser.getBuilder().getContext());
   builder.setInsertionPointToStart(&block);
 
-  OperationState innerOpState(opLoc, innerOpName);
-  innerOpState.operands.push_back(lhs);
-  innerOpState.operands.push_back(rhs);
-  innerOpState.addTypes(innerOpType);
-
-  Operation *innerOp = builder.createOperation(innerOpState);
+  Operation *innerOp =
+      builder.create(opLoc, innerOpName, /*operands=*/{lhs, rhs}, innerOpType);
 
   // Insert a return statement in the block returning the inner-op's result.
   builder.create<TestReturnOp>(innerOp->getLoc(), innerOp->getResults());
 
   // Populate the op operation-state with result-type and location.
   result.addTypes(opFntype.getResults());
   result.location = innerOp->getLoc();
 

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

for (int j = 0; j < e; ++j) {
       std::array<Value, 2> values = {{fop.getArgument(i), fop.getArgument(j)}};
       SmallVector<Type, 2> inferredReturnTypes;
       if (succeeded(OpTy::inferReturnTypes(
               context, llvm::None, values, op->getAttrDictionary(),
               op->getRegions(), inferredReturnTypes))) {
         OperationState state(location, OpTy::getOperationName());
         // TODO: Expand to regions.
         OpTy::build(b, state, values, op->getAttrs());
-        (void)b.createOperation(state);
+        (void)b.create(state);
       }
     }
   }
 }
 
 static void reifyReturnShape(Operation *op) {
   OpBuilder b(op);
 
struct TestRegionRewriteUndo : public RewritePattern {
   TestRegionRewriteUndo(MLIRContext *ctx)
       : RewritePattern("test.region_builder", 1, ctx) {}
 
   LogicalResult matchAndRewrite(Operation *op,
                                 PatternRewriter &rewriter) const final {
     // Create the region operation with an entry block containing arguments.
     OperationState newRegion(op->getLoc(), "test.region");
     newRegion.addRegion();
-    auto *regionOp = rewriter.createOperation(newRegion);
+    auto *regionOp = rewriter.create(newRegion);
     auto *entryBlock = rewriter.createBlock(&regionOp->getRegion(0));
     entryBlock->addArgument(rewriter.getIntegerType(64),
                             rewriter.getUnknownLoc());
 
     // Add an explicitly illegal operation to ensure the conversion fails.
     rewriter.create<ILLegalOpF>(op->getLoc(), rewriter.getIntegerType(32));
     rewriter.create<TestValidOp>(op->getLoc(), ArrayRef<Value>());
 

mlir/test/lib/Rewrite/TestPDLByteCode.cpp

customMultiEntityVariadicConstraint(ArrayRef<PDLValue> values,
   if (operandValues.size() != 2 || typeValues.size() != 2)
     return failure();
   return success();
 }
 
 // Custom creator invoked from PDL.
 static void customCreate(ArrayRef<PDLValue> args, ArrayAttr constantParams,
                          PatternRewriter &rewriter, PDLResultList &results) {
-  results.push_back(rewriter.createOperation(
+  results.push_back(rewriter.create(
       OperationState(args[0].cast<Operation *>()->getLoc(), "test.success")));
 }
 static void customVariadicResultCreate(ArrayRef<PDLValue> args,
                                        ArrayAttr constantParams,
                                        PatternRewriter &rewriter,
                                        PDLResultList &results) {
   Operation *root = args[0].cast<Operation *>();
   results.push_back(root->getOperands());
   results.push_back(root->getOperands().getTypes());
 }
 static void customCreateType(ArrayRef<PDLValue> args, ArrayAttr constantParams,
                              PatternRewriter &rewriter,
                              PDLResultList &results) {
   results.push_back(rewriter.getF32Type());
 }
 
 /// Custom rewriter invoked from PDL.
 static void customRewriter(ArrayRef<PDLValue> args, ArrayAttr constantParams,
                            PatternRewriter &rewriter, PDLResultList &results) {
   Operation *root = args[0].cast<Operation *>();
   OperationState successOpState(root->getLoc(), "test.success");
   successOpState.addOperands(args[1].cast<Value>());
   successOpState.addAttribute("constantParams", constantParams);
-  rewriter.createOperation(successOpState);
+  rewriter.create(successOpState);
   rewriter.eraseOp(root);
 }
 
 namespace {
 struct TestPDLByteCodePass
     : public PassWrapper<TestPDLByteCodePass, OperationPass<ModuleOp>> {
   StringRef getArgument() const final { return "test-pdl-bytecode-pass"; }
   StringRef getDescription() const final {