Add `Operation* OpState::operator->()` to provide more convenient access to members of Operation.

[csigg]

Summary

Given that OpState already implicit converts to Operator*, this seems reasonable.

The alternative would be to add more functions to OpState which forward to Operation.

[rriddle]

Much nicer, thanks!! We could probably remove some of the duplicated methods from Op now, the duplication doesn't bring a huge benefit IMO.

[csigg]

In D92266#2426800, @rriddle wrote:

Much nicer, thanks!! We could probably remove some of the duplicated methods from Op now, the duplication doesn't bring a huge benefit IMO.

Sure, I can do that.

mlir/examples/toy/Ch5/mlir/LowerToAffineLoops.cpp

 }
 
 /// Insert an allocation and deallocation for the given MemRefType.
 static Value insertAllocAndDealloc(MemRefType type, Location loc,
                                    PatternRewriter &rewriter) {
   auto alloc = rewriter.create<AllocOp>(loc, type);
 
   // Make sure to allocate at the beginning of the block.
-  auto *parentBlock = alloc.getOperation()->getBlock();
-  alloc.getOperation()->moveBefore(&parentBlock->front());
+  auto *parentBlock = alloc->getBlock();
+  alloc->moveBefore(&parentBlock->front());
 
   // Make sure to deallocate this alloc at the end of the block. This is fine
   // as toy functions have no control flow.
   auto dealloc = rewriter.create<DeallocOp>(loc, alloc);
-  dealloc.getOperation()->moveBefore(&parentBlock->back());
+  dealloc->moveBefore(&parentBlock->back());
   return alloc;
 }
 
 /// This defines the function type used to process an iteration of a lowered
 /// loop. It takes as input an OpBuilder, an range of memRefOperands
 /// corresponding to the operands of the input operation, and the range of loop
 /// induction variables for the iteration. It returns a value to store at the
 /// current index of the iteration.

mlir/examples/toy/Ch6/mlir/LowerToAffineLoops.cpp

 }
 
 /// Insert an allocation and deallocation for the given MemRefType.
 static Value insertAllocAndDealloc(MemRefType type, Location loc,
                                    PatternRewriter &rewriter) {
   auto alloc = rewriter.create<AllocOp>(loc, type);
 
   // Make sure to allocate at the beginning of the block.
-  auto *parentBlock = alloc.getOperation()->getBlock();
-  alloc.getOperation()->moveBefore(&parentBlock->front());
+  auto *parentBlock = alloc->getBlock();
+  alloc->moveBefore(&parentBlock->front());
 
   // Make sure to deallocate this alloc at the end of the block. This is fine
   // as toy functions have no control flow.
   auto dealloc = rewriter.create<DeallocOp>(loc, alloc);
-  dealloc.getOperation()->moveBefore(&parentBlock->back());
+  dealloc->moveBefore(&parentBlock->back());
   return alloc;
 }
 
 /// This defines the function type used to process an iteration of a lowered
 /// loop. It takes as input an OpBuilder, an range of memRefOperands
 /// corresponding to the operands of the input operation, and the range of loop
 /// induction variables for the iteration. It returns a value to store at the
 /// current index of the iteration.

mlir/examples/toy/Ch7/mlir/LowerToAffineLoops.cpp

 }
 
 /// Insert an allocation and deallocation for the given MemRefType.
 static Value insertAllocAndDealloc(MemRefType type, Location loc,
                                    PatternRewriter &rewriter) {
   auto alloc = rewriter.create<AllocOp>(loc, type);
 
   // Make sure to allocate at the beginning of the block.
-  auto *parentBlock = alloc.getOperation()->getBlock();
-  alloc.getOperation()->moveBefore(&parentBlock->front());
+  auto *parentBlock = alloc->getBlock();
+  alloc->moveBefore(&parentBlock->front());
 
   // Make sure to deallocate this alloc at the end of the block. This is fine
   // as toy functions have no control flow.
   auto dealloc = rewriter.create<DeallocOp>(loc, alloc);
-  dealloc.getOperation()->moveBefore(&parentBlock->back());
+  dealloc->moveBefore(&parentBlock->back());
   return alloc;
 }
 
 /// This defines the function type used to process an iteration of a lowered
 /// loop. It takes as input an OpBuilder, an range of memRefOperands
 /// corresponding to the operands of the input operation, and the range of loop
 /// induction variables for the iteration. It returns a value to store at the
 /// current index of the iteration.

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

InterfaceMethod<
         init_tensors operands.
       }],
       /*retTy=*/"Operation *",
       /*methodName=*/"clone",
       (ins "OpBuilder &":$b, "Location":$loc, "TypeRange":$resultTypes,
            "ValueRange":$operands),
       [{
         BlockAndValueMapping map;
-        unsigned numRegions = $_op.getOperation()->getNumRegions();
+        unsigned numRegions = $_op->getNumRegions();
         Operation *res = create(b, loc, resultTypes, operands, $_op.getAttrs());
         assert(res->getNumRegions() == numRegions && "inconsistent # regions");
         for (unsigned ridx = 0; ridx < numRegions; ++ridx)
-          $_op.getOperation()->getRegion(ridx).cloneInto(
+          $_op->getRegion(ridx).cloneInto(
             &res->getRegion(ridx), map);
         return res;
       }]
     >,
     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

mlir/include/mlir/Dialect/Vector/VectorTransforms.h

if (!maybeShapeRatio ||
         llvm::all_of(*maybeShapeRatio, [](int64_t v) { return v == 1; }))
       return failure();
     if (std::is_same<OpTy, TransferWriteOp>::value) {
       if (failed(unrollTransferWriteOp(rewriter, op, *targetShape)))
         return failure();
       rewriter.eraseOp(op);
       return success();
     }
-    if (op.getOperation()->getNumResults() != 1)
+    if (op->getNumResults() != 1)
       return failure();
     auto resultVector = unrollSingleResultVectorOp(rewriter, op, *targetShape);
     if (resultVector.size() != 1)
       return failure();
     rewriter.replaceOp(op, resultVector.front());
     return success();
   }
 

mlir/include/mlir/IR/OpDefinition.h

 class OpState {
 public:
   /// Ops are pointer-like, so we allow implicit conversion to bool.
   operator bool() { return getOperation() != nullptr; }
 
   /// This implicitly converts to Operation*.
   operator Operation *() const { return state; }
 
+  /// Shortcut of `->` to access a member of Operation.
+  Operation *operator->() const { return state; }
+
   /// Return the operation that this refers to.
   Operation *getOperation() { return state; }
 
   /// Return the dialect that this refers to.
   Dialect *getDialect() { return getOperation()->getDialect(); }
 
   /// Return the parent Region of this operation.
   Region *getParentRegion() { return getOperation()->getParentRegion(); }

mlir/include/mlir/Interfaces/VectorInterfaces.td

InterfaceMethod<
         `targetShape`. Return `None` if the op cannot be unrolled to the target
         vector shape.
       }],
       /*retTy=*/"Optional<SmallVector<int64_t, 4>>",
       /*methodName=*/"getShapeForUnroll",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        assert($_op.getOperation()->getNumResults() == 1);
+        assert($_op->getNumResults() == 1);
         auto vt = $_op.getResult().getType().
           template dyn_cast<VectorType>();
         if (!vt)
           return None;
         SmallVector<int64_t, 4> res(vt.getShape().begin(), vt.getShape().end());
         return res;
       }]
     >,

