[mlir][TableGen][NFC] Compact OpBase description

[javedabsar]

Summary

Make the OpBase tablgen descriptions shorter for easier read

[jpienaar]

mlir/include/mlir/IR/OpBase.td

101

This decreases readability for me, these aren't instances of a parameterized base class but separate atoms that share a prefix.

[rriddle]

mlir/include/mlir/IR/OpBase.td

101

Same kind of applies to me in all of these changes. Seems like this is trading off a small amount of code line decrease for much less readability.

[javedabsar]

Fix based on review comments

[javedabsar]

I have removed parts that reduced readibility. The ones left are like what would be common in llvm td files.
But if you reckon this doesnt help readability its ok i will abandon the diff.

[javedabsar]

Is none of these changes desirable ? If so I will abandon this diff.

mlir/include/mlir/IR/OpBase.td

 // Base class for logical predicates.
 //
 // Predicates are used to compose constraints (see next section for details).
 // There are two categories of predicates:
 //
 // 1. CPred: the primitive leaf predicate.
 // 2. Compound predicate: a predicate composed from child predicates using
 //    predicate combiners ("conjunction", "disjunction", "negation" or
-//    "substitution").
+//    "substitution") e.g. PredCombinerAnd.
 class Pred;
 
 // A logical predicate wrapping any C expression.
 //
 // This is the basis for composing more complex predicates. It is the "atom"
 // predicate from the perspective of TableGen and the "interface" between
 // TableGen and C++. What is inside is already C++ code, which will be treated
 // as opaque strings with special placeholders to be substituted.
 //
 // ## Special placeholders
 //
 // Special placeholders can be used to refer to entities in the context where
 // this predicate is used. They serve as "hooks" to the enclosing environment.
 // The following special placeholders are supported in constraints for an op:
 //
 // * `$_builder` will be replaced by a mlir::Builder instance.
 // * `$_op` will be replaced by the current operation.
 // * `$_self` will be replaced with the entity this predicate is attached to.
 //   E.g., `BoolAttr` is an attribute constraint that wraps a
 //   `CPred<"$_self.isa<BoolAttr>()">` (see the following sections for details).
 //   Then for `F32:$attr`,`$_self` will be replaced by `$attr`.
 //   For type constraints, it's a little bit special since we want the
-//   constraints on each type definition reads naturally and we want to attach
+//   constraints on each type definition to read naturally and we want to attach
 //   type constraints directly to an operand/result, $_self will be replaced
 //   by the operand/result's type. E.g., for `F32` in `F32:$operand`, its
 //   `$_self` will be expanded as `getOperand(...).getType()`.
 //
 // One thing to be noticed, while using these placeholders in the C expression,
 // the type of placeholder is only guaranteed to be the base type. For example,
 // if you have a predicate in the form `CPred<"CheckType($_self)">, the argument
 // type of the function `CheckType` should be `mlir::Type`.
 class CPred<code pred> : Pred {
   code predExpr = "(" # pred # ")";
 }
 
-// Kinds of predicate combiners.  These must closely match the predicates
+// Kinds of predicate combiners (PredCombinerAnd, PredCombinerOr, ...).
+// These must closely match the predicates 
 // implemented by the C++ backend (tblgen::PredCombinerKind).
 class PredCombinerKind;
-def PredCombinerAnd : PredCombinerKind;
-def PredCombinerOr : PredCombinerKind;
-def PredCombinerNot : PredCombinerKind;
-def PredCombinerSubstLeaves : PredCombinerKind;
-def PredCombinerConcat : PredCombinerKind;
+foreach k = ["And", "Or", "Not", "SubstLeaves", "Concat"] in {
+  def PredCombiner#k : PredCombinerKind;
+}
 
 // A predicate that combines other predicates as defined by PredCombinerKind.
 // Instantiated below.
 class CombinedPred<PredCombinerKind k, list<Pred> c> : Pred {
   PredCombinerKind kind = k;
   list<Pred> children = c;
 }
 
