[TorchToArith] Implement conversion patterns for AtenNegFloatOp and add ConvertAtenNegIntOp test case.

Implement conversion patterns for `AtenNegFloatOp`: arith::subf(0.0, a);
Add `ConvertAtenNegIntOp` test case.

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> {
@@ -501,6 +522,9 @@ class ConvertTorchToArith
     patterns.add<ConvertAtenAddOp>(typeConverter, context);
     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

@@ -407,3 +407,27 @@ func.func @torch.aten.Int.Scalar(%arg0: !torch.float) -> !torch.int {
   %0 = torch.aten.Int.Scalar %arg0 : !torch.float -> !torch.int
   return %0 : !torch.int
 }
+
+// CHECK-LABEL:   func.func @torch.aten.neg.int(
+// CHECK-SAME:                            %[[ARG:.*]]: !torch.int) -> !torch.int {
+// CHECK:         %[[ARG_I64:.*]] = torch_c.to_i64 %[[ARG]]
+// CHECK:         %[[CST:.*]] = arith.constant 0 : i64
+// CHECK:         %[[SUB:.*]] = arith.subi %[[CST:.*]], [[ARG_I64:.*]] : i64
+// CHECK:         %[[OUT:.*]] = torch_c.from_i64 %[[SUB:.*]]
+// CHECK:         return %[[OUT:.*]] : !torch.int
+func.func @torch.aten.neg.int(%arg0: !torch.int) -> !torch.int {
+  %0 = torch.aten.neg.int %arg0 : !torch.int -> !torch.int
+  return %0 : !torch.int
+}
+
+// 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
+}