mlir/lib/Analysis/AffineAnalysis.cpp

 
 /// Gathers dependence components for dependences between all ops in loop nest
 /// rooted at 'forOp' at loop depths in range [1, maxLoopDepth].
 void mlir::getDependenceComponents(
     AffineForOp forOp, unsigned maxLoopDepth,
     std::vector<SmallVector<DependenceComponent, 2>> *depCompsVec) {
   // Collect all load and store ops in loop nest rooted at 'forOp'.
   SmallVector<Operation *, 8> loadAndStoreOps;
-  forOp.getOperation()->walk([&](Operation *op) {
+  forOp->walk([&](Operation *op) {
     if (isa<AffineReadOpInterface, AffineWriteOpInterface>(op))
       loadAndStoreOps.push_back(op);
   });
 
   unsigned numOps = loadAndStoreOps.size();
   for (unsigned d = 1; d <= maxLoopDepth; ++d) {
     for (unsigned i = 0; i < numOps; ++i) {
       auto *srcOp = loadAndStoreOps[i];

mlir/lib/Analysis/BufferAliasAnalysis.cpp

void BufferAliasAnalysis::build(Operation *op) {
   // Registers all aliases of the given values.
   auto registerAliases = [&](auto values, auto aliases) {
     for (auto entry : llvm::zip(values, aliases))
       this->aliases[std::get<0>(entry)].insert(std::get<1>(entry));
   };
 
   // Add additional aliases created by view changes to the alias list.
   op->walk([&](ViewLikeOpInterface viewInterface) {
-    aliases[viewInterface.getViewSource()].insert(
-        viewInterface.getOperation()->getResult(0));
+    aliases[viewInterface.getViewSource()].insert(viewInterface->getResult(0));
   });
 
   // Query all branch interfaces to link block argument aliases.
   op->walk([&](BranchOpInterface branchInterface) {
-    Block *parentBlock = branchInterface.getOperation()->getBlock();
+    Block *parentBlock = branchInterface->getBlock();
     for (auto it = parentBlock->succ_begin(), e = parentBlock->succ_end();
          it != e; ++it) {
       // Query the branch op interface to get the successor operands.
       auto successorOperands =
           branchInterface.getSuccessorOperands(it.getIndex());
       if (!successorOperands.hasValue())
         continue;
       // Build the actual mapping of values to their immediate aliases.
for (RegionSuccessor &entrySuccessor : entrySuccessors) {
       assert(entrySuccessor.getSuccessor() &&
              "Invalid entry region without an attached successor region");
       registerAliases(regionInterface.getSuccessorEntryOperands(
                           entrySuccessor.getSuccessor()->getRegionNumber()),
                       entrySuccessor.getSuccessorInputs());
     }
 
     // Wire flow between regions and from region exits.
-    for (Region &region : regionInterface.getOperation()->getRegions()) {
+    for (Region &region : regionInterface->getRegions()) {
       // Iterate over all successor region entries that are reachable from the
       // current region.
       SmallVector<RegionSuccessor, 2> successorRegions;
       regionInterface.getSuccessorRegions(region.getRegionNumber(),
                                           successorRegions);
       for (RegionSuccessor &successorRegion : successorRegions) {
         // Iterate over all immediate terminator operations and wire the
         // successor inputs with the operands of each terminator.

mlir/lib/Analysis/Utils.cpp

mlir::insertBackwardComputationSlice(Operation *srcOpInst, Operation *dstOpInst,
   if (dstLoopDepth > dstLoopIVsSize) {
     dstOpInst->emitError("invalid destination loop depth");
     return AffineForOp();
   }
 
   // Find the op block positions of 'srcOpInst' within 'srcLoopIVs'.
   SmallVector<unsigned, 4> positions;
   // TODO: This code is incorrect since srcLoopIVs can be 0-d.
-  findInstPosition(srcOpInst, srcLoopIVs[0].getOperation()->getBlock(),
-                   &positions);
+  findInstPosition(srcOpInst, srcLoopIVs[0]->getBlock(), &positions);
 
   // Clone src loop nest and insert it a the beginning of the operation block
   // of the loop at 'dstLoopDepth' in 'dstLoopIVs'.
   auto dstAffineForOp = dstLoopIVs[dstLoopDepth - 1];
   OpBuilder b(dstAffineForOp.getBody(), dstAffineForOp.getBody()->begin());
   auto sliceLoopNest =
       cast<AffineForOp>(b.clone(*srcLoopIVs[0].getOperation()));
 
return ::getMemoryFootprintBytes(
       *forInst->getBlock(), Block::iterator(forInst),
       std::next(Block::iterator(forInst)), memorySpace);
 }
 
 /// Returns in 'sequentialLoops' all sequential loops in loop nest rooted
 /// at 'forOp'.
 void mlir::getSequentialLoops(AffineForOp forOp,
                               llvm::SmallDenseSet<Value, 8> *sequentialLoops) {
-  forOp.getOperation()->walk([&](Operation *op) {
+  forOp->walk([&](Operation *op) {
     if (auto innerFor = dyn_cast<AffineForOp>(op))
       if (!isLoopParallel(innerFor))
         sequentialLoops->insert(innerFor.getInductionVar());
   });
 }
 
 /// Returns true if 'forOp' is parallel.
 bool mlir::isLoopParallel(AffineForOp forOp) {

mlir/lib/Conversion/AVX512ToLLVM/ConvertAVX512ToLLVM.cpp

matchAndRewriteOneToOne(const ConvertToLLVMPattern &lowering,
 
   auto newOp = rewriter.create<TargetOp>(op->getLoc(), packedType, operands,
                                          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.getOperation()->getResult(0)),
-           success();
+    return rewriter.replaceOp(op, newOp->getResult(0)), success();
 
   // Otherwise, it had been converted to an operation producing a structure.
   // Extract individual results from the structure and return them as list.
   SmallVector<Value, 4> results;
   results.reserve(numResults);
   for (unsigned i = 0; i < numResults; ++i) {
     auto type = typeConverter.convertType(op->getResult(i).getType());
     results.push_back(rewriter.create<LLVM::ExtractValueOp>(
-        op->getLoc(), type, newOp.getOperation()->getResult(0),
-        rewriter.getI64ArrayAttr(i)));
+        op->getLoc(), type, newOp->getResult(0), rewriter.getI64ArrayAttr(i)));
   }
   rewriter.replaceOp(op, results);
   return success();
 }
 
 namespace {
 // TODO: Patterns are too verbose due to the fact that we have 1 op (e.g.
 // MaskRndScaleOp) and different possible target ops. It would be better to take

mlir/lib/Conversion/GPUCommon/ConvertLaunchFuncToRuntimeCalls.cpp

LogicalResult ConvertAllocOpToGpuRuntimeCallPattern::matchAndRewrite(
   SmallVector<Value, 4> strides;
   Value sizeBytes;
   getMemRefDescriptorSizes(loc, memRefType, operands, rewriter, shape, strides,
                            sizeBytes);
 
   // Allocate the underlying buffer and store a pointer to it in the MemRef
   // descriptor.
   Type elementPtrType = this->getElementPtrType(memRefType);
-  auto adaptor = gpu::AllocOpAdaptor(
-      operands, allocOp.getOperation()->getAttrDictionary());
+  auto adaptor = gpu::AllocOpAdaptor(operands, allocOp->getAttrDictionary());
   auto stream = adaptor.asyncDependencies().front();
   Value allocatedPtr =
       allocCallBuilder.create(loc, rewriter, {sizeBytes, stream}).getResult(0);
   allocatedPtr =
       rewriter.create<LLVM::BitcastOp>(loc, elementPtrType, allocatedPtr);
 
   // No alignment.
   Value alignedPtr = allocatedPtr;
LogicalResult ConvertDeallocOpToGpuRuntimeCallPattern::matchAndRewrite(
     gpu::DeallocOp deallocOp, ArrayRef<Value> operands,
     ConversionPatternRewriter &rewriter) const {
   if (failed(areAllLLVMTypes(deallocOp, operands, rewriter)) ||
       failed(isAsyncWithOneDependency(rewriter, deallocOp)))
     return failure();
 
   Location loc = deallocOp.getLoc();
 
-  auto adaptor = gpu::DeallocOpAdaptor(
-      operands, deallocOp.getOperation()->getAttrDictionary());
+  auto adaptor =
+      gpu::DeallocOpAdaptor(operands, deallocOp->getAttrDictionary());
   Value pointer =
       MemRefDescriptor(adaptor.memref()).allocatedPtr(rewriter, loc);
   auto casted = rewriter.create<LLVM::BitcastOp>(loc, llvmPointerType, pointer);
   Value stream = adaptor.asyncDependencies().front();
   deallocCallBuilder.create(loc, rewriter, {casted, stream});
 
   rewriter.replaceOp(deallocOp, {stream});
   return success();
LogicalResult ConvertWaitAsyncOpToGpuRuntimeCallPattern::matchAndRewrite(
   SmallVector<Value, 1> events;
   for (auto pair : llvm::zip(waitOp.asyncDependencies(), operands)) {
     auto token = std::get<0>(pair);
     if (auto *defOp = token.getDefiningOp()) {
       rewriter.setInsertionPointAfter(defOp);
     } else {
       // If we can't find the defining op, we record the event at block start,
       // which is late and therefore misses parallelism, but still valid.
-      rewriter.setInsertionPointToStart(waitOp.getOperation()->getBlock());
+      rewriter.setInsertionPointToStart(waitOp->getBlock());
     }
     auto event = eventCreateCallBuilder.create(loc, rewriter, {}).getResult(0);
     auto stream = std::get<1>(pair);
     eventRecordCallBuilder.create(loc, rewriter, {event, stream});
     events.push_back(event);
   }
   rewriter.restoreInsertionPoint(insertionPoint);
   auto stream = streamCreateCallBuilder.create(loc, rewriter, {}).getResult(0);
LogicalResult ConvertLaunchFuncOpToGpuRuntimeCallPattern::matchAndRewrite(
   // Get the function from the module. The name corresponds to the name of
   // the kernel function.
   auto kernelName = generateKernelNameConstant(
       launchOp.getKernelModuleName(), launchOp.getKernelName(), loc, rewriter);
   auto function = moduleGetFunctionCallBuilder.create(
       loc, rewriter, {module.getResult(0), kernelName});
   auto zero = rewriter.create<LLVM::ConstantOp>(loc, llvmInt32Type,
                                                 rewriter.getI32IntegerAttr(0));
-  auto adaptor = gpu::LaunchFuncOpAdaptor(
-      operands, launchOp.getOperation()->getAttrDictionary());
+  auto adaptor =
+      gpu::LaunchFuncOpAdaptor(operands, launchOp->getAttrDictionary());
   Value stream =
       adaptor.asyncDependencies().empty()
           ? streamCreateCallBuilder.create(loc, rewriter, {}).getResult(0)
           : adaptor.asyncDependencies().front();
   // Create array of pointers to kernel arguments.
   auto kernelParams = generateParamsArray(launchOp, operands, rewriter);
   auto nullpointer = rewriter.create<LLVM::NullOp>(loc, llvmPointerPointerType);
   launchKernelCallBuilder.create(loc, rewriter,

mlir/lib/Conversion/PDLToPDLInterp/PDLToPDLInterp.cpp

void PatternLowering::generateRewriter(
   }
 }
 
 void PatternLowering::generateOperationResultTypeRewriter(
     pdl::OperationOp op, SmallVectorImpl<Value> &types,
     DenseMap<Value, Value> &rewriteValues,
     function_ref<Value(Value)> mapRewriteValue) {
   // Functor that returns if the given use can be used to infer a type.
-  Block *rewriterBlock = op.getOperation()->getBlock();
+  Block *rewriterBlock = op->getBlock();
   auto getReplacedOperationFrom = [&](OpOperand &use) -> Operation * {
     // Check that the use corresponds to a ReplaceOp and that it is the
     // replacement value, not the operation being replaced.
     pdl::ReplaceOp replOpUser = dyn_cast<pdl::ReplaceOp>(use.getOwner());
     if (!replOpUser || use.getOperandNumber() == 0)
       return nullptr;
     // Make sure the replaced operation was defined before this one.
     Operation *replacedOp = replOpUser.operation().getDefiningOp();

mlir/lib/Conversion/SCFToOpenMP/SCFToOpenMP.cpp

static void insertOpenMPParallel(FuncOp func) {
   });
 
   // Wrap SCF ops into OpenMP "parallel" ops.
   for (scf::ParallelOp parallelOp : topLevelParallelOps) {
     OpBuilder builder(parallelOp);
     auto omp = builder.create<omp::ParallelOp>(parallelOp.getLoc());
     Block *block = builder.createBlock(&omp.getRegion());
     builder.create<omp::TerminatorOp>(parallelOp.getLoc());
-    block->getOperations().splice(
-        block->begin(), parallelOp.getOperation()->getBlock()->getOperations(),
+    block->getOperations().splice(block->begin(),
+                                  parallelOp->getBlock()->getOperations(),
                                   parallelOp.getOperation());
   }
 }
 
 /// Applies the conversion patterns in the given function.
 static LogicalResult applyPatterns(FuncOp func) {
   ConversionTarget target(*func.getContext());
   target.addIllegalOp<scf::ParallelOp>();
   target.addDynamicallyLegalOp<scf::YieldOp>(

mlir/lib/Conversion/SCFToSPIRV/SCFToSPIRV.cpp

ForOpConversion::matchAndRewrite(scf::ForOp forOp, ArrayRef<Value> operands,
   signatureConverter.remapInput(0, newIndVar);
   for (unsigned i = 1, e = body->getNumArguments(); i < e; i++)
     signatureConverter.remapInput(i, header->getArgument(i));
   body = rewriter.applySignatureConversion(&forOp.getLoopBody(),
                                            signatureConverter);
 
   // Move the blocks from the forOp into the loopOp. This is the body of the
   // loopOp.
-  rewriter.inlineRegionBefore(forOp.getOperation()->getRegion(0), loopOp.body(),
+  rewriter.inlineRegionBefore(forOp->getRegion(0), loopOp.body(),
                               std::next(loopOp.body().begin(), 2));
 
   SmallVector<Value, 8> args(1, forOperands.lowerBound());
   args.append(forOperands.initArgs().begin(), forOperands.initArgs().end());
   // Branch into it from the entry.
   rewriter.setInsertionPointToEnd(&(loopOp.body().front()));
   rewriter.create<spirv::BranchOp>(loc, header, args);
 

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

matchAndRewrite(CallOpType callOp, ArrayRef<Value> operands,
 
     if (numResults != 0) {
       if (!(packedResult =
                 this->typeConverter.packFunctionResults(resultTypes)))
         return failure();
     }
 
     auto promoted = this->typeConverter.promoteOperands(
-        callOp.getLoc(), /*opOperands=*/callOp.getOperation()->getOperands(),
-        operands, rewriter);
+        callOp.getLoc(), /*opOperands=*/callOp->getOperands(), operands,
+        rewriter);
     auto newOp = rewriter.create<LLVM::CallOp>(
         callOp.getLoc(), packedResult ? TypeRange(packedResult) : TypeRange(),
         promoted, callOp.getAttrs());
 
     SmallVector<Value, 4> results;
     if (numResults < 2) {
       // If < 2 results, packing did not do anything and we can just return.
       results.append(newOp.result_begin(), newOp.result_end());
     } else {
       // Otherwise, it had been converted to an operation producing a structure.
       // Extract individual results from the structure and return them as list.
       results.reserve(numResults);
       for (unsigned i = 0; i < numResults; ++i) {
         auto type =
             this->typeConverter.convertType(callOp.getResult(i).getType());
         results.push_back(rewriter.create<LLVM::ExtractValueOp>(
-            callOp.getLoc(), type, newOp.getOperation()->getResult(0),
+            callOp.getLoc(), type, newOp->getResult(0),
             rewriter.getI64ArrayAttr(i)));
       }
     }
 
     if (this->typeConverter.getOptions().useBarePtrCallConv) {
       // For the bare-ptr calling convention, promote memref results to
       // descriptors.
       assert(results.size() == resultTypes.size() &&

 
 struct MemRefReinterpretCastOpLowering
     : public ConvertOpToLLVMPattern<MemRefReinterpretCastOp> {
   using ConvertOpToLLVMPattern<MemRefReinterpretCastOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
   matchAndRewrite(MemRefReinterpretCastOp castOp, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
-    MemRefReinterpretCastOp::Adaptor adaptor(
-        operands, castOp.getOperation()->getAttrDictionary());
+    MemRefReinterpretCastOp::Adaptor adaptor(operands,
+                                             castOp->getAttrDictionary());
     Type srcType = castOp.source().getType();
 
     Value descriptor;
     if (failed(convertSourceMemRefToDescriptor(rewriter, srcType, castOp,
                                                adaptor, &descriptor)))
       return failure();
     rewriter.replaceOp(castOp, {descriptor});
     return success();

 struct OneToOneLLVMTerminatorLowering
     : public ConvertOpToLLVMPattern<SourceOp> {
   using ConvertOpToLLVMPattern<SourceOp>::ConvertOpToLLVMPattern;
   using Super = OneToOneLLVMTerminatorLowering<SourceOp, TargetOp>;
 
   LogicalResult
   matchAndRewrite(SourceOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
-    rewriter.replaceOpWithNewOp<TargetOp>(
-        op, operands, op.getOperation()->getSuccessors(), op.getAttrs());
+    rewriter.replaceOpWithNewOp<TargetOp>(op, operands, op->getSuccessors(),
+                                          op.getAttrs());
     return success();
   }
 };
 
 // Special lowering pattern for `ReturnOps`.  Unlike all other operations,
 // `ReturnOp` interacts with the function signature and must have as many
 // operands as the function has return values.  Because in LLVM IR, functions
 // can only return 0 or 1 value, we pack multiple values into a structure type.
 // Emit `UndefOp` followed by `InsertValueOp`s to create such structure if
 // necessary before returning it
 struct ReturnOpLowering : public ConvertOpToLLVMPattern<ReturnOp> {
   using ConvertOpToLLVMPattern<ReturnOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
   matchAndRewrite(ReturnOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     Location loc = op.getLoc();
     unsigned numArguments = op.getNumOperands();
     SmallVector<Value, 4> updatedOperands;
 
     if (typeConverter.getOptions().useBarePtrCallConv) {
       // For the bare-ptr calling convention, extract the aligned pointer to
       // be returned from the memref descriptor.
-      for (auto it : llvm::zip(op.getOperation()->getOperands(), operands)) {
+      for (auto it : llvm::zip(op->getOperands(), operands)) {
         Type oldTy = std::get<0>(it).getType();
         Value newOperand = std::get<1>(it);
         if (oldTy.isa<MemRefType>()) {
           MemRefDescriptor memrefDesc(newOperand);
           newOperand = memrefDesc.alignedPtr(rewriter, loc);
         } else if (oldTy.isa<UnrankedMemRefType>()) {
           // Unranked memref is not supported in the bare pointer calling
           // convention.
matchAndRewrite(GenericAtomicRMWOp atomicOp, ArrayRef<Value> operands,
     auto *initBlock = rewriter.getInsertionBlock();
     auto *loopBlock =
         rewriter.createBlock(initBlock->getParent(),
                              std::next(Region::iterator(initBlock)), valueType);
     auto *endBlock = rewriter.createBlock(
         loopBlock->getParent(), std::next(Region::iterator(loopBlock)));
 
     // Operations range to be moved to `endBlock`.
-    auto opsToMoveStart = atomicOp.getOperation()->getIterator();
+    auto opsToMoveStart = atomicOp->getIterator();
     auto opsToMoveEnd = initBlock->back().getIterator();
 
     // Compute the loaded value and branch to the loop block.
     rewriter.setInsertionPointToEnd(initBlock);
     auto memRefType = atomicOp.memref().getType().cast<MemRefType>();
     auto dataPtr = getStridedElementPtr(loc, memRefType, adaptor.memref(),
                                         adaptor.indices(), rewriter);
     Value init = rewriter.create<LLVM::LoadOp>(loc, dataPtr);

mlir/lib/Conversion/StandardToSPIRV/ConvertStandardToSPIRV.cpp

static Value adjustAccessChainForBitwidth(SPIRVTypeConverter &typeConverter,
                                           int sourceBits, int targetBits,
                                           OpBuilder &builder) {
   assert(targetBits % sourceBits == 0);
   const auto loc = op.getLoc();
   IntegerType targetType = builder.getIntegerType(targetBits);
   IntegerAttr attr =
       builder.getIntegerAttr(targetType, targetBits / sourceBits);
   auto idx = builder.create<spirv::ConstantOp>(loc, targetType, attr);
-  auto lastDim = op.getOperation()->getOperand(op.getNumOperands() - 1);
+  auto lastDim = op->getOperand(op.getNumOperands() - 1);
   auto indices = llvm::to_vector<4>(op.indices());
   // There are two elements if this is a 1-D tensor.
   assert(indices.size() == 2);
   indices.back() = builder.create<spirv::SDivOp>(loc, lastDim, idx);
   Type t = typeConverter.convertType(op.component_ptr().getType());
   return builder.create<spirv::AccessChainOp>(loc, t, op.base_ptr(), indices);
 }
 
IntLoadOpPattern::matchAndRewrite(LoadOp loadOp, ArrayRef<Value> operands,
   Value spvLoadOp = rewriter.create<spirv::LoadOp>(
       loc, dstType, adjustedPtr,
       loadOp.getAttrOfType<IntegerAttr>(
           spirv::attributeName<spirv::MemoryAccess>()),
       loadOp.getAttrOfType<IntegerAttr>("alignment"));
 
   // Shift the bits to the rightmost.
   // ____XXXX________ -> ____________XXXX
-  Value lastDim = accessChainOp.getOperation()->getOperand(
-      accessChainOp.getNumOperands() - 1);
+  Value lastDim = accessChainOp->getOperand(accessChainOp.getNumOperands() - 1);
   Value offset = getOffsetForBitwidth(loc, lastDim, srcBits, dstBits, rewriter);
   Value result = rewriter.create<spirv::ShiftRightArithmeticOp>(
       loc, spvLoadOp.getType(), spvLoadOp, offset);
 
   // Apply the mask to extract corresponding bits.
   Value mask = rewriter.create<spirv::ConstantOp>(
       loc, dstType, rewriter.getIntegerAttr(dstType, (1 << srcBits) - 1));
   result = rewriter.create<spirv::BitwiseAndOp>(loc, dstType, result, mask);
IntStoreOpPattern::matchAndRewrite(StoreOp storeOp, ArrayRef<Value> operands,
   // 2) clear 8 bits in the loading value
   // 3) store 32-bit value back
   // 4) load a 32-bit integer
   // 5) modify 8 bits in the loading value
   // 6) store 32-bit value back
   // The step 1 to step 3 are done by AtomicAnd as one atomic step, and the step
   // 4 to step 6 are done by AtomicOr as another atomic step.
   assert(accessChainOp.indices().size() == 2);
-  Value lastDim = accessChainOp.getOperation()->getOperand(
-      accessChainOp.getNumOperands() - 1);
+  Value lastDim = accessChainOp->getOperand(accessChainOp.getNumOperands() - 1);
   Value offset = getOffsetForBitwidth(loc, lastDim, srcBits, dstBits, rewriter);
 
   // Create a mask to clear the destination. E.g., if it is the second i8 in
   // i32, 0xFFFF00FF is created.
   Value mask = rewriter.create<spirv::ConstantOp>(
       loc, dstType, rewriter.getIntegerAttr(dstType, (1 << srcBits) - 1));
   Value clearBitsMask =
       rewriter.create<spirv::ShiftLeftLogicalOp>(loc, dstType, mask, offset);

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

AffineApplyNormalizer::AffineApplyNormalizer(AffineMap map,
   } else {
     assert(numDimsBeforeRewrite <= operands.size());
     // 2. Compose AffineApplyOps and dispatch dims or symbols.
     for (unsigned i = 0, e = operands.size(); i < e; ++i) {
       auto t = operands[i];
       auto affineApply = t.getDefiningOp<AffineApplyOp>();
       if (affineApply) {
         // a. Compose affine.apply operations.
-        LLVM_DEBUG(affineApply.getOperation()->print(
+        LLVM_DEBUG(affineApply->print(
             dbgs() << "\nCompose AffineApplyOp recursively: "));
         AffineMap affineApplyMap = affineApply.getAffineMap();
         SmallVector<Value, 8> affineApplyOperands(
             affineApply.getOperands().begin(), affineApply.getOperands().end());
         AffineApplyNormalizer normalizer(affineApplyMap, affineApplyOperands);
 
         LLVM_DEBUG(normalizer.affineMap.print(
             dbgs() << "\nRenumber into current normalizer: "));

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

void LoopInvariantCodeMotion::runOnAffineForOp(AffineForOp forOp) {
   }
 
   // For all instructions that we found to be invariant, place sequentially
   // right before the for loop.
   for (auto *op : opsToMove) {
     op->moveBefore(forOp);
   }
 
-  LLVM_DEBUG(forOp.getOperation()->print(llvm::dbgs() << "Modified loop\n"));
+  LLVM_DEBUG(forOp->print(llvm::dbgs() << "Modified loop\n"));
 }
 
 void LoopInvariantCodeMotion::runOnFunction() {
   // Walk through all loops in a function in innermost-loop-first order.  This
   // way, we first LICM from the inner loop, and place the ops in
   // the outer loop, which in turn can be further LICM'ed.
   getFunction().walk([&](AffineForOp op) {
-    LLVM_DEBUG(op.getOperation()->print(llvm::dbgs() << "\nOriginal loop\n"));
+    LLVM_DEBUG(op->print(llvm::dbgs() << "\nOriginal loop\n"));
     runOnAffineForOp(op);
   });
 }
 
 std::unique_ptr<OperationPass<FuncOp>>
 mlir::createAffineLoopInvariantCodeMotionPass() {
   return std::make_unique<LoopInvariantCodeMotion>();
 }

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

verifyLoopNesting(const std::vector<SmallVector<AffineForOp, 2>> &loops) {
 
   // Traverse loops outer-to-inner to check some invariants.
   for (int i = 1, end = loops.size(); i < end; ++i) {
     for (AffineForOp loop : loops[i]) {
       //  Check that each loop at this level is nested in one of the loops from
       //  the previous level.
       bool parentFound = false;
       for (AffineForOp maybeParent : loops[i - 1]) {
-        if (maybeParent.getOperation()->isProperAncestor(loop)) {
+        if (maybeParent->isProperAncestor(loop)) {
           parentFound = true;
           break;
         }
       }
       assert(parentFound && "Child loop not nested in any parent loop");
 
       //  Check that each loop at this level is not nested in another loop from
       //  this level.
 #ifndef NDEBUG
       for (AffineForOp sibling : loops[i])
-        assert(!sibling.getOperation()->isProperAncestor(loop) &&
+        assert(!sibling->isProperAncestor(loop) &&
                "Loops at the same level are nested");
 #endif
     }
   }
 }
 
 namespace mlir {
 

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

 
 /// Promotes the `then` or the `else` block of `ifOp` (depending on whether
 /// `elseBlock` is false or true) into `ifOp`'s containing block, and discards
 /// the rest of the op.
 static void promoteIfBlock(AffineIfOp ifOp, bool elseBlock) {
   if (elseBlock)
     assert(ifOp.hasElse() && "else block expected");
 
-  Block *destBlock = ifOp.getOperation()->getBlock();
+  Block *destBlock = ifOp->getBlock();
   Block *srcBlock = elseBlock ? ifOp.getElseBlock() : ifOp.getThenBlock();
   destBlock->getOperations().splice(
       Block::iterator(ifOp), srcBlock->getOperations(), srcBlock->begin(),
       std::prev(srcBlock->end()));
   ifOp.erase();
 }
 
 /// Returns the outermost affine.for/parallel op that the `ifOp` is invariant

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

for (auto &kv : blockUsers) {
     //
     // Mapping from `dropRef.getOperation()` to `addRef.getOperation()`.
     llvm::SmallDenseMap<Operation *, Operation *> cancellable;
 
     for (AddRefOp addRef : info.addRefs) {
       for (DropRefOp dropRef : info.dropRefs) {
         // `drop_ref` operation after the `add_ref` with matching count.
         if (dropRef.count() != addRef.count() ||
-            dropRef.getOperation()->isBeforeInBlock(addRef.getOperation()))
+            dropRef->isBeforeInBlock(addRef.getOperation()))
           continue;
 
         // `drop_ref` was already marked for removal.
         if (cancellable.find(dropRef.getOperation()) != cancellable.end())
           continue;
 
         // Check `value` users between `addRef` and `dropRef` in the `block`.
         Operation *addRefOp = addRef.getOperation();

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

static ParseResult parseGPUModuleOp(OpAsmParser &parser,
   return success();
 }
 
 static void print(OpAsmPrinter &p, GPUModuleOp op) {
   p << op.getOperationName() << ' ';
   p.printSymbolName(op.getName());
   p.printOptionalAttrDictWithKeyword(op.getAttrs(),
                                      {SymbolTable::getSymbolAttrName()});
-  p.printRegion(op.getOperation()->getRegion(0), /*printEntryBlockArgs=*/false,
+  p.printRegion(op->getRegion(0), /*printEntryBlockArgs=*/false,
                 /*printBlockTerminators=*/false);
 }
 
 static ParseResult parseAsyncDependencies(
     OpAsmParser &parser, Type &asyncTokenType,
     SmallVectorImpl<OpAsmParser::OperandType> &asyncDependencies) {
   auto loc = parser.getCurrentLocation();
   if (succeeded(parser.parseOptionalKeyword("async"))) {

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

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

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

 static LogicalResult
 allocateBuffersForResults(Location loc, LinalgOp linalgOp,
                           linalg::GenericOpAdaptor &adaptor,
                           SmallVectorImpl<Value> &resultBuffers, OpBuilder &b) {
   // Lazily compute loopRanges.
   SmallVector<Range, 4> loopRanges;
 
   // Allocate a buffer for every tensor result.
-  for (auto en : llvm::enumerate(linalgOp.getOperation()->getResultTypes())) {
+  for (auto en : llvm::enumerate(linalgOp->getResultTypes())) {
     size_t resultIndex = en.index();
     Type resultType = en.value();
 
     auto tensorType = resultType.dyn_cast<RankedTensorType>();
     if (tensorType == nullptr) {
       linalgOp.emitOpError()
           << "tensor to buffer conversion expects ranked tensor results";
       return failure();

 /// std::CopyOp.
 class SubTensorOpConverter : public OpConversionPattern<SubTensorOp> {
 public:
   using OpConversionPattern<SubTensorOp>::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(SubTensorOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const final {
-    SubTensorOpAdaptor adaptor(operands,
-                               op.getOperation()->getAttrDictionary());
+    SubTensorOpAdaptor adaptor(operands, op->getAttrDictionary());
     Value sourceMemref = adaptor.source();
     assert(sourceMemref.getType().isa<MemRefType>());
 
     MemRefType subviewMemRefType =
         getTypeConverter()->convertType(op.getType()).cast<MemRefType>();
     // op.sizes() capture exactly the dynamic alloc operands matching the
     // subviewMemRefType thanks to subview/subtensor canonicalization and
     // verification.

 class SubTensorInsertOpConverter
     : public OpConversionPattern<SubTensorInsertOp> {
 public:
   using OpConversionPattern<SubTensorInsertOp>::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(SubTensorInsertOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const final {
-    SubTensorInsertOpAdaptor adaptor(operands,
-                                     op.getOperation()->getAttrDictionary());
+    SubTensorInsertOpAdaptor adaptor(operands, op->getAttrDictionary());
     Value sourceMemRef = adaptor.source();
     assert(sourceMemRef.getType().isa<MemRefType>());
 
     // For now, be conservative and copy the converted input memref.
     // In general, the converted input memref here could be aliased or could
     // point into constant memory, so mutating it would lead to miscompilations.
     Value destMemRef = cloneMemref(op.getLoc(), adaptor.dest(), rewriter);
     assert(destMemRef.getType().isa<MemRefType>());

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

replaceBlockArgForUnitDimLoops(OpTy op, const DenseSet<unsigned> &unitDims,
   return success();
 }
 
 template <>
 LogicalResult replaceBlockArgForUnitDimLoops<IndexedGenericOp>(
     IndexedGenericOp op, const DenseSet<unsigned> &unitDims,
     PatternRewriter &rewriter) {
   OpBuilder::InsertionGuard guard(rewriter);
-  Block *entryBlock = &op.getOperation()->getRegion(0).front();
+  Block *entryBlock = &op->getRegion(0).front();
   rewriter.setInsertionPointToStart(entryBlock);
   Value zero = rewriter.create<ConstantIndexOp>(op.getLoc(), 0);
   for (unsigned unitDimLoop : unitDims) {
     entryBlock->getArgument(unitDimLoop).replaceAllUsesWith(zero);
   }
   SmallVector<unsigned, 8> unitDimsToErase(unitDims.begin(), unitDims.end());
   entryBlock->eraseArguments(unitDimsToErase);
   return success();

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

static LinalgOp cloneWithLoopRanges(OpBuilder &b, Location loc, LinalgOp op,
   auto operands = op.getAssumedNonShapedOperands();
   clonedShapes.append(operands.begin(), operands.end());
 
   // Iterate over the results in order.
   // Extract the subtensor type from the linearized range.
   // Since we do not enforce any canonicalizations on the fly, this is always
   // fully dynamic at construction time.
   SmallVector<Type, 4> resultTypes;
-  resultTypes.reserve(op.getOperation()->getNumResults());
+  resultTypes.reserve(op->getNumResults());
   for (RankedTensorType t : op.getOutputTensorTypes()) {
     unsigned rank = t.getRank();
     SmallVector<int64_t, 4> staticOffsetsVector(
         rank, ShapedType::kDynamicStrideOrOffset);
     SmallVector<int64_t, 4> staticSizesVector(rank, ShapedType::kDynamicSize);
     SmallVector<int64_t, 4> staticStridesVector(
         rank, ShapedType::kDynamicStrideOrOffset);
     resultTypes.push_back(SubTensorOp::inferResultType(
static bool isStructurallyFusableProducer(LinalgOp producer, Value consumedView,
   assert(consumer.hasBufferSemantics() &&
          "expected linalg op with buffer semantics");
   if (producer.getNumOutputs() != 1) {
     LLVM_DEBUG(llvm::dbgs() << "\nNot structurally fusable (multi-output)");
     return false;
   }
   // Only fuse when the producer block dominates.
   DominanceInfo dom(producer.getOperation());
-  if (!dom.dominates(producer.getOperation()->getBlock(),
-                     consumer.getOperation()->getBlock())) {
+  if (!dom.dominates(producer->getBlock(), consumer->getBlock())) {
     LLVM_DEBUG(
         llvm::dbgs()
         << "\nNot structurally fusable (producer block does not dominate)");
     return false;
   }
   return true;
 }
 
mlir::linalg::fuseProducerOfBuffer(OpBuilder &b, LinalgOp consumer,
                                    const LinalgDependenceGraph &graph) {
   Optional<LinalgDependenceGraph::LinalgDependenceGraphElem> fusableDependence =
       findFusableProducer(consumer, consumerIdx, graph);
   if (!fusableDependence)
     return {};
 
   LinalgOp producerOp = cast<LinalgOp>(fusableDependence->dependentOpView.op);
   // If producer is already in the same block as consumer, we are done.
-  if (consumer.getOperation()->getBlock() ==
-      producerOp.getOperation()->getBlock())
+  if (consumer->getBlock() == producerOp->getBlock())
     return {};
 
   unsigned producerIdx = fusableDependence->dependentOpView.operandIndex -
                          producerOp.getNumInputs();
   Value consumerView = consumer.getShapedOperand(consumerIdx);
 
   // Must be a subview or a slice to guarantee there are loops we can fuse
   // into.
Optional<FusionInfo> mlir::linalg::fuseProducerOfTensor(OpBuilder &b,
   // Must be a subtensor to guarantee there are loops we can fuse into.
   auto subTensor = inputTensor.getDefiningOp<SubTensorOp>();
   if (!subTensor || !producerOp) {
     LLVM_DEBUG(llvm::dbgs() << "\nNot fusable (not a subtensor)");
     return {};
   }
 
   // If producer is already in the same block as consumer, we are done.
-  if (consumer.getOperation()->getBlock() ==
-      producerOp.getOperation()->getBlock())
+  if (consumer->getBlock() == producerOp->getBlock())
     return {};
 
   // Insert fused `producer` just before `consumer`.
   OpBuilder::InsertionGuard g(b);
   b.setInsertionPoint(consumer.getOperation());
   ScopedContext scope(b, consumer.getLoc());
   LLVM_DEBUG(llvm::dbgs() << "Fuse into consumer: " << *consumer << "\n");
   LinalgOp fusedProducer =
       fuse(b, producerOp, producerIdx, consumer, consumerIdx);
 
   // Replace use.
   // Canonicalizations are not guaranteed to have happened before constructing
   // `fusedProducer`. In the tensor case this can result in temporary type
   // mismatches. Insert a `tensor_cast` op to propagate the transformation
   // invariant that types are compatible.
-  Value def = fusedProducer.getOperation()->getResult(producerIdx);
-  OpOperand &use = consumer.getOperation()->getOpOperand(consumerIdx);
+  Value def = fusedProducer->getResult(producerIdx);
+  OpOperand &use = consumer->getOpOperand(consumerIdx);
   Type consumerType = use.get().getType();
   if (consumerType != def.getType())
     def = b.create<TensorCastOp>(fusedProducer.getLoc(), consumerType, def);
   use.set(def);
   return FusionInfo{producerOp, fusedProducer};
 }
 
 /// Prune all dimensions that are of reduction iterator type from `map`.
for (auto operandIndex :
               findFusableProducer(op, operandIndex, dependenceGraph);
       if (!fusableDependence)
         continue;
       LinalgOp producerOp =
           cast<LinalgOp>(fusableDependence->dependentOpView.op);
       // Do not fuse dependences that are to operations not in the same basic
       // block. This avoid moving fused operations across loops that might
       // themselves carry dependency making the fusion illegal.
-      if (producerOp.getOperation()->getBlock() !=
-          op.getOperation()->getBlock()) {
+      if (producerOp->getBlock() != op->getBlock()) {
         op.emitRemark("unhandled fusion of ops in different basic blocks");
         return FusableOpDependencesTy{};
       }
       // Make sure that the indexing map of the view used for fusion in the
       // producer is a projected permutation.
       unsigned producerIdx = fusableDependence->dependentOpView.operandIndex;
       AffineMap producerMap = producerOp.getIndexingMap(producerIdx);
       if (!producerMap.isProjectedPermutation()) {

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

 /// Generate the region of the fused tensor operation. The region of the fused
 /// op must be empty.
 static void generateFusedTensorOpRegion(PatternRewriter &rewriter,
                                         Operation *fusedOp, LinalgOp producer,
                                         LinalgOp consumer,
                                         AffineMap consumerToProducerLoopsMap,
                                         unsigned consumerIdx, unsigned nloops) {
   // Build the region of the fused op.
-  Block &producerBlock = producer.getOperation()->getRegion(0).front();
-  Block &consumerBlock = consumer.getOperation()->getRegion(0).front();
+  Block &producerBlock = producer->getRegion(0).front();
+  Block &consumerBlock = consumer->getRegion(0).front();
   Block *fusedBlock = new Block();
   fusedOp->getRegion(0).push_back(fusedBlock);
   BlockAndValueMapping mapper;
   OpBuilder::InsertionGuard guard(rewriter);
   rewriter.setInsertionPointToStart(fusedBlock);
 
   // The block arguments are
   // [index_0, index_1, ... ,
fuseTensorOpsImpl(LinalgOp producer, LinalgOp consumer, unsigned consumerIdx,
   fusedIndexMaps.append(std::next(consumerIndexMaps.begin(), consumerIdx + 1),
                         consumerIndexMaps.end());
 
   // Generate the fused op.
   // Tensor-level fusion is only on ops without initTensors and outputBuffers.
   LinalgOp fusedOp;
   if (isa<GenericOp>(producer.getOperation()) &&
       isa<GenericOp>(consumer.getOperation())) {
-    fusedOp = rewriter
-                  .create<GenericOp>(consumer.getLoc(),
-                                     consumer.getOperation()->getResultTypes(),
-                                     /*inputs=*/fusedOperands,
-                                     /*outputBuffers=*/ValueRange{},
-                                     /*initTensors=*/ValueRange{},
-                                     rewriter.getArrayAttr(fusedIndexMaps),
-                                     consumer.iterator_types(),
-                                     /*doc=*/nullptr,
-                                     /*library_call=*/nullptr,
-                                     /*sparse=*/nullptr)
-                  .getOperation();
+    fusedOp =
+        rewriter
+            .create<GenericOp>(consumer.getLoc(), consumer->getResultTypes(),
   } else {
-    fusedOp =
-        rewriter
-            .create<IndexedGenericOp>(consumer.getLoc(),
-                                      consumer.getOperation()->getResultTypes(),
-                                      /*inputs=*/fusedOperands,
-                                      /*outputBuffers=*/ValueRange{},
-                                      /*initTensors=*/ValueRange{},
-                                      rewriter.getArrayAttr(fusedIndexMaps),
-                                      consumer.iterator_types(),
-                                      /*doc=*/nullptr,
-                                      /*library_call=*/nullptr,
-                                      /*sparse=*/nullptr)
+    fusedOp = rewriter
+                  .create<IndexedGenericOp>(
+                      consumer.getLoc(), consumer->getResultTypes(),
                   .getOperation();
   }
 
   // Construct an AffineMap from consumer loops to producer loops.
   // consumer loop -> tensor index
   AffineMap consumerResultIndexMap = consumer.getInputIndexingMap(consumerIdx);
   // producer loop -> tensor index
   AffineMap producerResultIndexMap = producer.getOutputIndexingMap(0);
   // tensor index -> producer loop
   AffineMap invProducerResultIndexMap =
       inversePermutation(producerResultIndexMap);
   assert(invProducerResultIndexMap &&
          "expected producer result indexig map to be invertible");
   // consumer loop -> producer loop
   AffineMap consumerToProducerLoopsMap =
       invProducerResultIndexMap.compose(consumerResultIndexMap);
 
   generateFusedTensorOpRegion(rewriter, fusedOp.getOperation(), producer,
                               consumer, consumerToProducerLoopsMap, consumerIdx,
                               consumer.getNumLoops());
-  return SmallVector<Value, 1>(fusedOp.getOperation()->getResults());
+  return SmallVector<Value, 1>(fusedOp->getResults());
 }
 
 /// Linearize the expressions in `sourceMap` based on the `reassociationMaps`
 /// provided, given the shape of the source tensor that corresponds to the
 /// `sourceMap`. Note that this implicitly assumes that the tensors dimensions
 /// are "row-major" ordered logically.
 ///
 /// For example:
if (expandedOperandType != operand.value().getType()) {
           linalgOp.getLoc(), expandedOperandType, operand.value(),
           reassociation));
     } else {
       expandedOpOperands.push_back(operand.value());
     }
   }
   SmallVector<Type, 1> resultTypes;
   SmallVector<SmallVector<ReassociationIndices, 4>, 1> resultReassociation;
-  for (auto result : llvm::enumerate(linalgOp.getOperation()->getResults())) {
+  for (auto result : llvm::enumerate(linalgOp->getResults())) {
     AffineMap indexingMap =
         linalgOp.getIndexingMap(linalgOp.getNumInputs() + result.index());
     SmallVector<ReassociationIndices, 4> reassociation;
     SmallVector<int64_t, 4> expandedResultShape;
     getReshapeInfo(indexingMap, reassociation, expandedResultShape);
     resultTypes.push_back(RankedTensorType::get(
         expandedResultShape,
         result.value().getType().cast<ShapedType>().getElementType()));
     resultReassociation.emplace_back(std::move(reassociation));
   }
 
   // The iterator types of the expanded op are all parallel.
   SmallVector<StringRef, 4> iteratorTypes(remapping.back(),
                                           getParallelIteratorTypeName());
 
   LinalgOp fusedOp = createLinalgOpOfSameType(
       linalgOp, rewriter, linalgOp.getLoc(), resultTypes,
       /*inputs=*/expandedOpOperands,
       /*outputBuffers=*/ValueRange{},
       /*initTensors=*/ValueRange{}, expandedOpIndexingMaps, iteratorTypes);
-  Region &fusedRegion = fusedOp.getOperation()->getRegion(0);
-  Region &originalRegion = linalgOp.getOperation()->getRegion(0);
+  Region &fusedRegion = fusedOp->getRegion(0);
+  Region &originalRegion = linalgOp->getRegion(0);
 
   if (isa<GenericOp>(linalgOp.getOperation())) {
     rewriter.cloneRegionBefore(originalRegion, fusedRegion,
                                fusedRegion.begin());
   } else {
     assert(isa<IndexedGenericOp>(linalgOp.getOperation()));
     // Create an entry block in the fused Region with same number of arguments
     // as the fused op
if (isa<GenericOp>(linalgOp.getOperation())) {
     }
     rewriter.mergeBlocks(fusedEntryBlock->getNextNode(), fusedEntryBlock,
                          argReplacements);
   }
 
   // Reshape the result values to their original shape if this is a collapsing
   // reshape folded into its consumer.
   SmallVector<Value, 1> resultVals;
-  for (auto result : llvm::enumerate(linalgOp.getOperation()->getResults())) {
+  for (auto result : llvm::enumerate(linalgOp->getResults())) {
     if (!isExpanding &&
         resultTypes[result.index()] != result.value().getType()) {
       resultVals.push_back(rewriter.create<TensorReshapeOp>(
           linalgOp.getLoc(), result.value().getType(),
-          fusedOp.getOperation()->getResult(result.index()),
+          fusedOp->getResult(result.index()),
           resultReassociation[result.index()]));
     } else {
-      resultVals.push_back(fusedOp.getOperation()->getResult(result.index()));
+      resultVals.push_back(fusedOp->getResult(result.index()));
     }
   }
   // Assuming a single result.
   return resultVals;
 }
 
 namespace {
 
for (auto operand : llvm::enumerate(linalgOp.getInputs())) {
       fusedIndexMaps[operand.index()] = modifiedMap;
 
       // Further check that the resulting index maps can be fused and
       // inverted. Without this the resultant op is not legal.
       if (!inversePermutation(concatAffineMaps(fusedIndexMaps)))
         return op.emitRemark("fused op loop bound computation failed");
 
       rewriter.startRootUpdate(op);
-      op.getOperation()->setOperands(fusedOperands);
+      op->setOperands(fusedOperands);
       op.indexing_mapsAttr(rewriter.getAffineMapArrayAttr(fusedIndexMaps));
       rewriter.finalizeRootUpdate(op);
       if (reshapeOp.use_empty())
         rewriter.eraseOp(reshapeOp);
       return success();
     }
     return op.emitRemark("no fusion candidates found");
   }
LinalgOp fusedOp = createLinalgOpOfSameType(
         /*inputs=*/producer.getInputs(),
         /*outputBuffers=*/ValueRange{},
         /*initTensors=*/ValueRange{}, // no init tensors for now.
         rewriter.getAffineMapArrayAttr(fusedIndexMaps),
         producer.iterator_types(),
         /*doc=*/nullptr,
         /*library_call=*/nullptr,
         /*sparse=*/nullptr);
-    auto &fusedRegion = fusedOp.getOperation()->getRegion(0);
-    rewriter.cloneRegionBefore(producer.getOperation()->getRegion(0),
-                               fusedRegion, fusedRegion.begin());
-    rewriter.replaceOp(reshapeOp, fusedOp.getOperation()->getResults());
+    auto &fusedRegion = fusedOp->getRegion(0);
+    rewriter.cloneRegionBefore(producer->getRegion(0), fusedRegion,
+                               fusedRegion.begin());
+    rewriter.replaceOp(reshapeOp, fusedOp->getResults());
     if (producer.use_empty())
       rewriter.eraseOp(producer);
     return success();
   }
 };
 
 /// Pattern to fold a tensor_reshape op with its producer generic op if the
 /// tensor_reshape op is expanding, by expanding the dimensionality of the loop
for (auto operand : llvm::enumerate(linalgOp.getInputs())) {
 
       // Create a constant scalar value from the splat constant.
       Value scalarConstant = rewriter.create<ConstantOp>(
           constantOp.getLoc(),
           constantOp.value().cast<DenseElementsAttr>().getSplatValue());
 
       LinalgOp fusedOp = createLinalgOpOfSameType(
           linalgOp, rewriter, rewriter.getUnknownLoc(),
-          linalgOp.getOperation()->getResultTypes(),
+          linalgOp->getResultTypes(),
           /*inputs=*/fusedOperands,
           /*outputBuffers=*/ValueRange{},
           /*initTensors=*/ValueRange{}, // no init tensors for now.
           rewriter.getAffineMapArrayAttr(fusedIndexMaps),
           linalgOp.iterator_types(),
           /*doc=*/nullptr,
           /*library_call=*/nullptr,
           /*sparse=*/nullptr);
 
       // Map the block argument corresponding to the replaced argument with the
       // scalar constant.
-      Region &linalgOpRegion = linalgOp.getOperation()->getRegion(0);
+      Region &linalgOpRegion = linalgOp->getRegion(0);
       Block &entryBlock = *linalgOpRegion.begin();
       unsigned argIndex = entryBlock.getNumArguments() -
                           linalgOp.getNumInputs() + operand.index();
       BlockAndValueMapping mapping;
       mapping.map(entryBlock.getArgument(argIndex), scalarConstant);
-      Region &fusedRegion = fusedOp.getOperation()->getRegion(0);
+      Region &fusedRegion = fusedOp->getRegion(0);
       rewriter.cloneRegionBefore(linalgOpRegion, fusedRegion,
                                  fusedRegion.begin(), mapping);
-      rewriter.replaceOp(linalgOp, fusedOp.getOperation()->getResults());
+      rewriter.replaceOp(linalgOp, fusedOp->getResults());
       if (constantOp.use_empty())
         rewriter.eraseOp(constantOp);
       return success();
     }
     return failure();
   }
 };
 } // namespace

 /// Patterns to fuse a generic op, with the producer of its operands.
 template <typename LinalgOpTy>
 struct FuseTensorOps : public OpRewritePattern<LinalgOpTy> {
   using OpRewritePattern<LinalgOpTy>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(LinalgOpTy op,
                                 PatternRewriter &rewriter) const override {
     // Find the first operand that is defined by another generic op on tensors.
-    for (auto operandNum :
-         llvm::seq<unsigned>(0, op.getOperation()->getNumOperands())) {
-      Operation *producer =
-          op.getOperation()->getOperand(operandNum).getDefiningOp();
+    for (auto operandNum : llvm::seq<unsigned>(0, op->getNumOperands())) {
+      Operation *producer = op->getOperand(operandNum).getDefiningOp();
       if (!producer)
         continue;
       Optional<SmallVector<Value, 1>> fusedOpResults =
           fuseTensorOps(rewriter, op, operandNum);
       if (fusedOpResults) {
         rewriter.replaceOp(op, *fusedOpResults);
         if (producer->use_empty())
           rewriter.eraseOp(producer);

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

func.walk([&](vector::TransferReadOp transferRead) {
       }
 
       // Hoist read before.
       if (failed(loop.moveOutOfLoop({transferRead})))
         llvm_unreachable(
             "Unexpected failure to move transfer read out of loop");
 
       // Hoist write after.
-      transferWrite.getOperation()->moveAfter(loop);
+      transferWrite->moveAfter(loop);
 
       // Rewrite `loop` with new yields by cloning and erase the original loop.
       OpBuilder b(transferRead);
       auto newForOp = cloneWithNewYields(b, loop, transferRead.vector(),
                                          transferWrite.vector());
 
       // Transfer write has been hoisted, need to update the written value to
       // the value yielded by the newForOp.

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

return permutation ? applyMapToValues(ScopedContext::getBuilderRef(),
                                         permutation.getValue(), ivs)
                      : SmallVector<Value, 4>(ivs.begin(), ivs.end());
 }
 
 template <typename IndexedValueType, typename OpType>
 static void inlineRegionAndEmitStore(OpType op, ArrayRef<Value> indexedValues,
                                      ArrayRef<SmallVector<Value, 8>> indexing,
                                      ArrayRef<Value> outputBuffers) {
-  assert(op.getOperation()->getNumRegions() == 1 &&
-         "Expected single region op");
+  assert(op->getNumRegions() == 1 && "Expected single region op");
   auto &b = ScopedContext::getBuilderRef();
-  auto &block = op.getOperation()->getRegion(0).front();
+  auto &block = op->getRegion(0).front();
   BlockAndValueMapping map;
   map.map(block.getArguments(), indexedValues);
   for (auto &op : block.without_terminator()) {
     assert(op.getNumRegions() == 0 && "expected a non-nested region");
     auto *newOp = b.clone(op, map);
     map.map(op.getResults(), newOp->getResults());
   }
 

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

if (options.subViews.count(view.index()) != 0) {
       if (view.index() >= op.getNumInputs())
         writebackViews.emplace_back(std::make_pair(
             view.value(),
             (*promotedBuffersAndViews)[view.index()].partialLocalView));
     } else {
       opViews.push_back(view.value());
     }
   }
-  op.getOperation()->setOperands(0, opViews.size(), opViews);
+  op->setOperands(0, opViews.size(), opViews);
 
   OpBuilder::InsertionGuard guard(b);
   b.setInsertionPointAfter(op);
   ScopedContext scope(b, loc);
   // 3. Emit write-back for the promoted output views: copy the partial view.
   for (auto viewAndPartialLocalView : writebackViews) {
     if (failed(options.copyOutFn(b, viewAndPartialLocalView.second,
                                  viewAndPartialLocalView.first)))

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

GenerateLoopNest<LoopTy>::doit(
         // If LinalgOp has results, they must all be tied to init tensors.
         // We enforce this to ensure all tiled ops have been rewritten in
         // "init tensor" form. This ensures tiling has anchor values into which
         // to subtensor / subtensor_insert. Otherwise tiling would need to
         // allocate which is not acceptable.
         // This would not be the case with a special terminator op that
         // generates the whole tensor (instead of inserting a subtensor). But
         // the generator-based abstraction has other issues.
-        assert(op.getNumInitTensors() == op.getOperation()->getNumResults() &&
+        assert(op.getNumInitTensors() == op->getNumResults() &&
                "expected same number of init tensors as number of results");
 
         // Handle init tensor operands.
         // This uses knowledge about position of the init tensor in the list
         // of operands.
         // TODO: InterfaceAdaptor ?
         SmallVector<Type, 4> resultTensorTypes;
         for (auto idx : llvm::seq<unsigned>(0, op.getNumInitTensors()))
           resultTensorTypes.push_back(
               tiledOperands[op.getNumInputsAndOutputBuffers() + idx].getType());
 
         res = op.clone(b, loc, resultTensorTypes, tiledOperands);
 
         // Insert a subtensor_insert for each init subtensor.
         for (unsigned idx = 0, e = op.getNumInitTensors(); idx != e; ++idx) {
           Value initTensor =
               tiledOperands[op.getNumInputsAndOutputBuffers() + idx];
           if (auto subtensor = initTensor.getDefiningOp<SubTensorOp>()) {
             tensorResults.push_back(b.create<SubTensorInsertOp>(
-                loc, subtensor.source().getType(),
-                res.getOperation()->getResult(idx), subtensor.source(),
-                subtensor.offsets(), subtensor.sizes(), subtensor.strides(),
-                subtensor.static_offsets(), subtensor.static_sizes(),
-                subtensor.static_strides()));
+                loc, subtensor.source().getType(), res->getResult(idx),
+                subtensor.source(), subtensor.offsets(), subtensor.sizes(),
+                subtensor.strides(), subtensor.static_offsets(),
+                subtensor.static_sizes(), subtensor.static_strides()));
           } else {
-            tensorResults.push_back(res.getOperation()->getResult(idx));
+            tensorResults.push_back(res->getResult(idx));
           }
         }
         return scf::ValueVector(tensorResults.begin(), tensorResults.end());
       },
       options.distribution);
 
   // 3. Transforms index arguments of `linalg.generic` w.r.t. to the tiling.
   transformIndexedGenericOpIndices(b, res, ivs, loopIndexToRangeIndex);

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

LogicalResult mlir::linalg::LinalgBaseTilingPattern::matchAndRewriteBase(
   // If LinalgOp has results, they must all be tied to init tensors.
   // We enforce this to ensure all tiled ops have been rewritten in
   // "init tensor" form. This ensures tiling has anchor values into which to
   // subtensor / subtensor_insert. Otherwise tiling would need to allocate which
   // is not acceptable.
   // This would not be the case with a special terminator op that generates the
   // whole tensor (instead of inserting a subtensor). But the generator-based
   // abstraction has other issues.
-  if (linalgOp.getNumInitTensors() != linalgOp.getOperation()->getNumResults())
+  if (linalgOp.getNumInitTensors() != linalgOp->getNumResults())
     return failure();
 
   Optional<TiledLinalgOp> res = tileLinalgOp(rewriter, linalgOp, options);
 
   if (!res)
     return failure();
 
   // Return relevant information to derived pattern.

mlir/lib/Dialect/PDL/IR/PDL.cpp

 }
 
 /// Verifies that the result types of this operation, defined within a
 /// `pdl.rewrite`, can be inferred.
 static LogicalResult verifyResultTypesAreInferrable(OperationOp op,
                                                     ResultRange opResults,
                                                     OperandRange resultTypes) {
   // Functor that returns if the given use can be used to infer a type.
-  Block *rewriterBlock = op.getOperation()->getBlock();
+  Block *rewriterBlock = op->getBlock();
   auto canInferTypeFromUse = [&](OpOperand &use) {
     // If the use is within a ReplaceOp and isn't the operation being replaced
     // (i.e. is not the first operand of the replacement), we can infer a type.
     ReplaceOp replOpUser = dyn_cast<ReplaceOp>(use.getOwner());
     if (!replOpUser || use.getOperandNumber() == 0)
       return false;
     // Make sure the replaced operation was defined before this one.
     Operation *replacedOp = replOpUser.operation().getDefiningOp();

mlir/lib/Dialect/SCF/SCF.cpp

void transferBody(Block *source, Block *dest, ArrayRef<OpResult> usedResults,
     rewriter.mergeBlocks(source, dest);
     // Replace the yield op by one that returns only the used values.
     auto yieldOp = cast<scf::YieldOp>(dest->getTerminator());
     SmallVector<Value, 4> usedOperands;
     llvm::transform(usedResults, std::back_inserter(usedOperands),
                     [&](OpResult result) {
                       return yieldOp.getOperand(result.getResultNumber());
                     });
-    rewriter.updateRootInPlace(
-        yieldOp, [&]() { yieldOp.getOperation()->setOperands(usedOperands); });
+    rewriter.updateRootInPlace(yieldOp,
+                               [&]() { yieldOp->setOperands(usedOperands); });
   }
 
   LogicalResult matchAndRewrite(IfOp op,
                                 PatternRewriter &rewriter) const override {
     // Compute the list of used results.
     SmallVector<OpResult, 4> usedResults;
     llvm::copy_if(op.getResults(), std::back_inserter(usedResults),
                   [](OpResult result) { return !result.use_empty(); });

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

static bool haveNoReadsAfterWriteExceptSameIndex(
   DenseMap<Value, SmallVector<ValueRange, 1>> bufferStores;
   firstPloop.getBody()->walk([&](StoreOp store) {
     bufferStores[store.getMemRef()].push_back(store.indices());
   });
   auto walkResult = secondPloop.getBody()->walk([&](LoadOp load) {
     // Stop if the memref is defined in secondPloop body. Careful alias analysis
     // is needed.
     auto *memrefDef = load.getMemRef().getDefiningOp();
-    if (memrefDef && memrefDef->getBlock() == load.getOperation()->getBlock())
+    if (memrefDef && memrefDef->getBlock() == load->getBlock())
       return WalkResult::interrupt();
 
     auto write = bufferStores.find(load.getMemRef());
     if (write == bufferStores.end())
       return WalkResult::advance();
 
     // Allow only single write access per buffer.
     if (write->second.size() != 1)

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

matchAndRewrite(ForOp op, ArrayRef<Value> operands,
 
     // Convert the type of the entry block of the ForOp's body.
     if (failed(rewriter.convertRegionTypes(&newOp.getLoopBody(),
                                            *getTypeConverter()))) {
       return rewriter.notifyMatchFailure(op, "could not convert body types");
     }
     // Change the clone to use the updated operands. We could have cloned with
     // a BlockAndValueMapping, but this seems a bit more direct.
-    newOp.getOperation()->setOperands(operands);
+    newOp->setOperands(operands);
     // Update the result types to the new converted types.
     for (auto t : llvm::zip(newOp.getResults(), newResultTypes))
       std::get<0>(t).setType(std::get<1>(t));
 
     rewriter.replaceOp(op, newOp.getResults());
     return success();
   }
 };
matchAndRewrite(IfOp op, ArrayRef<Value> operands,
     // then inline.
     IfOp newOp = cast<IfOp>(rewriter.cloneWithoutRegions(*op.getOperation()));
     rewriter.inlineRegionBefore(op.thenRegion(), newOp.thenRegion(),
                                 newOp.thenRegion().end());
     rewriter.inlineRegionBefore(op.elseRegion(), newOp.elseRegion(),
                                 newOp.elseRegion().end());
 
     // Update the operands and types.
-    newOp.getOperation()->setOperands(operands);
+    newOp->setOperands(operands);
     for (auto t : llvm::zip(newOp.getResults(), newResultTypes))
       std::get<0>(t).setType(std::get<1>(t));
     rewriter.replaceOp(op, newOp.getResults());
     return success();
   }
 };
 } // namespace
 

mlir/lib/Dialect/SPIRV/Linking/ModuleCombiner/ModuleCombiner.cpp

 /// \return the hash code computed from the Op's attributes as described above.
 ///
 /// Note: We use the operation's name (not the symbol name) as part of the hash
 /// computation. This prevents, for example, mistakenly considering a global
 /// variable and a spec constant as duplicates because their descriptor set +
 /// binding and spec_id, repectively, happen to hash to the same value.
 static llvm::hash_code computeHash(SymbolOpInterface symbolOp) {
   llvm::hash_code hashCode(0);
-  hashCode = llvm::hash_combine(symbolOp.getOperation()->getName());
+  hashCode = llvm::hash_combine(symbolOp->getName());
 
-  for (auto attr : symbolOp.getOperation()->getAttrs()) {
+  for (auto attr : symbolOp->getAttrs()) {
     if (attr.first == SymbolTable::getSymbolAttrName())
       continue;
     hashCode = llvm::hash_combine(hashCode, attr);
   }
 
   return hashCode;
 }
 

mlir/lib/Dialect/SPIRV/SPIRVCanonicalization.cpp

LogicalResult matchAndRewrite(spirv::SelectionOp selectionOp,
 
     if (failed(canCanonicalizeSelection(trueBlock, falseBlock, mergeBlock)))
       return failure();
 
     auto trueValue = getSrcValue(trueBlock);
     auto falseValue = getSrcValue(falseBlock);
     auto ptrValue = getDstPtr(trueBlock);
     auto storeOpAttributes =
-        cast<spirv::StoreOp>(trueBlock->front()).getOperation()->getAttrs();
+        cast<spirv::StoreOp>(trueBlock->front())->getAttrs();
 
     auto selectOp = rewriter.create<spirv::SelectOp>(
         selectionOp.getLoc(), trueValue.getType(), brConditionalOp.condition(),
         trueValue, falseValue);
     rewriter.create<spirv::StoreOp>(selectOp.getLoc(), ptrValue,
                                     selectOp.getResult(), storeOpAttributes);
 
     // `spv.selection` is not needed anymore.
LogicalResult canCanonicalizeSelection(Block *trueBlock, Block *falseBlock,
                                          Block *mergeBlock) const;
 
   bool onlyContainsBranchConditionalOp(Block *block) const {
     return std::next(block->begin()) == block->end() &&
            isa<spirv::BranchConditionalOp>(block->front());
   }
 
   bool isSameAttrList(spirv::StoreOp lhs, spirv::StoreOp rhs) const {
-    return lhs.getOperation()->getAttrDictionary() ==
-           rhs.getOperation()->getAttrDictionary();
+    return lhs->getAttrDictionary() == rhs->getAttrDictionary();
   }
 
 
   // Returns a source value for the given block.
   Value getSrcValue(Block *block) const {
     auto storeOp = cast<spirv::StoreOp>(block->front());
     return storeOp.value();
   }
LogicalResult ConvertSelectionOpToSelect::canCanonicalizeSelection(
 
   // Check that each `spv.Store` uses the same pointer, memory access
   // attributes and a valid type of the value.
   if ((trueBrStoreOp.ptr() != falseBrStoreOp.ptr()) ||
       !isSameAttrList(trueBrStoreOp, falseBrStoreOp) || !isScalarOrVector) {
     return failure();
   }
 
-  if ((trueBrBranchOp.getOperation()->getSuccessor(0) != mergeBlock) ||
-      (falseBrBranchOp.getOperation()->getSuccessor(0) != mergeBlock)) {
+  if ((trueBrBranchOp->getSuccessor(0) != mergeBlock) ||
+      (falseBrBranchOp->getSuccessor(0) != mergeBlock)) {
     return failure();
   }
 
   return success();
 }
 } // end anonymous namespace
 
 void spirv::SelectionOp::getCanonicalizationPatterns(
     OwningRewritePatternList &results, MLIRContext *context) {
   results.insert<ConvertSelectionOpToSelect>(context);
 }

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

if (auto loopOp = dyn_cast<spirv::LoopOp>(block->getParentOp())) {
       // Then the incoming parent block for OpPhi should be the merge block of
       // the structured control flow op before this loop.
       Operation *op = loopOp.getOperation();
       while ((op = op->getPrevNode()) != nullptr)
         if (Block *incomingBlock = getStructuredControlFlowOpMergeBlock(op))
           return incomingBlock;
       // Or the enclosing block itself if no structured control flow ops
       // exists before this loop.
-      return loopOp.getOperation()->getBlock();
+      return loopOp->getBlock();
     }
   }
 
   // Otherwise, we jump from the given predecessor block. Try to see if there is
   // a structured control flow op inside it.
   for (Operation &op : llvm::reverse(block->getOperations())) {
     if (Block *incomingBlock = getStructuredControlFlowOpMergeBlock(&op))
       return incomingBlock;

 }
 
 template <>
 LogicalResult
 Serializer::processOp<spirv::CopyMemoryOp>(spirv::CopyMemoryOp op) {
   SmallVector<uint32_t, 4> operands;
   SmallVector<StringRef, 2> elidedAttrs;
 
-  for (Value operand : op.getOperation()->getOperands()) {
+  for (Value operand : op->getOperands()) {
     auto id = getValueID(operand);
     assert(id && "use before def!");
     operands.push_back(id);
   }
 
   if (auto attr = op.getAttr("memory_access")) {
     operands.push_back(static_cast<uint32_t>(
         attr.cast<IntegerAttr>().getValue().getZExtValue()));

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

for (const auto &insertions : workList) {
     for (auto insertionOp : insertions)
       operands.push_back(insertionOp.object());
 
     OpBuilder builder(lastCompositeInsertOp);
     auto compositeConstructOp = builder.create<spirv::CompositeConstructOp>(
         location, compositeType, operands);
 
     lastCompositeInsertOp.replaceAllUsesWith(
-        compositeConstructOp.getOperation()->getResult(0));
+        compositeConstructOp->getResult(0));
 
     // Erase ops.
     for (auto insertOp : llvm::reverse(insertions)) {
       auto *op = insertOp.getOperation();
       if (op->use_empty())
         insertOp.erase();
     }
   }

mlir/lib/Dialect/StandardOps/IR/Ops.cpp

 /// merges the two blocks.
 struct SimplifyBrToBlockWithSinglePred : public OpRewritePattern<BranchOp> {
   using OpRewritePattern<BranchOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(BranchOp op,
                                 PatternRewriter &rewriter) const override {
     // Check that the successor block has a single predecessor.
     Block *succ = op.getDest();
-    Block *opParent = op.getOperation()->getBlock();
+    Block *opParent = op->getBlock();
     if (succ == opParent || !llvm::hasSingleElement(succ->getPredecessors()))
       return failure();
 
     // Merge the successor into the current block and erase the branch.
     rewriter.mergeBlocks(succ, opParent, op.getOperands());
     rewriter.eraseOp(op);
     return success();
   }
struct SimplifyPassThroughBr : public OpRewritePattern<BranchOp> {
   LogicalResult matchAndRewrite(BranchOp op,
                                 PatternRewriter &rewriter) const override {
     Block *dest = op.getDest();
     ValueRange destOperands = op.getOperands();
     SmallVector<Value, 4> destOperandStorage;
 
     // Try to collapse the successor if it points somewhere other than this
     // block.
-    if (dest == op.getOperation()->getBlock() ||
+    if (dest == op->getBlock() ||
         failed(collapseBranch(dest, destOperands, destOperandStorage)))
       return failure();
 
     // Create a new branch with the collapsed successor.
     rewriter.replaceOpWithNewOp<BranchOp>(op, dest, destOperands);
     return success();
   }
 };
LogicalResult matchAndRewrite(CondBranchOp condbr,
     OperandRange falseOperands = condbr.getFalseOperands();
     if (trueOperands == falseOperands) {
       rewriter.replaceOpWithNewOp<BranchOp>(condbr, trueDest, trueOperands);
       return success();
     }
 
     // Otherwise, if the current block is the only predecessor insert selects
     // for any mismatched branch operands.
-    if (trueDest->getUniquePredecessor() != condbr.getOperation()->getBlock())
+    if (trueDest->getUniquePredecessor() != condbr->getBlock())
       return failure();
 
     // Generate a select for any operands that differ between the two.
     SmallVector<Value, 8> mergedOperands;
     mergedOperands.reserve(trueOperands.size());
     Value condition = condbr.getCondition();
     for (auto it : llvm::zip(trueOperands, falseOperands)) {
       if (std::get<0>(it) == std::get<1>(it))

 ///
 struct SimplifyCondBranchFromCondBranchOnSameCondition
     : public OpRewritePattern<CondBranchOp> {
   using OpRewritePattern<CondBranchOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(CondBranchOp condbr,
                                 PatternRewriter &rewriter) const override {
     // Check that we have a single distinct predecessor.
-    Block *currentBlock = condbr.getOperation()->getBlock();
+    Block *currentBlock = condbr->getBlock();
     Block *predecessor = currentBlock->getSinglePredecessor();
     if (!predecessor)
       return failure();
 
     // Check that the predecessor terminates with a conditional branch to this
     // block and that it branches on the same condition.
     auto predBranch = dyn_cast<CondBranchOp>(predecessor->getTerminator());
     if (!predBranch || condbr.getCondition() != predBranch.getCondition())

 ///   `memref_reinterpret_cast` ssa-name to
 ///       offset: `[` offset `]`
 ///       sizes: `[` size-list `]`
 ///       strides:`[` stride-list `]`
 ///   `:` any-memref-type to strided-memref-type
 /// ```
 static void print(OpAsmPrinter &p, MemRefReinterpretCastOp op) {
   int stdDotLen = StandardOpsDialect::getDialectNamespace().size() + 1;
-  p << op.getOperation()->getName().getStringRef().drop_front(stdDotLen) << ' ';
+  p << op->getName().getStringRef().drop_front(stdDotLen) << ' ';
   p << op.source() << " ";
   printOffsetsSizesAndStrides(
       p, op, /*offsetPrefix=*/"to offset: ", /*sizePrefix=*/", sizes: ",
       /*stridePrefix=*/", strides: ");
   p << ": " << op.source().getType() << " to " << op.getType();
 }
 
 /// Parse a memref_reinterpret_cast op of the form:

 /// Print a subview op of the form:
 /// ```
 ///   `subview` ssa-name
 ///     `[` offset-list `]` `[` size-list `]` `[` stride-list `]`
 ///     `:` strided-memref-type `to` strided-memref-type
 /// ```
 static void print(OpAsmPrinter &p, SubViewOp op) {
   int stdDotLen = StandardOpsDialect::getDialectNamespace().size() + 1;
-  p << op.getOperation()->getName().getStringRef().drop_front(stdDotLen) << ' ';
+  p << op->getName().getStringRef().drop_front(stdDotLen) << ' ';
   p << op.source();
   printOffsetsSizesAndStrides(p, op);
   p << " : " << op.getSourceType() << " to " << op.getType();
 }
 
 /// Parse a subview op of the form:
 /// ```
 ///   `subview` ssa-name

 /// Print a subtensor op of the form:
 /// ```
 ///   `subtensor` ssa-name
 ///     `[` offset-list `]` `[` size-list `]` `[` stride-list `]`
 ///     `:` ranked-tensor-type `to` ranked-tensor-type
 /// ```
 static void print(OpAsmPrinter &p, SubTensorOp op) {
   int stdDotLen = StandardOpsDialect::getDialectNamespace().size() + 1;
-  p << op.getOperation()->getName().getStringRef().drop_front(stdDotLen) << ' ';
+  p << op->getName().getStringRef().drop_front(stdDotLen) << ' ';
   p << op.source();
   printOffsetsSizesAndStrides(p, op);
   p << " : " << op.getSourceType() << " to " << op.getType();
 }
 
 /// Parse a subtensor op of the form:
 /// ```
 ///   `subtensor` ssa-name

 /// Print a subtensor_insert op of the form:
 /// ```
 ///   `subtensor_insert` ssa-name `into` ssa-name
 ///     `[` offset-list `]` `[` size-list `]` `[` stride-list `]`
 ///     `:` ranked-tensor-type `into` ranked-tensor-type
 /// ```
 static void print(OpAsmPrinter &p, SubTensorInsertOp op) {
   int stdDotLen = StandardOpsDialect::getDialectNamespace().size() + 1;
-  p << op.getOperation()->getName().getStringRef().drop_front(stdDotLen) << ' ';
+  p << op->getName().getStringRef().drop_front(stdDotLen) << ' ';
   p << op.source() << " into " << op.dest();
   printOffsetsSizesAndStrides(p, op);
   p << " : " << op.getSourceType() << " into " << op.getType();
 }
 
 /// Parse a subtensor_insert op of the form:
 /// ```
 ///   `subtensor_insert` ssa-name `into` ssa-name

mlir/lib/Dialect/StandardOps/Transforms/TensorConstantBufferize.cpp

auto global = globalBuilder.create<GlobalMemrefOp>(
         op.getLoc(), (Twine("__constant_") + os.str()).str(),
         /*sym_visibility=*/globalBuilder.getStringAttr("private"),
         /*type=*/
         TypeAttr::get(typeConverter.convertType(type)), /*initial_value=*/
         op.getValue().cast<ElementsAttr>(), /*constant=*/true);
     symbolTable.insert(global);
     // The symbol table inserts at the end of the module, but globals are a bit
     // nicer if they are at the beginning.
-    global.getOperation()->moveBefore(&module.front());
+    global->moveBefore(&module.front());
     globals[op.getValue()] = global;
   });
 }
 } // namespace
 
 namespace {
 class BufferizeTensorConstantOp : public OpConversionPattern<ConstantOp> {
 public:

mlir/lib/Dialect/Vector/VectorOps.cpp

return failure(
       parser.addTypeToList(TupleType::get(types, ctx), result.types));
 }
 
 static void print(OpAsmPrinter &p, TupleOp op) {
   p << op.getOperationName() << ' ';
   p.printOperands(op.getOperands());
   p.printOptionalAttrDict(op.getAttrs());
   p << " : ";
-  llvm::interleaveComma(op.getOperation()->getOperandTypes(), p);
+  llvm::interleaveComma(op->getOperandTypes(), p);
 }
 
 static LogicalResult verify(TupleOp op) { return success(); }
 
 //===----------------------------------------------------------------------===//
 // TransposeOp
 //===----------------------------------------------------------------------===//
 

mlir/lib/Dialect/Vector/VectorTransforms.cpp

LogicalResult mlir::vector::splitFullAndPartialTransferPrecondition(
   if (!xferOp.permutation_map().isMinorIdentity())
     return failure();
   // Must have some masked dimension to be a candidate for splitting.
   if (!xferOp.hasMaskedDim())
     return failure();
   // Don't split transfer operations directly under IfOp, this avoids applying
   // the pattern recursively.
   // TODO: improve the filtering condition to make it more applicable.
-  if (isa<scf::IfOp>(xferOp.getOperation()->getParentOp()))
+  if (isa<scf::IfOp>(xferOp->getParentOp()))
     return failure();
   return success();
 }
 
 /// Given two MemRefTypes `aT` and `bT`, return a MemRefType to which both can
 /// be cast. If the MemRefTypes don't have the same rank or are not strided,
 /// return null; otherwise:
 ///   1. if `aT` and `bT` are cast-compatible, return `aT`.

mlir/lib/IR/BuiltinDialect.cpp

 /// from this function to dest.
 void FuncOp::cloneInto(FuncOp dest, BlockAndValueMapping &mapper) {
   // Add the attributes of this function to dest.
   llvm::MapVector<Identifier, Attribute> newAttrs;
   for (auto &attr : dest.getAttrs())
     newAttrs.insert(attr);
   for (auto &attr : getAttrs())
     newAttrs.insert(attr);
-  dest.getOperation()->setAttrs(
-      DictionaryAttr::get(newAttrs.takeVector(), getContext()));
+  dest->setAttrs(DictionaryAttr::get(newAttrs.takeVector(), getContext()));
 
   // Clone the body.
   getBody().cloneInto(&dest.getBody(), mapper);
 }
 
 /// Create a deep copy of this function and all of its blocks, remapping
 /// any operands that use values outside of the function using the map that is
 /// provided (leaving them alone if no entry is present). Replaces references

mlir/lib/Parser/Parser.cpp

ParseResult OperationParser::popSSANameScope() {
 
   // Verify that all referenced blocks were defined.
   if (!forwardRefInCurrentScope.empty()) {
     SmallVector<std::pair<const char *, Block *>, 4> errors;
     // Iteration over the map isn't deterministic, so sort by source location.
     for (auto entry : forwardRefInCurrentScope) {
       errors.push_back({entry.second.getPointer(), entry.first});
       // Add this block to the top-level region to allow for automatic cleanup.
-      moduleOp.getOperation()->getRegion(0).push_back(entry.first);
+      moduleOp->getRegion(0).push_back(entry.first);
     }
     llvm::array_pod_sort(errors.begin(), errors.end());
 
     for (auto entry : errors) {
       auto loc = SMLoc::getFromPointer(entry.first);
       emitError(loc, "reference to an undefined block");
     }
     return failure();
case Token::eof: {
       assert(!operations.empty() && "expected a valid module terminator");
 
       // Check that the first operation is a module, and it is the only
       // non-terminator operation.
       ModuleOp nested = dyn_cast<ModuleOp>(operations.front());
       if (nested && std::next(operations.begin(), 2) == operations.end()) {
         // Merge the data of the nested module operation into 'module'.
         module.setLoc(nested.getLoc());
-        module.setAttrs(nested.getOperation()->getMutableAttrDict());
+        module.setAttrs(nested->getMutableAttrDict());
         bodyBlocks.splice(bodyBlocks.end(), nested.getBodyRegion().getBlocks());
 
         // Erase the original module body.
         bodyBlocks.pop_front();
       }
 
       return opParser.popSSANameScope();
     }

mlir/lib/Transforms/Inliner.cpp

struct Inliner : public InlinerInterface {
   SymbolTableCollection &symbolTable;
 };
 } // namespace
 
 /// Returns true if the given call should be inlined.
 static bool shouldInline(ResolvedCall &resolvedCall) {
   // Don't allow inlining terminator calls. We currently don't support this
   // case.
-  if (resolvedCall.call.getOperation()->isKnownTerminator())
+  if (resolvedCall.call->isKnownTerminator())
     return false;
 
   // Don't allow inlining if the target is an ancestor of the call. This
   // prevents inlining recursively.
   if (resolvedCall.targetNode->getCallableRegion()->isAncestor(
           resolvedCall.call.getParentRegion()))
     return false;
 

mlir/lib/Transforms/LoopFusion.cpp

while (!worklist.empty()) {
 
           LLVM_DEBUG(llvm::dbgs()
                      << "Fused src loop " << srcId << " into dst loop " << dstId
                      << " at depth " << bestDstLoopDepth << ":\n"
                      << dstAffineForOp << "\n");
 
           // Move 'dstAffineForOp' before 'insertPointInst' if needed.
           if (insertPointInst != dstAffineForOp.getOperation())
-            dstAffineForOp.getOperation()->moveBefore(insertPointInst);
+            dstAffineForOp->moveBefore(insertPointInst);
 
           // Update edges between 'srcNode' and 'dstNode'.
           mdg->updateEdges(srcNode->id, dstNode->id, memref,
                            createPrivateMemref);
 
           // Collect slice loop stats.
           LoopNestStateCollector dstForCollector;
           dstForCollector.collect(dstAffineForOp);
while (findSiblingNodeToFuse(dstNode, &visitedSibNodeIds, &idAndMemref)) {
 
       // Fuse computation slice of 'sibLoopNest' into 'dstLoopNest'.
       mlir::fuseLoops(sibAffineForOp, dstAffineForOp,
                       depthSliceUnions[bestDstLoopDepth - 1]);
 
       auto dstForInst = cast<AffineForOp>(dstNode->op);
       // Update operation position of fused loop nest (if needed).
       if (insertPointInst != dstForInst.getOperation()) {
-        dstForInst.getOperation()->moveBefore(insertPointInst);
+        dstForInst->moveBefore(insertPointInst);
       }
       // Update data dependence graph state post fusion.
       updateStateAfterSiblingFusion(sibNode, dstNode);
     }
   }
 
   // Searches function argument uses and the graph from 'dstNode' looking for a
   // fusion candidate sibling node which shares no dependences with 'dstNode'

mlir/lib/Transforms/SCCP.cpp

for (const SymbolTable::SymbolUse &use : *uses) {
       if (auto callOp = dyn_cast<CallOpInterface>(use.getUser())) {
         Operation *symCallable = callOp.resolveCallable(&symbolTable);
         auto callableLatticeIt = callableLatticeState.find(symCallable);
         if (callableLatticeIt != callableLatticeState.end()) {
           callToSymbolCallable.try_emplace(callOp, symCallable);
 
           // We only need to record the call in the lattice if it produces any
           // values.
-          if (callOp.getOperation()->getNumResults())
+          if (callOp->getNumResults())
             callableLatticeIt->second.addSymbolCall(callOp);
         }
         continue;
       }
       // This use isn't a call, so don't we know all of the callers.
       auto *symbol = symbolTable.lookupSymbolIn(op, use.getSymbolRef());
       auto it = callableLatticeState.find(symbol);
       if (it != callableLatticeState.end())
void SCCPSolver::visitCallableOperation(Operation *op) {
 
   // TODO: Add support for non-symbol callables when necessary. If the callable
   // has non-call uses we would mark overdefined, otherwise allow for
   // propagating the return values out.
   markAllOverdefined(op, op->getResults());
 }
 
 void SCCPSolver::visitCallOperation(CallOpInterface op) {
-  ResultRange callResults = op.getOperation()->getResults();
+  ResultRange callResults = op->getResults();
 
   // Resolve the callable operation for this call.
   Operation *callableOp = nullptr;
   if (Value callableValue = op.getCallableForCallee().dyn_cast<Value>())
     callableOp = callableValue.getDefiningOp();
   else
     callableOp = callToSymbolCallable.lookup(op);
 

mlir/lib/Transforms/Utils/InliningUtils.cpp

LogicalResult mlir::inlineCall(InlinerInterface &interface,
   if (src->empty())
     return failure();
   auto *entryBlock = &src->front();
   ArrayRef<Type> callableResultTypes = callable.getCallableResults();
 
   // Make sure that the number of arguments and results matchup between the call
   // and the region.
   SmallVector<Value, 8> callOperands(call.getArgOperands());
-  SmallVector<Value, 8> callResults(call.getOperation()->getResults());
+  SmallVector<Value, 8> callResults(call->getResults());
   if (callOperands.size() != entryBlock->getNumArguments() ||
       callResults.size() != callableResultTypes.size())
     return failure();
 
   // A set of cast operations generated to matchup the signature of the region
   // with the signature of the call.
   SmallVector<Operation *, 4> castOps;
   castOps.reserve(callOperands.size() + callResults.size());

mlir/lib/Transforms/Utils/LoopFusionUtils.cpp

 }
 
 // Computes and returns an insertion point operation, before which the
 // the fused <srcForOp, dstForOp> loop nest can be inserted while preserving
 // dependences. Returns nullptr if no such insertion point is found.
 static Operation *getFusedLoopNestInsertionPoint(AffineForOp srcForOp,
                                                  AffineForOp dstForOp) {
   bool isSrcForOpBeforeDstForOp =
-      srcForOp.getOperation()->isBeforeInBlock(dstForOp.getOperation());
+      srcForOp->isBeforeInBlock(dstForOp.getOperation());
   auto forOpA = isSrcForOpBeforeDstForOp ? srcForOp : dstForOp;
   auto forOpB = isSrcForOpBeforeDstForOp ? dstForOp : srcForOp;
 
   auto *firstDepOpA =
       getFirstDependentOpInRange(forOpA.getOperation(), forOpB.getOperation());
   auto *lastDepOpB =
       getLastDependentOpInRange(forOpA.getOperation(), forOpB.getOperation());
   // Block:
FusionResult mlir::canFuseLoops(AffineForOp srcForOp, AffineForOp dstForOp,
                                 ComputationSliceState *srcSlice,
                                 FusionStrategy fusionStrategy) {
   // Return 'failure' if 'dstLoopDepth == 0'.
   if (dstLoopDepth == 0) {
     LLVM_DEBUG(llvm::dbgs() << "Cannot fuse loop nests at depth 0\n");
     return FusionResult::FailPrecondition;
   }
   // Return 'failure' if 'srcForOp' and 'dstForOp' are not in the same block.
-  auto *block = srcForOp.getOperation()->getBlock();
-  if (block != dstForOp.getOperation()->getBlock()) {
+  auto *block = srcForOp->getBlock();
+  if (block != dstForOp->getBlock()) {
     LLVM_DEBUG(llvm::dbgs() << "Cannot fuse loop nests in different blocks\n");
     return FusionResult::FailPrecondition;
   }
 
   // Return 'failure' if no valid insertion point for fused loop nest in 'block'
   // exists which would preserve dependences.
   if (!getFusedLoopNestInsertionPoint(srcForOp, dstForOp)) {
     LLVM_DEBUG(llvm::dbgs() << "Fusion would violate dependences in block\n");
     return FusionResult::FailBlockDependence;
   }
 
   // Check if 'srcForOp' precedes 'dstForOp' in 'block'.
   bool isSrcForOpBeforeDstForOp =
-      srcForOp.getOperation()->isBeforeInBlock(dstForOp.getOperation());
+      srcForOp->isBeforeInBlock(dstForOp.getOperation());
   // 'forOpA' executes before 'forOpB' in 'block'.
   auto forOpA = isSrcForOpBeforeDstForOp ? srcForOp : dstForOp;
   auto forOpB = isSrcForOpBeforeDstForOp ? dstForOp : srcForOp;
 
   // Gather all load and store from 'forOpA' which precedes 'forOpB' in 'block'.
   SmallVector<Operation *, 4> opsA;
   if (!gatherLoadsAndStores(forOpA, opsA)) {
     LLVM_DEBUG(llvm::dbgs() << "Fusing loops with affine.if unsupported\n");

mlir/lib/Transforms/Utils/LoopUtils.cpp

LogicalResult mlir::promoteIfSingleIteration(AffineForOp forOp) {
   if (!tripCount || tripCount.getValue() != 1)
     return failure();
 
   if (forOp.getLowerBoundMap().getNumResults() != 1)
     return failure();
 
   // Replaces all IV uses to its single iteration value.
   auto iv = forOp.getInductionVar();
-  auto *parentBlock = forOp.getOperation()->getBlock();
+  auto *parentBlock = forOp->getBlock();
   if (!iv.use_empty()) {
     if (forOp.hasConstantLowerBound()) {
       OpBuilder topBuilder(forOp.getParentOfType<FuncOp>().getBody());
       auto constOp = topBuilder.create<ConstantIndexOp>(
           forOp.getLoc(), forOp.getConstantLowerBound());
       iv.replaceAllUsesWith(constOp);
     } else {
       auto lbOperands = forOp.getLowerBoundOperands();
LogicalResult mlir::promoteIfSingleIteration(scf::ForOp forOp) {
   // Replace uses of loop results with the values yielded by the loop.
   auto outerResults = forOp.getResults();
   auto innerResults = forOp.getBody()->getTerminator()->getOperands();
   for (auto e : llvm::zip(outerResults, innerResults))
     std::get<0>(e).replaceAllUsesWith(std::get<1>(e));
 
   // Move the loop body operations, except for its terminator, to the loop's
   // containing block.
-  auto *parentBlock = forOp.getOperation()->getBlock();
+  auto *parentBlock = forOp->getBlock();
   forOp.getBody()->getTerminator()->erase();
   parentBlock->getOperations().splice(Block::iterator(forOp),
                                       forOp.getBody()->getOperations());
   forOp.erase();
   return success();
 }
 
 /// Promotes all single iteration 'for' ops in `f`, i.e., moves

 /// checking if there is a 'negative' dependence in the memrefs present in
 /// the loop nest. If yes then tiling is invalid.
 static bool
 checkTilingLegalityImpl(MutableArrayRef<mlir::AffineForOp> origLoops) {
   assert(!origLoops.empty() && "no original loops provided");
 
   // We first find out all dependences we intend to check.
   SmallVector<Operation *, 8> loadAndStoreOps;
-  origLoops[0].getOperation()->walk([&](Operation *op) {
+  origLoops[0]->walk([&](Operation *op) {
     if (isa<AffineReadOpInterface, AffineWriteOpInterface>(op))
       loadAndStoreOps.push_back(op);
   });
 
   unsigned numOps = loadAndStoreOps.size();
   unsigned numLoops = origLoops.size();
   FlatAffineConstraints dependenceConstraints;
   for (unsigned d = 1; d <= numLoops + 1; ++d) {
LogicalResult mlir::loopUnrollByFactor(AffineForOp forOp,
   // TODO: option to specify cleanup loop unrolling.
   Optional<uint64_t> mayBeConstantTripCount = getConstantTripCount(forOp);
   if (mayBeConstantTripCount.hasValue() &&
       mayBeConstantTripCount.getValue() < unrollFactor)
     return failure();
 
   // Generate the cleanup loop if trip count isn't a multiple of unrollFactor.
   if (getLargestDivisorOfTripCount(forOp) % unrollFactor != 0) {
-    OpBuilder builder(forOp.getOperation()->getBlock(),
-                      std::next(Block::iterator(forOp)));
+    OpBuilder builder(forOp->getBlock(), std::next(Block::iterator(forOp)));
     auto cleanupForOp = cast<AffineForOp>(builder.clone(*forOp));
     AffineMap cleanupMap;
     SmallVector<Value, 4> cleanupOperands;
     getCleanupLoopLowerBound(forOp, unrollFactor, cleanupMap, cleanupOperands);
     assert(cleanupMap &&
            "cleanup loop lower bound map for single result lower bound maps "
            "can always be determined");
     cleanupForOp.setLowerBound(cleanupOperands, cleanupMap);
upperBoundUnrolled = boundsBuilder.create<AddIOp>(
         loc, lowerBound,
         boundsBuilder.create<MulIOp>(loc, tripCountEvenMultiple, step));
     // Scale 'step' by 'unrollFactor'.
     stepUnrolled = boundsBuilder.create<MulIOp>(loc, step, unrollFactorCst);
   }
 
   // Create epilogue clean up loop starting at 'upperBoundUnrolled'.
   if (generateEpilogueLoop) {
-    OpBuilder epilogueBuilder(forOp.getOperation()->getBlock(),
+    OpBuilder epilogueBuilder(forOp->getBlock(),
                               std::next(Block::iterator(forOp)));
     auto epilogueForOp = cast<scf::ForOp>(epilogueBuilder.clone(*forOp));
     epilogueForOp.setLowerBound(upperBoundUnrolled);
 
     // Update uses of loop results.
     auto results = forOp.getResults();
     auto epilogueResults = epilogueForOp.getResults();
     auto epilogueIterOperands = epilogueForOp.getIterOperands();
 
     for (auto e : llvm::zip(results, epilogueResults, epilogueIterOperands)) {
       std::get<0>(e).replaceAllUsesWith(std::get<1>(e));
-      epilogueForOp.getOperation()->replaceUsesOfWith(std::get<2>(e),
-                                                      std::get<0>(e));
+      epilogueForOp->replaceUsesOfWith(std::get<2>(e), std::get<0>(e));
     }
     promoteIfSingleIteration(epilogueForOp);
   }
 
   // Create unrolled loop.
   forOp.setUpperBound(upperBoundUnrolled);
   forOp.setStep(stepUnrolled);
 
LogicalResult mlir::loopUnrollJamByFactor(AffineForOp forOp,
   JamBlockGatherer jbg;
   jbg.walk(forOp);
   auto &subBlocks = jbg.subBlocks;
 
   // Generate the cleanup loop if trip count isn't a multiple of
   // unrollJamFactor.
   if (getLargestDivisorOfTripCount(forOp) % unrollJamFactor != 0) {
     // Insert the cleanup loop right after 'forOp'.
-    OpBuilder builder(forOp.getOperation()->getBlock(),
-                      std::next(Block::iterator(forOp)));
+    OpBuilder builder(forOp->getBlock(), std::next(Block::iterator(forOp)));
     auto cleanupAffineForOp = cast<AffineForOp>(builder.clone(*forOp));
     // Adjust the lower bound of the cleanup loop; its upper bound is the same
     // as the original loop's upper bound.
     AffineMap cleanupMap;
     SmallVector<Value, 4> cleanupOperands;
     getCleanupLoopLowerBound(forOp, unrollJamFactor, cleanupMap,
                              cleanupOperands);
     cleanupAffineForOp.setLowerBound(cleanupOperands, cleanupMap);

 void mlir::interchangeLoops(AffineForOp forOpA, AffineForOp forOpB) {
   assert(&*forOpA.getBody()->begin() == forOpB.getOperation());
   auto &forOpABody = forOpA.getBody()->getOperations();
   auto &forOpBBody = forOpB.getBody()->getOperations();
 
   // 1) Splice forOpA's non-terminator operations (which is just forOpB) just
   // before forOpA (in ForOpA's parent's block) this should leave 'forOpA's
   // body containing only the terminator.
-  forOpA.getOperation()->getBlock()->getOperations().splice(
-      Block::iterator(forOpA), forOpABody, forOpABody.begin(),
+  forOpA->getBlock()->getOperations().splice(Block::iterator(forOpA),
+                                             forOpABody, forOpABody.begin(),
                                              std::prev(forOpABody.end()));
   // 2) Splice forOpB's non-terminator operations into the beginning of forOpA's
   // body (this leaves forOpB's body containing only the terminator).
   forOpABody.splice(forOpABody.begin(), forOpBBody, forOpBBody.begin(),
                     std::prev(forOpBBody.end()));
   // 3) Splice forOpA into the beginning of forOpB's body.
-  forOpBBody.splice(forOpBBody.begin(),
-                    forOpA.getOperation()->getBlock()->getOperations(),
+  forOpBBody.splice(forOpBBody.begin(), forOpA->getBlock()->getOperations(),
                     Block::iterator(forOpA));
 }
 
 // Checks each dependence component against the permutation to see if the
 // desired loop interchange would violate dependences by making the
 // dependence component lexicographically negative.
 static bool checkLoopInterchangeDependences(
     const std::vector<SmallVector<DependenceComponent, 2>> &depCompsVec,
unsigned mlir::permuteLoops(MutableArrayRef<AffineForOp> input,
   for (int i = input.size() - 1; i >= 0; --i) {
     // If this has to become the outermost loop after permutation, add it to the
     // parent block of the original root.
     if (permMap[i] == 0) {
       // If the root remains the same, nothing to do.
       if (i == 0)
         continue;
       // Make input[i] the new outermost loop moving it into parentBlock.
-      auto *parentBlock = input[0].getOperation()->getBlock();
-      parentBlock->getOperations().splice(
-          Block::iterator(input[0]),
-          input[i].getOperation()->getBlock()->getOperations(),
+      auto *parentBlock = input[0]->getBlock();
+      parentBlock->getOperations().splice(Block::iterator(input[0]),
+                                          input[i]->getBlock()->getOperations(),
                                           Block::iterator(input[i]));
       continue;
     }
 
     // If the parent in the permuted order is the same as in the original,
     // nothing to do.
     unsigned parentPosInInput = invPermMap[permMap[i] - 1].second;
     if (i > 0 && static_cast<unsigned>(i - 1) == parentPosInInput)
       continue;
 
     // Move input[i] to its surrounding loop in the transformed nest.
     auto *destBody = input[parentPosInInput].getBody();
-    destBody->getOperations().splice(
-        destBody->begin(), input[i].getOperation()->getBlock()->getOperations(),
+    destBody->getOperations().splice(destBody->begin(),
+                                     input[i]->getBlock()->getOperations(),
                                      Block::iterator(input[i]));
   }
 
   return invPermMap[0].second;
 }
 
 // Sinks all sequential loops to the innermost levels (while preserving
 // relative order among them) and moves all parallel loops to the
 // outermost (while again preserving relative order among them).

 // each of the `targets`.
 static SmallVector<AffineForOp, 8>
 stripmineSink(AffineForOp forOp, uint64_t factor,
               ArrayRef<AffineForOp> targets) {
   auto originalStep = forOp.getStep();
   auto scaledStep = originalStep * factor;
   forOp.setStep(scaledStep);
 
-  OpBuilder b(forOp.getOperation()->getBlock(),
-              std::next(Block::iterator(forOp)));
+  OpBuilder b(forOp->getBlock(), std::next(Block::iterator(forOp)));
 
   // Lower-bound map creation.
   auto lbMap = forOp.getLowerBoundMap();
   SmallVector<Value, 4> lbOperands(forOp.getLowerBoundOperands());
   augmentMapAndBounds(b, forOp.getInductionVar(), &lbMap, &lbOperands);
 
   // Upper-bound map creation.
   auto ubMap = forOp.getUpperBoundMap();
for (auto e = enclosingFors.rend(); it != e; ++it) {
     if (llvm::is_contained(symbols, it->getInductionVar()))
       break;
   }
 
   if (it != enclosingFors.rbegin()) {
     auto lastInvariantIV = *std::prev(it);
     *copyInPlacementStart = Block::iterator(lastInvariantIV.getOperation());
     *copyOutPlacementStart = std::next(*copyInPlacementStart);
-    *copyPlacementBlock = lastInvariantIV.getOperation()->getBlock();
+    *copyPlacementBlock = lastInvariantIV->getBlock();
   } else {
     *copyInPlacementStart = begin;
     *copyOutPlacementStart = end;
     *copyPlacementBlock = &block;
   }
 }
 
 // Info comprising stride and number of elements transferred every stride.
if (!ifOp) {
     return failure();
   }
 
   // Move the full tile into the then block.
   Block *thenBlock = ifOp.getThenBlock();
   AffineForOp outermostFullTileLoop = fullTileLoops[0];
   thenBlock->getOperations().splice(
       std::prev(thenBlock->end()),
-      outermostFullTileLoop.getOperation()->getBlock()->getOperations(),
+      outermostFullTileLoop->getBlock()->getOperations(),
       Block::iterator(outermostFullTileLoop));
 
   // Move the partial tile into the else block. The partial tile is the same as
   // the original loop nest.
   Block *elseBlock = ifOp.getElseBlock();
-  elseBlock->getOperations().splice(
-      std::prev(elseBlock->end()),
-      firstLoop.getOperation()->getBlock()->getOperations(),
+  elseBlock->getOperations().splice(std::prev(elseBlock->end()),
+                                    firstLoop->getBlock()->getOperations(),
                                     Block::iterator(firstLoop));
 
   if (fullTileNest)
     *fullTileNest = std::move(fullTileLoops);
 
   return success();
 }

mlir/test/lib/Dialect/SPIRV/TestAvailability.cpp

 } // end anonymous namespace
 
 void PrintOpAvailability::runOnFunction() {
   auto f = getFunction();
   llvm::outs() << f.getName() << "\n";
 
   Dialect *spvDialect = getContext().getLoadedDialect("spv");
 
-  f.getOperation()->walk([&](Operation *op) {
+  f->walk([&](Operation *op) {
     if (op->getDialect() != spvDialect)
       return WalkResult::advance();
 
     auto opName = op->getName();
     auto &os = llvm::outs();
 
     if (auto minVersion = dyn_cast<spirv::QueryMinVersionInterface>(op))
       os << opName << " min version: "

mlir/test/lib/Transforms/TestLinalgFusionTransforms.cpp

 static LogicalResult fuseLinalgOpsGreedily(FuncOp f) {
   OpBuilder b(f);
   DenseSet<Operation *> eraseSet;
 
   // Save original Linalg ops, we only want to make a pass over those.
   SmallVector<LinalgOp, 8> linalgOps;
   f.walk([&](LinalgOp op) {
     // TODO: support multi-results.
-    if (op.getOperation()->getNumResults() <= 1)
+    if (op->getNumResults() <= 1)
       linalgOps.push_back(op);
   });
 
   // Tile and Fuse for tensors inputs (TODO: all tensor operands).
   bool changed = false;
   for (LinalgOp linalgOp : llvm::reverse(linalgOps)) {
     for (auto en : llvm::enumerate(linalgOp.getShapedOperands())) {
       if (en.value().getType().isa<MemRefType>()) {

mlir/test/lib/Transforms/TestLoopFusion.cpp

 static bool testDependenceCheck(AffineForOp srcForOp, AffineForOp dstForOp,
                                 unsigned i, unsigned j, unsigned loopDepth,
                                 unsigned maxLoopDepth) {
   mlir::ComputationSliceState sliceUnion;
   for (unsigned d = loopDepth + 1; d <= maxLoopDepth; ++d) {
     FusionResult result =
         mlir::canFuseLoops(srcForOp, dstForOp, d, &sliceUnion);
     if (result.value == FusionResult::FailBlockDependence) {
-      srcForOp.getOperation()->emitRemark("block-level dependence preventing"
-                                          " fusion of loop nest ")
+      srcForOp->emitRemark("block-level dependence preventing"
           << i << " into loop nest " << j << " at depth " << loopDepth;
     }
   }
   return false;
 }
 
 // Returns the index of 'op' in its block.
 static unsigned getBlockIndex(Operation &op) {

 // Returns false as IR is not transformed.
 static bool testSliceComputation(AffineForOp forOpA, AffineForOp forOpB,
                                  unsigned i, unsigned j, unsigned loopDepth,
                                  unsigned maxLoopDepth) {
   for (unsigned d = loopDepth + 1; d <= maxLoopDepth; ++d) {
     mlir::ComputationSliceState sliceUnion;
     FusionResult result = mlir::canFuseLoops(forOpA, forOpB, d, &sliceUnion);
     if (result.value == FusionResult::Success) {
-      forOpB.getOperation()->emitRemark("slice (")
+      forOpB->emitRemark("slice (")
           << " src loop: " << i << ", dst loop: " << j << ", depth: " << d
           << " : " << getSliceStr(sliceUnion) << ")";
     }
   }
   return false;
 }
 
 // Attempts to fuse 'forOpA' into 'forOpB' at loop depths in range

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

const auto *attrSizedOperands =
 
     constructor->addMemberInitializer("odsOperands", "values");
     constructor->addMemberInitializer("odsAttrs", "attrs");
   }
 
   {
     auto *constructor = adaptor.addConstructorAndPrune(
         llvm::formatv("{0}&", op.getCppClassName()).str(), "op");
-    constructor->addMemberInitializer("odsOperands",
-                                      "op.getOperation()->getOperands()");
-    constructor->addMemberInitializer("odsAttrs",
-                                      "op.getOperation()->getAttrDictionary()");
+    constructor->addMemberInitializer("odsOperands", "op->getOperands()");
+    constructor->addMemberInitializer("odsAttrs", "op->getAttrDictionary()");
   }
 
   std::string sizeAttrInit =
       formatv(adapterSegmentSizeAttrInitCode, "operand_segment_sizes");
   generateNamedOperandGetters(op, adaptor, sizeAttrInit,
                               /*rangeType=*/"::mlir::ValueRange",
                               /*rangeBeginCall=*/"odsOperands.begin()",
                               /*rangeSizeCall=*/"odsOperands.size()",

mlir/tools/mlir-tblgen/SPIRVUtilsGen.cpp

if (!it->is<NamedAttribute *>()) {
       break;
     }
   }
 
   // Serialize all operands together.
   if (areOperandsAheadOfAttrs) {
     if (op.getNumOperands() != 0) {
       os << tabs
-         << formatv(
-                "for (Value operand : {0}.getOperation()->getOperands()) {{\n",
-                opVar);
+         << formatv("for (Value operand : {0}->getOperands()) {{\n", opVar);
       os << tabs << "  auto id = getValueID(operand);\n";
       os << tabs << "  assert(id && \"use before def!\");\n";
       os << tabs << formatv("  {0}.push_back(id);\n", operands);
       os << tabs << "}\n";
     }
     for (const NamedAttribute &attr : op.getAttributes()) {
       emitAttributeSerialization(
           (attr.attr.isOptional() ? attr.attr.getBaseAttr() : attr.attr), loc,