class AnyI<int width>
     : Type<CPred<"$_self.isInteger(" # width # ")">, width # "-bit integer"> {
   int bitwidth = width;
 }
 
 class AnyIntOfWidths<list<int> widths> :
     AnyTypeOf<!foreach(w, widths, AnyI<w>),
               !interleave(widths, "/") # "-bit integer",
               "::mlir::IntegerType">;
-
-def AnyI1  : AnyI<1>;
-def AnyI8  : AnyI<8>;
-def AnyI16 : AnyI<16>;
-def AnyI32 : AnyI<32>;
-def AnyI64 : AnyI<64>;
+// Define AnyI1, AnyI8, ...
+foreach i = [1,8,16,32,64] in {
+  def AnyI#i : AnyI<i>;
+}
 
 // Any signless integer type irrespective of its width.
 def AnySignlessInteger : Type<
   CPred<"$_self.isSignlessInteger()">, "signless integer",
         "::mlir::IntegerType">;
 
 // Signless integer type of a specific width.
 class I<int width>
     : Type<CPred<"$_self.isSignlessInteger(" # width # ")">,
                   width # "-bit signless integer", "::mlir::IntegerType">,
       BuildableType<"$_builder.getIntegerType(" # width # ")"> {
   int bitwidth = width;
 }
 
 class SignlessIntOfWidths<list<int> widths> :
     AnyTypeOf<!foreach(w, widths, I<w>),
               !interleave(widths, "/") # "-bit signless integer">;
 
-def I1  : I<1>;
-def I8  : I<8>;
-def I16 : I<16>;
-def I32 : I<32>;
-def I64 : I<64>;
+// Define I1, I8,I16 ...
+foreach i = [1, 8, 16, 32, 64] in {
+  def I#i : I<i>;
+}
 
 // Any signed integer type irrespective of its width.
 def AnySignedInteger : Type<
   CPred<"$_self.isSignedInteger()">, "signed integer">;
 
 // Signed integer type of a specific width.
 class SI<int width>
     : Type<CPred<"$_self.isSignedInteger(" # width # ")">,
                   width # "-bit signed integer", "::mlir::IntegerType">,
       BuildableType<
         "$_builder.getIntegerType(" # width # ", /*isSigned=*/true)"> {
   int bitwidth = width;
 }
 
 class SignedIntOfWidths<list<int> widths> :
     AnyTypeOf<!foreach(w, widths, SI<w>),
               !interleave(widths, "/") # "-bit signed integer">;
 
-def SI1  : SI<1>;
-def SI8  : SI<8>;
-def SI16 : SI<16>;
-def SI32 : SI<32>;
-def SI64 : SI<64>;
+foreach i = [1, 8, 16, 32, 64] in {
+  def SI#i : SI<i>;
+}
 
 // Any unsigned integer type irrespective of its width.
 def AnyUnsignedInteger : Type<
   CPred<"$_self.isUnsignedInteger()">, "unsigned integer">;
 
 // Unsigned integer type of a specific width.
 class UI<int width>
     : Type<CPred<"$_self.isUnsignedInteger(" # width # ")">,
                   width # "-bit unsigned integer", "::mlir::IntegerType">,
       BuildableType<
         "$_builder.getIntegerType(" # width # ", /*isSigned=*/false)"> {
   int bitwidth = width;
 }
 
 class UnsignedIntOfWidths<list<int> widths> :
     AnyTypeOf<!foreach(w, widths, UI<w>),
               !interleave(widths, "/") # "-bit unsigned integer">;
 
