[mlir] NFC: Remove Value::operator* and Value::operator-> now that Value is properly value-typed.

Summary: These were temporary methods used to simplify the transition.

Reviewed By: antiagainst

Differential Revision: https://reviews.llvm.org/D72548

1 files changed, 6 insertions, 6 deletions

diff --git a/mlir/test/lib/TestDialect/TestPatterns.cpp b/mlir/test/lib/TestDialect/TestPatterns.cpp
index 929c4a941a2..62ee89e0fe4 100644
--- a/mlir/test/lib/TestDialect/TestPatterns.cpp
+++ b/mlir/test/lib/TestDialect/TestPatterns.cpp
@@ -23,7 +23,7 @@ static void createOpI(PatternRewriter &rewriter, Value input) {
 
 void handleNoResultOp(PatternRewriter &rewriter, OpSymbolBindingNoResult op) {
   // Turn the no result op to a one-result op.
-  rewriter.create<OpSymbolBindingB>(op.getLoc(), op.operand()->getType(),
+  rewriter.create<OpSymbolBindingB>(op.getLoc(), op.operand().getType(),
                                     op.operand());
 }
 
@@ -182,7 +182,7 @@ struct TestDropOpSignatureConversion : public ConversionPattern {
     TypeConverter::SignatureConversion result(entry->getNumArguments());
     for (unsigned i = 0, e = entry->getNumArguments(); i != e; ++i)
       if (failed(converter.convertSignatureArg(
-              i, entry->getArgument(i)->getType(), result)))
+              i, entry->getArgument(i).getType(), result)))
         return matchFailure();
 
     // Convert the region signature and just drop the operation.
@@ -214,12 +214,12 @@ struct TestSplitReturnType : public ConversionPattern {
   matchAndRewrite(Operation *op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const final {
     // Check for a return of F32.
-    if (op->getNumOperands() != 1 || !op->getOperand(0)->getType().isF32())
+    if (op->getNumOperands() != 1 || !op->getOperand(0).getType().isF32())
       return matchFailure();
 
     // Check if the first operation is a cast operation, if it is we use the
     // results directly.
-    auto *defOp = operands[0]->getDefiningOp();
+    auto *defOp = operands[0].getDefiningOp();
     if (auto packerOp = llvm::dyn_cast_or_null<TestCastOp>(defOp)) {
       rewriter.replaceOpWithNewOp<TestReturnOp>(op, packerOp.getOperands());
       return matchSuccess();
@@ -277,7 +277,7 @@ struct TestUpdateConsumerType : public ConversionPattern {
   matchAndRewrite(Operation *op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const final {
     // Verify that the incoming operand has been successfully remapped to F64.
-    if (!operands[0]->getType().isF64())
+    if (!operands[0].getType().isF64())
       return matchFailure();
     rewriter.replaceOpWithNewOp<TestTypeConsumerOp>(op, operands[0]);
     return matchSuccess();
@@ -380,7 +380,7 @@ struct TestLegalizePatternDriver
     target.addDynamicallyLegalOp<TestTypeProducerOp>(
         [](TestTypeProducerOp op) { return op.getType().isF64(); });
     target.addDynamicallyLegalOp<TestTypeConsumerOp>([](TestTypeConsumerOp op) {
-      return op.getOperand()->getType().isF64();
+      return op.getOperand().getType().isF64();
     });
 
     // Check support for marking certain operations as recursively legal.