[mlir] Use TypedValue in single result traits

[rkayaith]

Summary

Ops with a single result currently get a getResult() method +
conversion operator to Value through the OneResult trait. By moving
these to the OneTypedResult trait instead, we can use TypedValue as
the return type to get more specfic types.

When the result type is unknown ODS adds the
OneTypedResult<mlir::Type> trait, in which case there is no change in
the resulting API.

mlir/include/mlir/IR/OpDefinition.h

 };
 } // namespace detail
 
 /// This class provides return value APIs for ops that are known to have a
 /// single result.  ResultType is the concrete type returned by getType().
 template <typename ConcreteType>
 class OneResult : public TraitBase<ConcreteType, OneResult> {
 public:
-  Value getResult() { return this->getOperation()->getResult(0); }
-
-  /// If the operation returns a single value, then the Op can be implicitly
-  /// converted to an Value. This yields the value of the only result.
-  operator Value() { return getResult(); }
-
   /// Replace all uses of 'this' value with the new value, updating anything
   /// in the IR that uses 'this' to use the other value instead.  When this
   /// returns there are zero uses of 'this'.
   void replaceAllUsesWith(Value newValue) {
-    getResult().replaceAllUsesWith(newValue);
+    this->getOperation()->getResult(0).replaceAllUsesWith(newValue);
   }
 
   /// Replace all uses of 'this' value with the result of 'op'.
   void replaceAllUsesWith(Operation *op) {
     this->getOperation()->replaceAllUsesWith(op);
   }
 
   static LogicalResult verifyTrait(Operation *op) {

 class OneTypedResult {
 public:
   /// This class provides return value APIs for ops that are known to have a
   /// single result.  ResultType is the concrete type returned by getType().
   template <typename ConcreteType>
   class Impl
       : public TraitBase<ConcreteType, OneTypedResult<ResultType>::Impl> {
   public:
-    ResultType getType() {
-      auto resultTy = this->getOperation()->getResult(0).getType();
-      return resultTy.template cast<ResultType>();
+    TypedValue<ResultType> getResult() {
+      return this->getOperation()->getResult(0);
     }
+
+    /// If the operation returns a single value, then the Op can be implicitly
+    /// converted to a Value. This yields the value of the only result.
+    operator TypedValue<ResultType>() { return getResult(); }
+
+    ResultType getType() { return getResult().getType(); }
   };
 };
 
 /// This class provides the API for ops that are known to have a specified
 /// number of results.  This is used as a trait like this:
 ///
 ///   class FooOp : public Op<FooOp, OpTrait::NResults<2>::Impl> {
 ///

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

TestUndoBlockArgReplace(MLIRContext *ctx)
       : ConversionPattern("test.undo_block_arg_replace", /*benefit=*/1, ctx) {}
 
   LogicalResult
   matchAndRewrite(Operation *op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const final {
     auto illegalOp =
         rewriter.create<ILLegalOpF>(op->getLoc(), rewriter.getF32Type());
     rewriter.replaceUsesOfBlockArgument(op->getRegion(0).getArgument(0),
-                                        illegalOp);
+                                        illegalOp->getResult(0));
     rewriter.updateRootInPlace(op, [] {});
     return success();
   }
 };
 
 /// A rewrite pattern that tests the undo mechanism when erasing a block.
 struct TestUndoBlockErase : public ConversionPattern {
   TestUndoBlockErase(MLIRContext *ctx)