[mlir] Refactor ComplexOps.td [NFC]

[akuegel]

Summary

Create a ComplexUnaryOp base class and use it for AbsOp, ReOp and ImOp.
Sort all ops in lexicographic order.

[pifon2a]

Nice! Thanks!

[akuegel]

Actually make it a NFC.

[akuegel]

In D104095#2812557, @pifon2a wrote:

Nice! Thanks!

I actually made it a NFC, that is safer. If we want to add additional traits, I guess that should be a separate change.

mlir/include/mlir/Dialect/Complex/IR/ComplexOps.td

class ComplexArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
     DeclareOpInterfaceMethods<VectorUnrollOpInterface>] #
     ElementwiseMappable.traits> {
   let arguments = (ins Complex<AnyFloat>:$lhs, Complex<AnyFloat>:$rhs);
   let results = (outs Complex<AnyFloat>:$result);
   let assemblyFormat = "$lhs `,` $rhs  attr-dict `:` type($result)";
   let verifier = ?;
 }
 
+// Base class for standard unary operations on complex numbers with a
+// floating-point element type. These operations take one operand and return
+// one result; the operand must be a complex number.
+class ComplexUnaryOp<string mnemonic, list<OpTrait> traits = []> :
+    Complex_Op<mnemonic, traits # [NoSideEffect] # ElementwiseMappable.traits> {
+  let arguments = (ins Complex<AnyFloat>:$complex);
+  let assemblyFormat = "$complex attr-dict `:` type($complex)";
+  let verifier = ?;
+}
+
 //===----------------------------------------------------------------------===//
-// AddOp
+// AbsOp
 //===----------------------------------------------------------------------===//
 
-def AddOp : ComplexArithmeticOp<"add"> {
-  let summary = "complex addition";
+def AbsOp : ComplexUnaryOp<"abs",
+    [TypesMatchWith<"complex element type matches result type",
+                    "complex", "result",
+                    "$_self.cast<ComplexType>().getElementType()">]> {
+  let summary = "computes absolute value of a complex number";
   let description = [{
-    The `add` operation takes two complex numbers and returns their sum.
+    The `abs` op takes a single complex number and computes its absolute value.
 
     Example:
 
     ```mlir
-    %a = complex.add %b, %c : complex<f32>
+    %a = complex.abs %b : complex<f32>
     ```
   }];
+  let results = (outs AnyFloat:$result);
 }
 
 //===----------------------------------------------------------------------===//
-// AbsOp
+// AddOp
 //===----------------------------------------------------------------------===//
 
-def AbsOp : Complex_Op<"abs",
-    [NoSideEffect,
-     TypesMatchWith<"complex element type matches result type",
-                    "complex", "result",
-                    "$_self.cast<ComplexType>().getElementType()">]> {
-  let summary = "computes absolute value of a complex number";
+def AddOp : ComplexArithmeticOp<"add"> {
+  let summary = "complex addition";
   let description = [{
-    The `abs` op takes a single complex number and computes its absolute value.
+    The `add` operation takes two complex numbers and returns their sum.
 
     Example:
 
     ```mlir
-    %a = complex.abs %b : complex<f32>
+    %a = complex.add %b, %c : complex<f32>
     ```
   }];
-
-  let arguments = (ins Complex<AnyFloat>:$complex);
-  let results = (outs AnyFloat:$result);
-
-  let assemblyFormat = "$complex attr-dict `:` type($complex)";
 }
 
 //===----------------------------------------------------------------------===//
 // CreateOp
 //===----------------------------------------------------------------------===//
 
 def CreateOp : Complex_Op<"create",
     [NoSideEffect,
let description = [{
 
     ```mlir
     %a = complex.div %b, %c : complex<f32>
     ```
   }];
 }
 
 //===----------------------------------------------------------------------===//
-// ImOp
-//===----------------------------------------------------------------------===//
-
-def ImOp : Complex_Op<"im",
-    [NoSideEffect,
-     TypesMatchWith<"complex element type matches result type",
-                    "complex", "imaginary",
-                    "$_self.cast<ComplexType>().getElementType()">]> {
-  let summary = "extracts the imaginary part of a complex number";
-  let description = [{
-    The `im` op takes a single complex number and extracts the imaginary part.
-
-    Example:
-
-    ```mlir
-    %a = complex.im %b : complex<f32>
-    ```
-  }];
-
-  let arguments = (ins Complex<AnyFloat>:$complex);
-  let results = (outs AnyFloat:$imaginary);
-
-  let assemblyFormat = "$complex attr-dict `:` type($complex)";
-  let hasFolder = 1;
-}
-
-//===----------------------------------------------------------------------===//
 // EqualOp
 //===----------------------------------------------------------------------===//
 
 def EqualOp : Complex_Op<"eq",
     [NoSideEffect, AllTypesMatch<["lhs", "rhs"]>,
     DeclareOpInterfaceMethods<VectorUnrollOpInterface>] #
     ElementwiseMappable.traits> {
   let summary = "computes whether two complex values are equal";
let builders = [
     OpBuilder<(ins "Value":$lhs, "Value":$rhs), [{
       build($_builder, $_state, $_builder.getI1Type(), lhs, rhs);
     }]>];
 
   let assemblyFormat = "$lhs `,` $rhs  attr-dict `:` type($lhs)";
 }
 
 //===----------------------------------------------------------------------===//
+// ImOp
+//===----------------------------------------------------------------------===//
+
+def ImOp : ComplexUnaryOp<"im",
+    [TypesMatchWith<"complex element type matches result type",
+                    "complex", "imaginary",
+                    "$_self.cast<ComplexType>().getElementType()">]> {
+  let summary = "extracts the imaginary part of a complex number";
+  let description = [{
+    The `im` op takes a single complex number and extracts the imaginary part.
+
+    Example:
+
+    ```mlir
+    %a = complex.im %b : complex<f32>
+    ```
+  }];
+
+  let results = (outs AnyFloat:$imaginary);
+  let hasFolder = 1;
+}
+
+//===----------------------------------------------------------------------===//
 // MulOp
 //===----------------------------------------------------------------------===//
 
 def MulOp : ComplexArithmeticOp<"mul"> {
   let summary = "complex multiplication";
   let description = [{
     The `mul` operation takes two complex numbers and returns their product:
 
def NotEqualOp : Complex_Op<"neq",
 
   let assemblyFormat = "$lhs `,` $rhs  attr-dict `:` type($lhs)";
 }
 
 //===----------------------------------------------------------------------===//
 // ReOp
 //===----------------------------------------------------------------------===//
 
-def ReOp : Complex_Op<"re",
-    [NoSideEffect,
-     TypesMatchWith<"complex element type matches result type",
+def ReOp : ComplexUnaryOp<"re",
+    [TypesMatchWith<"complex element type matches result type",
                     "complex", "real",
                     "$_self.cast<ComplexType>().getElementType()">]> {
   let summary = "extracts the real part of a complex number";
   let description = [{
     The `re` op takes a single complex number and extracts the real part.
 
     Example:
 
     ```mlir
     %a = complex.re %b : complex<f32>
     ```
   }];
 
-  let arguments = (ins Complex<AnyFloat>:$complex);
   let results = (outs AnyFloat:$real);
-
-  let assemblyFormat = "$complex attr-dict `:` type($complex)";
   let hasFolder = 1;
 }
 
 
 //===----------------------------------------------------------------------===//
 // SubOp
 //===----------------------------------------------------------------------===//