[TorchToArith] Implement conversion for AtenNegFloatOp and rename ConvertAtenUnaryOpToFloatMathOp to ConvertAtenUnaryOp.

Implement conversion patterns for `AtenNegFloatOp`.
Rename `ConvertAtenUnaryOpToFloatMathOp` to `ConvertAtenUnaryOp`.
Add test case for `ConvertAtenNegIntOp`.

Author: Junru-Sheng

lib/Conversion/TorchToArith/TorchToArith.cpp

@@ -110,6 +110,27 @@ class ConvertAtenNegIntOp : public OpConversionPattern<AtenNegIntOp> {
 };
 } // namespace
 
+namespace {
+class ConvertAtenNegFloatOp : public OpConversionPattern<AtenNegFloatOp> {
+public:
+  using OpConversionPattern<AtenNegFloatOp>::OpConversionPattern;
+  LogicalResult matchAndRewrite(
+      AtenNegFloatOp op,
+      typename OpConversionPattern<AtenNegFloatOp>::OpAdaptor adaptor,
+      ConversionPatternRewriter &rewriter) const override {
+    Value a = adaptor.getA();
+    Type inputDtype = a.getType();
+    rewriter.replaceOpWithNewOp<arith::SubFOp>(
+        op,
+        arith::ConstantOp::create(
+            rewriter, op.getLoc(),
+            rewriter.getFloatAttr(inputDtype, /*value=*/0.0)),
+        a);
+    return success();
+  }
+};
+} // namespace
+
 namespace {
 template <typename AtenOp, typename UnaryOp>
 class ConvertAtenUnaryOpToFloatMathOp : public OpConversionPattern<AtenOp> {
@@ -513,6 +534,9 @@ class ConvertTorchToArith
 
     target.addIllegalOp<AtenNegIntOp>();
     patterns.add<ConvertAtenNegIntOp>(typeConverter, context);
+    target.addIllegalOp<AtenNegFloatOp>();
+    patterns.add<ConvertAtenNegFloatOp>(typeConverter, context);
+
     target.addIllegalOp<AtenAddIntOp, AtenAddFloatIntOp, AtenSubIntOp,
                         AtenMulIntOp, AtenRemainderIntOp, AtenMulIntFloatOp,
                         AtenMulFloatIntOp>();

test/Conversion/TorchToArith/basic.mlir

@@ -462,3 +462,15 @@ func.func @torch.aten.div(%arg0: !torch.float, %arg1: !torch.float) -> !torch.fl
   %0 = torch.aten.div %arg0, %arg1 : !torch.float, !torch.float -> !torch.float
   return %0 : !torch.float
 }
+
+// CHECK-LABEL:   func.func @torch.aten.neg.float(
+// CHECK-SAME:                            %[[ARG:.*]]: !torch.float) -> !torch.float {
+// CHECK:         %[[ARG_F64:.*]] = torch_c.to_f64 %[[ARG]]
+// CHECK:         %[[CST:.*]] = arith.constant 0.000000e+00 : f64
+// CHECK:         %[[SUB:.*]] = arith.subf %[[CST:.*]], [[ARG_F64:.*]] : f64
+// CHECK:         %[[OUT:.*]] = torch_c.from_f64 %[[SUB:.*]]
+// CHECK:         return %[[OUT:.*]] : !torch.float
+func.func @torch.aten.neg.float(%arg0: !torch.float) -> !torch.float {
+  %0 = torch.aten.neg.float %arg0 : !torch.float -> !torch.float
+  return %0 : !torch.float
+}