-def UI1  : UI<1>;
-def UI8  : UI<8>;
-def UI16 : UI<16>;
-def UI32 : UI<32>;
-def UI64 : UI<64>;
+foreach i = [1, 8, 16, 32, 64] in {
+  def UI#i : UI<i>;
+}
 
 // Index type.
 def Index : Type<CPred<"$_self.isa<::mlir::IndexType>()">, "index",
                  "::mlir::IndexType">,
             BuildableType<"$_builder.getIndexType()">;
 
 // Any signless integer type or index type.
 def AnySignlessIntegerOrIndex : Type<CPred<"$_self.isSignlessIntOrIndex()">,
: Type<CPred<"$_self.isF" # width # "()">,
       BuildableType<"$_builder.getF" # width # "Type()"> {
   int bitwidth = width;
 }
 
 class FloatOfWidths<list<int> widths> :
     AnyTypeOf<!foreach(w, widths, F<w>),
               !interleave(widths, "/") # "-bit float">;
 
-def F16 : F<16>;
-def F32 : F<32>;
-def F64 : F<64>;
-def F80 : F<80>;
-def F128 : F<128>;
+foreach i = [16, 32, 64, 80, 128] in {
+  def F#i : F<i>;
+}
 
 def BF16 : Type<CPred<"$_self.isBF16()">, "bfloat16 type">,
            BuildableType<"$_builder.getBF16Type()">;
 
 class Complex<Type type>
     : Type<And<[
           CPred<"$_self.isa<::mlir::ComplexType>()">,
           SubstLeaves<"$_self",

 // TODO: Have an easy way to add another constraint to a type.
 class StaticShapeTensorOf<list<Type> allowedTypes>
     : Type<And<[TensorOf<allowedTypes>.predicate, HasStaticShapePred]>,
            "statically shaped " # TensorOf<allowedTypes>.summary,
            "::mlir::TensorType">;
 
 def AnyStaticShapeTensor : StaticShapeTensorOf<[AnyType]>;
 
-def I1Tensor   : TensorOf<[I1]>;
-def I8Tensor   : TensorOf<[I8]>;
-def I16Tensor  : TensorOf<[I16]>;
-def I32Tensor  : TensorOf<[I32]>;
-def I64Tensor  : TensorOf<[I64]>;
+// Define I1Tensor, I8Tensor, ...
+foreach i = [1, 8, 16, 32, 64] in {
+  def I#i#Tensor : TensorOf<[!cast<Type>("I"#i)]>;
+}
 def IndexTensor: TensorOf<[Index]>;
 
 def BF16Tensor : TensorOf<[BF16]>;
 def F16Tensor  : TensorOf<[F16]>;
 def F32Tensor  : TensorOf<[F32]>;
 def F64Tensor  : TensorOf<[F64]>;
 
 // Ranked tensor type with one of the specified types and ranks.

 
 class RankedOrUnrankedMemRefOf<list<Type> allowedTypes>:
     AnyTypeOf<[UnrankedMemRefOf<allowedTypes>, MemRefOf<allowedTypes>]>;
 
 def AnyRankedOrUnrankedMemRef: AnyTypeOf<[AnyUnrankedMemRef, AnyMemRef]>;
 
 // Memref declarations handle any memref, independent of rank, size, (static or
 // dynamic), layout, or memory space.
-def I1MemRef  : MemRefOf<[I1]>;
-def I8MemRef  : MemRefOf<[I8]>;
-def I16MemRef : MemRefOf<[I16]>;
-def I32MemRef : MemRefOf<[I32]>;
-def I64MemRef : MemRefOf<[I64]>;
+foreach i = [1,8,16,32,64] in {
+  def I#i#MemRef : MemRefOf<[!cast<Type>("I"#i)]>;
+}
 
 def BF16MemRef : MemRefOf<[BF16]>;
 def F16MemRef  : MemRefOf<[F16]>;
 def F32MemRef  : MemRefOf<[F32]>;
 def F64MemRef  : MemRefOf<[F64]>;
 
 // TODO: Have an easy way to add another constraint to a type.
 class MemRefRankOf<list<Type> allowedTypes, list<int> ranks> :