[mlir][ODS] Rename several uses of 'description' to 'summary'

[rriddle]

Summary

Right now constraint/predicate traits/etc. use their "description" field as a one line human readable string. This breaks the current convention, by which a "description" may be multi-line. This revision renames the "description" field in these cases to "summary" which matches what the string is actually used as. This also unbreaks the use of TypeDefs(and eventually AttrDefs) in conjunction with existing type constraint facilities like Optional.

[rriddle]

Rebase

mlir/docs/OpDefinitions.md

 -   Set `hasCustomStorageConstructor` to generate the TypeStorage class with a
     constructor which is just declared -- no definition -- so you can write it
     yourself.
 -   Use the `TypeParameter` tablegen class instead of the "c++Type" string.
 
 ### TypeParameter tablegen class
 
 This is used to further specify attributes about each of the types parameters.
-It includes documentation (`description` and `syntax`), the C++ type to use, and
-a custom allocator to use in the storage constructor method.
+It includes documentation (`summary` and `syntax`), the C++ type to use, and a
+custom allocator to use in the storage constructor method.
 
 ```tablegen
 // DO NOT DO THIS!
 let parameters = (ins "ArrayRef<int>":$dims);
 ```
 
 The default storage constructor blindly copies fields by value. It does not know
 anything about the types. In this case, the ArrayRef<int> requires allocation

mlir/include/mlir/Dialect/ArmSVE/ArmSVE.td

 //===----------------------------------------------------------------------===//
 // ArmSVE type definitions
 //===----------------------------------------------------------------------===//
 
 def ArmSVE_ScalableVectorType : DialectType<ArmSVE_Dialect,
     CPred<"$_self.isa<ScalableVectorType>()">,
               "scalable vector type">,
     BuildableType<"$_builder.getType<ScalableVectorType>()"> {
-  let typeDescription = [{
+  let description = [{
     `arm_sve.vector` represents vectors that will be processed by a scalable
     vector architecture.
   }];
 }
 
 class ArmSVE_Type<string name> : TypeDef<ArmSVE_Dialect, name> { }
 
 def ScalableVectorType : ArmSVE_Type<"ScalableVector"> {

 class ScalableVectorOfLength<list<int> allowedLengths> : Type<
   IsScalableVectorOfLengthPred<allowedLengths>,
   " of length " # !interleave(allowedLengths, "/")>;
 
 class ScalableVectorOfLengthAndType<list<int> allowedLengths,
                                     list<Type> allowedTypes> : Type<
   And<[ScalableVectorOf<allowedTypes>.predicate,
        ScalableVectorOfLength<allowedLengths>.predicate]>,
-  ScalableVectorOf<allowedTypes>.description #
-  ScalableVectorOfLength<allowedLengths>.description>;
+  ScalableVectorOf<allowedTypes>.summary #
+  ScalableVectorOfLength<allowedLengths>.summary>;
 
 //===----------------------------------------------------------------------===//
 // ArmSVE op definitions
 //===----------------------------------------------------------------------===//
 
 class ArmSVE_Op<string mnemonic, list<OpTrait> traits = []> :
   Op<ArmSVE_Dialect, mnemonic, traits> {}
 

mlir/include/mlir/Dialect/Async/IR/AsyncBase.td

def AsyncDialect : Dialect {
   }];
 
   let cppNamespace = "::mlir::async";
 }
 
 def Async_TokenType : DialectType<AsyncDialect,
     CPred<"$_self.isa<::mlir::async::TokenType>()">, "token type">,
     BuildableType<"$_builder.getType<::mlir::async::TokenType>()"> {
-  let typeDescription = [{
+  let description = [{
     `async.token` is a type returned by asynchronous operations, and it becomes
     `ready` when the asynchronous operations that created it is completed.
   }];
 }
 
 class Async_ValueType<Type type>
     : DialectType<AsyncDialect,
         And<[
           CPred<"$_self.isa<::mlir::async::ValueType>()">,
           SubstLeaves<"$_self",
                       "$_self.cast<::mlir::async::ValueType>().getValueType()",
                       type.predicate>
-       ]>, "async value type with " # type.description # " underlying type"> {
-  let typeDescription = [{
+       ]>, "async value type with " # type.summary # " underlying type"> {
+  let description = [{
     `async.value` represents a value returned by asynchronous operations,
     which may or may not be available currently, but will be available at some
     point in the future.
   }];
 
   Type valueType = type;
 }
 
 def Async_GroupType : DialectType<AsyncDialect,
     CPred<"$_self.isa<::mlir::async::GroupType>()">, "group type">,
     BuildableType<"$_builder.getType<::mlir::async::GroupType>()"> {
-  let typeDescription = [{
+  let description = [{
     `async.group` represent a set of async tokens or values and allows to
     execute async operations on all of them together (e.g. wait for the
     completion of all/any of them).
   }];
 }
 
 def Async_AnyValueType : DialectType<AsyncDialect,
                            CPred<"$_self.isa<::mlir::async::ValueType>()">,

mlir/include/mlir/Dialect/LLVMIR/LLVMOpBase.td

 // Type constraint accepting LLVM pointer type with an additional constraint
 // on the element type.
 class LLVM_PointerTo<Type pointee> : Type<
   And<[LLVM_AnyPointer.predicate,
        SubstLeaves<
          "$_self",
          "$_self.cast<::mlir::LLVM::LLVMPointerType>().getElementType()",
          pointee.predicate>]>,
-  "LLVM pointer to " # pointee.description>;
+  "LLVM pointer to " # pointee.summary>;
 
 // Type constraint accepting any LLVM structure type.
 def LLVM_AnyStruct : Type<CPred<"$_self.isa<::mlir::LLVM::LLVMStructType>()">,
                          "LLVM structure type">;
 
 // Type constraint accepting opaque LLVM structure type.
 def LLVM_OpaqueStruct : Type<
   And<[LLVM_AnyStruct.predicate,

 // Type constraint accepting an LLVM vector type with an additional constraint
 // on the vector element type.
 class LLVM_VectorOf<Type element> : Type<
   And<[LLVM_AnyVector.predicate,
        SubstLeaves<
          "$_self",
          "$_self.cast<::mlir::LLVM::LLVMVectorType>().getElementType()",
          element.predicate>]>,
-  "LLVM vector of " # element.description>;
+  "LLVM vector of " # element.summary>;
 
 // Type constraint accepting a constrained type, or a vector of such types.
 class LLVM_ScalarOrVectorOf<Type element> :
     AnyTypeOf<[element, LLVM_VectorOf<element>]>;
 
 // Base class for LLVM operations. Defines the interface to the llvm::IRBuilder
 // used to translate to LLVM IR proper.
 class LLVM_OpBase<Dialect dialect, string mnemonic, list<OpTrait> traits = []> :

mlir/include/mlir/Dialect/Quant/QuantOpsBase.td

 //===----------------------------------------------------------------------===//
 // Quantization type definitions
 //===----------------------------------------------------------------------===//
 
 class quant_TypedPrimitiveOrContainer<Type etype> :
     Type<Or<[etype.predicate,
                 TensorOf<[etype]>.predicate,
                 VectorOf<[etype]>.predicate]>,
-         "primitive/tensor/vector of " # etype.description>;
+         "primitive/tensor/vector of " # etype.summary>;
 
 // An implementation of QuantizedType.
 def quant_QuantizedType :
     Type<CPred<"$_self.isa<mlir::quant::QuantizedType>()">, "QuantizedType">;
 
 // A primitive type that can represent a real value. This is either a
 // floating point value or a quantized type.
 def quant_RealPrimitiveType :

mlir/include/mlir/Dialect/Shape/IR/ShapeBase.td

def ShapeDialect : Dialect {
 
   let hasConstantMaterializer = 1;
   let hasOperationAttrVerify = 1;
 }
 
 def Shape_ShapeType : DialectType<ShapeDialect,
     CPred<"$_self.isa<::mlir::shape::ShapeType>()">, "shape">,
     BuildableType<"$_builder.getType<::mlir::shape::ShapeType>()"> {
-  let typeDescription = [{
+  let description = [{
     `shape.shape` represents either an unranked shape, a ranked shape with
     possibly unknown dimensions or an invalid shape. The rank is of type
     `shape.size` and, if rank is known, the extent is a 1D tensor of type
     `shape.size`.
 
     Shape is printed:
     * `[*]` if it is an unranked shape
     * `[?, 2]` if a rank 2 tensor with one unknown dimension
     * `[3, 4]` is a rank 2 static tensor
     * `[]` is a scalar
     * `[1]` is a rank 1 tensor with 1 element
     * `[invalid]` for an invalid shape
   }];
 }
 
 def Shape_SizeType : DialectType<ShapeDialect,
     CPred<"$_self.isa<::mlir::shape::SizeType>()">, "size">,
     BuildableType<"$_builder.getType<::mlir::shape::SizeType>()"> {
-  let typeDescription = [{
+  let description = [{
     `shape.size` represents a non-negative integer with support for being
     unknown and invalid.
 
     Operations on `shape.size` types are specialized to handle unknown/dynamic
     value. So, for example, `<unknown> + x == <unknown>` for all non-error `x :
     !shape.size` (e.g., an unknown value does not become known due to addition).
   }];
 }
 
 def Shape_ValueShapeType : DialectType<ShapeDialect,
     CPred<"$_self.isa<::mlir::shape::ValueShapeType>()">, "value shape">,
     BuildableType<"::mlir::shape::ValueShapeType::get($_builder.getContext())">
 {
-  let typeDescription = [{
+  let description = [{
     `shape.value_shape` represents the value produced by an operation (this
     corresponds to `Value` in the compiler) and a shape. Conceptually this is a
     tuple of a value (potentially unknown) and `shape.shape`. The value and
     shape can either or both be unknown. If both the `value` and `shape` are
     known, then the shape of `value` is conformant with `shape`. That is, the
     shape of the value conforms to the shape of the ValueShape, so that if we
     have ValueShape `(value, shape)` then `join(shape_of(value), shape)` would
     be error free and in particular it means that if both are statically known,
     then they are equal.
   }];
 }
 
 def Shape_ExtentTensorType :
     1DTensorOf<[Index]>,
     BuildableType<"::mlir::RankedTensorType::get({ShapedType::kDynamicSize}, "
                   "$_builder.getType<::mlir::IndexType>())"> {
-  let typeDescription = [{
+  let description = [{
     The extent tensor is a tensor of rank one with arbitrarily many index
     elements (tensor<?xindex>). Like `!shape.shape`, it is used to represent
     shapes with the difference that it is guaranteed to be error-free.
   }];
 }
 
 def Shape_ShapeOrSizeType : AnyTypeOf<[Shape_SizeType, Shape_ShapeType],
   "shape or size">;
 
 def Shape_ShapeOrExtentTensorType : AnyTypeOf<[Shape_ShapeType,
                                                Shape_ExtentTensorType],
                                               "shape or extent tensor">;
 
 def Shape_SizeOrIndexType : AnyTypeOf<[Shape_SizeType, Index], "size or index">;
 
 def Shape_WitnessType : DialectType<ShapeDialect,
     CPred<"$_self.isa<::mlir::shape::WitnessType>()">, "witness">,
     BuildableType<"$_builder.getType<::mlir::shape::WitnessType>()"> {
-  let typeDescription = [{
+  let description = [{
     A witness is a structural device in the compiler to maintain ordering of
     code relying on information obtained from passing assertions. Witnesses do
     not represent any physical data.
 
     "cstr_" operations will return witnesses and be lowered into assertion logic
     when not resolvable at compile time.
 
     "assuming_" operations will take witnesses as input and represent only

mlir/include/mlir/Dialect/Tosa/IR/TosaOpBase.td

 // This quantization attribute expresses numerical behavior of operators where
 // the operator has a numerical relationship between a single input and output.
 // For example: tosa.negate.
 def Tosa_UnaryOpQuantizationAttr : StructAttr<"UnaryOpQuantizationAttr",
   Tosa_Dialect, [
     StructFieldAttr<"input_zp",         I32Attr>,
     StructFieldAttr<"output_zp",        I32Attr>
     ]> {
-  let description = "Attribute for UnaryOp quantization information.";
+  let summary = "Attribute for UnaryOp quantization information.";
 }
 
 // There is no explicit BinaryOpQuantizationAttr for 2-input/1-output ops. In
 // this case, a tosa.rescale is used to express the inputs to the same scale.
 // TODO: Upload WIP legalization document describing this construction by
 // example.
 
 // This quantization attribute holds input and weight zero point. Both the
 // ConvOp and MatMulOp QuantizationAttrs follow a common design semantic where
 // their ownquantization attribute only expresses the numerical behavior at
 // the inputs.
 // The scaling of their accumulator output is done using an explicit
 // tosa.rescale operator that scales the accumulator result to output scale.
 def Tosa_ConvOpQuantizationAttr : StructAttr<"ConvOpQuantizationAttr",
   Tosa_Dialect, [
     StructFieldAttr<"input_zp",         I32Attr>,
     StructFieldAttr<"weight_zp",        I32Attr>
     ]> {
-  let description = "Attribute for Conv type op quantization information.";
+  let summary = "Attribute for Conv type op quantization information.";
 }
 
 def Tosa_MatMulOpQuantizationAttr : StructAttr<"MatMulOpQuantizationAttr",
   Tosa_Dialect, [
     StructFieldAttr<"a_zp",             I32Attr>,
     StructFieldAttr<"b_zp",             I32Attr>
     ]> {
-  let description = "Attribute for MatMulOp quantization information.";
+  let summary = "Attribute for MatMulOp quantization information.";
 }
 
 // This attribute holds input zero point correction applied to the padding
 // zeros to ensure numerical accuracy in the subsequent TOSA operations.
 // Its functional application is described in the tosa.pad() operator
 // description in the specification.
 def Tosa_PadOpQuantizationAttr : StructAttr<"PadOpQuantizationAttr",
   Tosa_Dialect, [
     StructFieldAttr<"input_zp",         I32Attr>
     ]> {
-  let description = "Attribute for PadOp quantization information.";
+  let summary = "Attribute for PadOp quantization information.";
 }
 
 //===----------------------------------------------------------------------===//
 // TOSA Operator Quantization Builders.
 //===----------------------------------------------------------------------===//
 
 // This builder is called on all convolution operators except for TransposeConv,
 // which has specialized output shape semantics. The builder also defines the

mlir/include/mlir/IR/OpBase.td

 // this class are used to generate verification code in op verifier, and
 // matching code in pattern matcher.
 //
 // Constraints are predicates with descriptive names, to facilitate inspection,
 // provide nice error messages, etc.
 class Constraint<Pred pred, string desc = ""> {
   // The predicates that this constraint requires.
   Pred predicate = pred;
-  // User-readable description used in error reporting messages. If empty, a
-  // generic message will be used.
-  string description = desc;
+  // User-readable one line summary used in error reporting messages. If empty,
+  // a generic message will be used.
+  string summary = desc;
 }
 
 // Subclasses used to differentiate different constraint kinds. These are used
 // as markers for the TableGen backend to handle different constraint kinds
 // differently if needed. Constraints not deriving from the following subclasses
 // are considered as uncategorized constraints.
 
 // Subclass for constraints on a type.
-class TypeConstraint<Pred predicate, string description = "",
+class TypeConstraint<Pred predicate, string summary = "",
                      string cppClassNameParam = "::mlir::Type"> :
-    Constraint<predicate, description> {
+    Constraint<predicate, summary> {
   // The name of the C++ Type class if known, or Type if not.
   string cppClassName = cppClassNameParam;
 }
 
 // Subclass for constraints on an attribute.
-class AttrConstraint<Pred predicate, string description = ""> :
-    Constraint<predicate, description>;
+class AttrConstraint<Pred predicate, string summary = ""> :
+    Constraint<predicate, summary>;
 
 // Subclass for constraints on a region.
-class RegionConstraint<Pred predicate, string description = ""> :
-    Constraint<predicate, description>;
+class RegionConstraint<Pred predicate, string summary = ""> :
+    Constraint<predicate, summary>;
 
 // Subclass for constraints on a successor.
-class SuccessorConstraint<Pred predicate, string description = ""> :
-    Constraint<predicate, description>;
+class SuccessorConstraint<Pred predicate, string summary = ""> :
+    Constraint<predicate, summary>;
 
 // How to use these constraint categories:
 //
 // * Use TypeConstraint to specify
 //   * Constraints on an op's operand/result definition
 //   * Further constraints to match an op's operand/result in source pattern
 //
 // * Use Attr (a subclass for AttrConstraint) for

 //===----------------------------------------------------------------------===//
 // Type definitions
 //===----------------------------------------------------------------------===//
 
 // A type, carries type constraints.
 class Type<Pred condition, string descr = "",
            string cppClassName = "::mlir::Type"> :
     TypeConstraint<condition, descr, cppClassName> {
-  string typeDescription = "";
+  string description = "";
   string builderCall = "";
 }
 
-// Allows providing an alternative name and description to an existing type def.
-class TypeAlias<Type t, string description = t.description> :
-    Type<t.predicate, description> {
-  let typeDescription = t.typeDescription;
+// Allows providing an alternative name and summary to an existing type def.
+class TypeAlias<Type t, string summary = t.summary> :
+    Type<t.predicate, summary> {
+  let description = t.description;
   let builderCall = t.builderCall;
 }
 
 // A type of a specific dialect.
 class DialectType<Dialect d, Pred condition, string descr = "",
                   string cppClassName = "::mlir::Type"> :
     Type<condition, descr, cppClassName> {
   Dialect dialect = d;
 }
 
 // A variadic type constraint. It expands to zero or more of the base type. This
 // class is used for supporting variadic operands/results.
-class Variadic<Type type> : TypeConstraint<type.predicate, type.description> {
+class Variadic<Type type> : TypeConstraint<type.predicate, type.summary> {
   Type baseType = type;
 }
 
 // An optional type constraint. It expands to either zero or one of the base
 // type. This class is used for supporting optional operands/results.
-class Optional<Type type> : TypeConstraint<type.predicate, type.description> {
+class Optional<Type type> : TypeConstraint<type.predicate, type.summary> {
   Type baseType = type;
 }
 
 // A type that can be constructed using MLIR::Builder.
 // Note that this does not "inherit" from Type because it would require
 // duplicating Type subclasses for buildable and non-buildable cases to avoid
 // diamond "inheritance".
 // TODO: we may extend this to a more general 'Buildable' trait, making some

 def AnyType : Type<CPred<"true">, "any type">;
 
 // None type
 def NoneType : Type<CPred<"$_self.isa<::mlir::NoneType>()">, "none type",
                     "::mlir::NoneType">,
       BuildableType<"$_builder.getType<::mlir::NoneType>()">;
 
 // Any type from the given list
-class AnyTypeOf<list<Type> allowedTypes, string description = "",
+class AnyTypeOf<list<Type> allowedTypes, string summary = "",
                 string cppClassName = "::mlir::Type"> : Type<
     // Satisfy any of the allowed type's condition
     Or<!foreach(allowedtype, allowedTypes, allowedtype.predicate)>,
-    !if(!eq(description, ""),
-        !interleave(!foreach(t, allowedTypes, t.description), " or "),
-        description)>;
+    !if(!eq(summary, ""),
+        !interleave(!foreach(t, allowedTypes, t.summary), " or "),
+        summary)>;
 
 // Integer types.
 
 // Any integer type irrespective of its width and signedness semantics.
 def AnyInteger : Type<CPred<"$_self.isa<::mlir::IntegerType>()">, "integer",
                       "::mlir::IntegerType">;
 
 // Any integer type (regardless of signedness semantics) of a specific width.
def BF16 : Type<CPred<"$_self.isBF16()">, "bfloat16 type">,
            BuildableType<"$_builder.getBF16Type()">;
 
 class Complex<Type type>
     : Type<And<[
           CPred<"$_self.isa<::mlir::ComplexType>()">,
           SubstLeaves<"$_self",
                       "$_self.cast<::mlir::ComplexType>().getElementType()",
            type.predicate>]>,
-           "complex type with " # type.description # " elements",
+           "complex type with " # type.summary # " elements",
            "::mlir::ComplexType">,
       SameBuildabilityAs<type, "::mlir::ComplexType::get($_builder.get" # type #
                                "Type())"> {
   Type elementType = type;
 }
 
 def AnyComplex : Type<CPred<"$_self.isa<::mlir::ComplexType>()">,
                       "complex-type", "::mlir::ComplexType">;
 
-class OpaqueType<string dialect, string name, string description>
+class OpaqueType<string dialect, string name, string summary>
   : Type<CPred<"isOpaqueTypeWithName($_self, \""#dialect#"\", \""#name#"\")">,
-         description, "::mlir::OpaqueType">,
+         summary, "::mlir::OpaqueType">,
     BuildableType<"::mlir::OpaqueType::get($_builder.getContext(), "
                   "$_builder.getIdentifier(\"" # dialect # "\"), \""
                   # name # "\")">;
 
 // Function Type
 
 // Any function type.
 def FunctionType : Type<CPred<"$_self.isa<::mlir::FunctionType>()">,
                               "function type", "::mlir::FunctionType">;
 
 // A container type is a type that has another type embedded within it.
 class ContainerType<Type etype, Pred containerPred, code elementTypeCall,
                     string descr, string cppClassName = "::mlir::Type"> :
     // First, check the container predicate.  Then, substitute the extracted
     // element into the element type checker.
     Type<And<[containerPred,
                 SubstLeaves<"$_self", !cast<string>(elementTypeCall),
                 etype.predicate>]>,
-         descr # " of " # etype.description # " values", cppClassName> {
+         descr # " of " # etype.summary # " values", cppClassName> {
   // The type of elements in the container.
   Type elementType = etype;
 
   // Call to retrieve.
   code getElementTypeCall = elementTypeCall;
 }
 
 class ShapedContainerType<list<Type> allowedTypes,
class VectorOfRank<list<int> allowedRanks> : Type<
   " of ranks " # !interleave(allowedRanks, "/"), "::mlir::VectorType">;
 
 // Any vector where the rank is from the given `allowedRanks` list and the type
 // is from the given `allowedTypes` list
 class VectorOfRankAndType<list<int> allowedRanks,
                           list<Type> allowedTypes> : Type<
   And<[VectorOf<allowedTypes>.predicate,
        VectorOfRank<allowedRanks>.predicate]>,
-  VectorOf<allowedTypes>.description #
-  VectorOfRank<allowedRanks>.description,
+  VectorOf<allowedTypes>.summary # VectorOfRank<allowedRanks>.summary,
   "::mlir::VectorType">;
 
 // Whether the number of elements of a vector is from the given
 // `allowedLengths` list
 class IsVectorOfLengthPred<list<int> allowedLengths> :
   And<[IsVectorTypePred,
        Or<!foreach(allowedlength, allowedLengths,
                    CPred<[{$_self.cast<::mlir::VectorType>().getNumElements()

 
 // Any vector where the number of elements is from the given
 // `allowedLengths` list and the type is from the given `allowedTypes`
 // list
 class VectorOfLengthAndType<list<int> allowedLengths,
                             list<Type> allowedTypes> : Type<
   And<[VectorOf<allowedTypes>.predicate,
        VectorOfLength<allowedLengths>.predicate]>,
-  VectorOf<allowedTypes>.description #
-  VectorOfLength<allowedLengths>.description,
+  VectorOf<allowedTypes>.summary # VectorOfLength<allowedLengths>.summary,
   "::mlir::VectorType">;
 
 def AnyVector : VectorOf<[AnyType]>;
 
 // Shaped types.
 
 def AnyShaped: ShapedContainerType<[AnyType], IsShapedTypePred, "shaped",
                                    "::mlir::ShapedType">;

 
 def AnyRankedTensor :
   ShapedContainerType<[AnyType], And<[IsTensorTypePred, HasRankPred]>,
   "ranked tensor", "::mlir::TensorType">;
 
 // 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>.description,
+           "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]>;
 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 TensorRankOf<list<Type> allowedTypes, list<int> ranks> :
     Type<And<[TensorOf<allowedTypes>.predicate, HasAnyRankOfPred<ranks>]>,
          !interleave(!foreach(rank, ranks, rank # "D"), "/") # " " #
-         TensorOf<allowedTypes>.description, "::mlir::TensorType">;
+         TensorOf<allowedTypes>.summary, "::mlir::TensorType">;
 
 class 0DTensorOf<list<Type> allowedTypes> : TensorRankOf<allowedTypes, [0]>;
 class 1DTensorOf<list<Type> allowedTypes> : TensorRankOf<allowedTypes, [1]>;
 class 2DTensorOf<list<Type> allowedTypes> : TensorRankOf<allowedTypes, [2]>;
 class 3DTensorOf<list<Type> allowedTypes> : TensorRankOf<allowedTypes, [3]>;
 class 4DTensorOf<list<Type> allowedTypes> : TensorRankOf<allowedTypes, [4]>;
 
 // Unranked Memref type

 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> :
     Type<And<[MemRefOf<allowedTypes>.predicate, HasAnyRankOfPred<ranks>]>,
          !interleave(!foreach(rank, ranks, rank # "D"), "/") # " " #
-         MemRefOf<allowedTypes>.description>;
+         MemRefOf<allowedTypes>.summary>;
 
 class StaticShapeMemRefOf<list<Type> allowedTypes>
     : Type<And<[MemRefOf<allowedTypes>.predicate, HasStaticShapePred]>,
-           "statically shaped " # MemRefOf<allowedTypes>.description>;
+           "statically shaped " # MemRefOf<allowedTypes>.summary>;
 
 def AnyStaticShapeMemRef : StaticShapeMemRefOf<[AnyType]>;
 
 // For a MemRefType, verify that it has strides.
 def HasStridesPred : CPred<[{ isStrided($_self.cast<::mlir::MemRefType>()) }]>;
 
 class StridedMemRefOf<list<Type> allowedTypes>
     : Type<And<[MemRefOf<allowedTypes>.predicate, HasStridesPred]>,
-           "strided " # MemRefOf<allowedTypes>.description>;
+           "strided " # MemRefOf<allowedTypes>.summary>;
 
 def AnyStridedMemRef : StridedMemRefOf<[AnyType]>;
 
 class AnyStridedMemRefOfRank<int rank> :
   Type<And<[AnyStridedMemRef.predicate,
             MemRefRankOf<[AnyType], [rank]>.predicate]>,
-       AnyStridedMemRef.description # " of rank " # rank>;
+       AnyStridedMemRef.summary # " of rank " # rank>;
 
 class StridedMemRefRankOf<list<Type> allowedTypes, list<int> ranks> :
     Type<And<[MemRefOf<allowedTypes>.predicate, HasAnyRankOfPred<ranks>]>,
          !interleave(!foreach(rank, ranks, rank # "D"), "/") # " " #
-         MemRefOf<allowedTypes>.description>;
+         MemRefOf<allowedTypes>.summary>;
 
 // This represents a generic tuple without any constraints on element type.
 def AnyTuple : Type<IsTupleTypePred, "tuple", "::mlir::TupleType">;
 
 // A container type that has other types embedded in it, but (unlike
 // ContainerType) can hold elements with a mix of types. Requires a call that
 // produces a list of all elements' types.
 class MixedContainerType<Type etype, Pred containerPred, code elementTypesCall,
                          string descr> :
     Type<
         And<[
             containerPred,
             Concat<
                 "::llvm::all_of(" # elementTypesCall # ", [](Type t) { return ",
                 SubstLeaves<"$_self", "t", etype.predicate>,
                 "; })"
             >
         ]>,
-        descr # " with any combination of " # etype.description # " values"> {
+        descr # " with any combination of " # etype.summary # " values"> {
   // The type of elements in the container.
   Type elementType = etype;
 
   // Call to retrieve.
   code getElementTypesCall = elementTypesCall;
 }
 
 // A Tuple that holds a mix of elements of the allowed types.
class DialectAttr<Dialect d, Pred condition, string descr = ""> :
   let cppNamespace = d.cppNamespace;
 }
 
 //===----------------------------------------------------------------------===//
 // Attribute modifier definition
 
 // Decorates an attribute to have an (unvalidated) default value if not present.
 class DefaultValuedAttr<Attr attr, string val> :
-    Attr<attr.predicate, attr.description> {
+    Attr<attr.predicate, attr.summary> {
   // Construct this attribute with the input attribute and change only
   // the default value.
   // Note: this has to be kept up to date with Attr above.
   let storageType = attr.storageType;
   let returnType = attr.returnType;
   let convertFromStorage = attr.convertFromStorage;
   let constBuilderCall = attr.constBuilderCall;
   let defaultValue = val;
   let valueType = attr.valueType;
 
   let baseAttr = attr;
 }
 
 // Decorates an attribute as optional. The return type of the generated
 // attribute accessor method will be Optional<>.
-class OptionalAttr<Attr attr> : Attr<attr.predicate, attr.description> {
+class OptionalAttr<Attr attr> : Attr<attr.predicate, attr.summary> {
   // Rewrite the attribute to be optional.
   // Note: this has to be kept up to date with Attr above.
   let storageType = attr.storageType;
   let returnType = "::llvm::Optional<" # attr.returnType #">";
   let convertFromStorage = "$_self ? " # returnType # "(" #
                            attr.convertFromStorage # ") : (::llvm::None)";
   let valueType = attr.valueType;
   let isOptional = 1;
class TypedStrAttr<Type ty>
     : StringBasedAttr<CPred<"$_self.isa<::mlir::StringAttr>()">,
                             "string attribute"> {
   let valueType = ty;
 }
 
 // Base class for attributes containing types. Example:
 //   def IntTypeAttr : TypeAttrBase<"IntegerType", "integer type attribute">
 // defines a type attribute containing an integer type.
-class TypeAttrBase<string retType, string description> :
+class TypeAttrBase<string retType, string summary> :
     Attr<And<[
       CPred<"$_self.isa<::mlir::TypeAttr>()">,
       CPred<"$_self.cast<::mlir::TypeAttr>().getValue().isa<"
             # retType # ">()">]>,
-    description> {
+    summary> {
   let storageType = [{ ::mlir::TypeAttr }];
   let returnType = retType;
   let valueType = NoneType;
   let convertFromStorage = "$_self.getValue().cast<" # retType # ">()";
 }
 
 def TypeAttr : TypeAttrBase<"::mlir::Type", "any type attribute">;
 
class EnumAttrInfo<string name, list<EnumAttrCaseInfo> cases> {
   string maxEnumValFnName = "getMaxEnumValFor" # name;
 }
 
 // An enum attribute backed by StringAttr.
 //
 // Op attributes of this kind are stored as StringAttr. Extra verification will
 // be generated on the string though: only the symbols of the allowed cases are
 // permitted as the string value.
-class StrEnumAttr<string name, string description,
-                  list<StrEnumAttrCase> cases> :
-    EnumAttrInfo<name, cases>,
+class StrEnumAttr<string name, string summary, list<StrEnumAttrCase> cases>
+  : EnumAttrInfo<name, cases>,
     StringBasedAttr<
       And<[StrAttr.predicate, Or<!foreach(case, cases, case.predicate)>]>,
-      !if(!empty(description), "allowed string cases: " #
+      !if(!empty(summary), "allowed string cases: " #
           !interleave(!foreach(case, cases, "'" # case.symbol # "'"), ", "),
-          description)>;
+          summary)>;
 
 // An enum attribute backed by IntegerAttr.
 //
 // Op attributes of this kind are stored as IntegerAttr. Extra verification will
 // be generated on the integer though: only the values of the allowed cases are
 // permitted as the integer value.
-class IntEnumAttr<I intType, string name, string description,
+class IntEnumAttr<I intType, string name, string summary,
                   list<IntEnumAttrCaseBase> cases> :
     EnumAttrInfo<name, cases>,
     SignlessIntegerAttrBase<intType,
-      !if(!empty(description), "allowed " # intType.description # " cases: " #
-          !interleave(!foreach(case, cases, case.value), ", "), description)> {
+      !if(!empty(summary), "allowed " # intType.summary # " cases: " #
+          !interleave(!foreach(case, cases, case.value), ", "), summary)> {
   let predicate = And<[
     SignlessIntegerAttrBase<intType, "">.predicate,
     Or<!foreach(case, cases, case.predicate)>]>;
 }
 
-class I32EnumAttr<string name, string description,
+class I32EnumAttr<string name, string summary,
                   list<I32EnumAttrCase> cases> :
-    IntEnumAttr<I32, name, description, cases> {
+    IntEnumAttr<I32, name, summary, cases> {
   let returnType = cppNamespace # "::" # name;
   let underlyingType = "uint32_t";
   let convertFromStorage = "static_cast<" # returnType # ">($_self.getInt())";
   let constBuilderCall =
           "$_builder.getI32IntegerAttr(static_cast<int32_t>($0))";
 }
-class I64EnumAttr<string name, string description,
+class I64EnumAttr<string name, string summary,
                   list<I64EnumAttrCase> cases> :
-    IntEnumAttr<I64, name, description, cases> {
+    IntEnumAttr<I64, name, summary, cases> {
   let returnType = cppNamespace # "::" # name;
   let underlyingType = "uint64_t";
   let convertFromStorage = "static_cast<" # returnType # ">($_self.getInt())";
   let constBuilderCall =
           "$_builder.getI64IntegerAttr(static_cast<int64_t>($0))";
 }
 
 // A bit enum stored with 32-bit IntegerAttr.
 //
 // Op attributes of this kind are stored as IntegerAttr. Extra verification will
 // be generated on the integer to make sure only allowed bit are set. Besides,
 // helper methods are generated to parse a string separated with a specified
 // delimiter to a symbol and vice versa.
-class BitEnumAttr<string name, string description,
+class BitEnumAttr<string name, string summary,
                   list<BitEnumAttrCase> cases> :
-    EnumAttrInfo<name, cases>, SignlessIntegerAttrBase<I32, description> {
+    EnumAttrInfo<name, cases>, SignlessIntegerAttrBase<I32, summary> {
   let predicate = And<[
     I32Attr.predicate,
     // Make sure we don't have unknown bit set.
     CPred<"!($_self.cast<::mlir::IntegerAttr>().getValue().getZExtValue() & (~("
           # !interleave(!foreach(case, cases, case.value # "u"), "|") #
           ")))">
   ]>;
 
class BitEnumAttr<string name, string summary,
 
   // The delimiter used to separate bit enum cases in strings.
   string separator = "|";
 }
 
 //===----------------------------------------------------------------------===//
 // Composite attribute kinds
 
-class DictionaryAttrBase<Pred condition, string description> :
-    Attr<condition, description> {
+class DictionaryAttrBase<Pred condition, string summary> :
+    Attr<condition, summary> {
   let storageType = [{ ::mlir::DictionaryAttr }];
   let returnType = [{ ::mlir::DictionaryAttr }];
   let valueType = NoneType;
   let convertFromStorage = "$_self";
 }
 
 def DictionaryAttr
     : DictionaryAttrBase<CPred<"$_self.isa<::mlir::DictionaryAttr>()">,
                                "dictionary of named attribute values">;
 
-class ElementsAttrBase<Pred condition, string description> :
-    Attr<condition, description> {
+class ElementsAttrBase<Pred condition, string summary> :
+    Attr<condition, summary> {
   let storageType = [{ ::mlir::ElementsAttr }];
   let returnType = [{ ::mlir::ElementsAttr }];
   let convertFromStorage = "$_self";
 }
 
 def ElementsAttr : ElementsAttrBase<CPred<"$_self.isa<::mlir::ElementsAttr>()">,
                                     "constant vector/tensor attribute">;
 
-class IntElementsAttrBase<Pred condition, string description> :
+class IntElementsAttrBase<Pred condition, string summary> :
     ElementsAttrBase<And<[CPred<"$_self.isa<::mlir::DenseIntElementsAttr>()">,
                           condition]>,
-                     description> {
+                     summary> {
   let storageType = [{ ::mlir::DenseIntElementsAttr }];
   let returnType = [{ ::mlir::DenseIntElementsAttr }];
 
   let convertFromStorage = "$_self";
 }
 
 def IndexElementsAttr
     : IntElementsAttrBase<CPred<[{$_self.cast<::mlir::DenseIntElementsAttr>()

 class RankedSignlessIntElementsAttr<int width, list<int> dims> :
     SignlessIntElementsAttr<width> {
   // Check that this has the specified shape.
   let predicate = And<[
     SignlessIntElementsAttr<width>.predicate,
     CPred<"$_self.cast<::mlir::DenseIntElementsAttr>().getType().getShape() == "
         "::mlir::ArrayRef<int64_t>({" # !interleave(dims, ", ") # "})">]>;
 
-  let description = width # "-bit signless int elements attribute of shape [" #
-                    !interleave(dims, ", ") # "]";
+  let summary = width # "-bit signless int elements attribute of shape [" #
 
   let constBuilderCall = "::mlir::DenseIntElementsAttr::get("
     "::mlir::RankedTensorType::get({" # !interleave(dims, ", ") #
     "}, $_builder.getIntegerType(" # width # ")), ::llvm::makeArrayRef($0))";
 }
 
 class RankedI32ElementsAttr<list<int> dims> :
     RankedSignlessIntElementsAttr<32, dims>;

 CPred<"$_self.isa<::mlir::AffineMapAttr>()">, "AffineMap attribute"> {
   let storageType = [{::mlir::AffineMapAttr }];
   let returnType = [{ ::mlir::AffineMap }];
   let valueType = Index;
   let constBuilderCall = "::mlir::AffineMapAttr::get($0)";
 }
 
 // Base class for array attributes.
-class ArrayAttrBase<Pred condition, string description> :
-    Attr<condition, description> {
+class ArrayAttrBase<Pred condition, string summary> : Attr<condition, summary> {
   let storageType = [{ ::mlir::ArrayAttr }];
   let returnType = [{ ::mlir::ArrayAttr }];
   let valueType = NoneType;
   let convertFromStorage = "$_self";
 }
 
 def ArrayAttr : ArrayAttrBase<CPred<"$_self.isa<::mlir::ArrayAttr>()">,
                               "array attribute">;
 
 // Base class for array attributes whose elements are of the same kind.
 // `element` specifies the element attribute kind stored in this array.
-class TypedArrayAttrBase<Attr element, string description>: ArrayAttrBase<
+class TypedArrayAttrBase<Attr element, string summary>: ArrayAttrBase<
     And<[
       // Guarantee this is an ArrayAttr first
       CPred<"$_self.isa<::mlir::ArrayAttr>()">,
       // Guarantee all elements satisfy the constraints from `element`
       Concat<"::llvm::all_of($_self.cast<::mlir::ArrayAttr>(), "
                             "[](::mlir::Attribute attr) { return ",
                                SubstLeaves<"$_self", "attr", element.predicate>,
                             "; })">]>,
-    description> {
+    summary> {
   let constBuilderCall = "$_builder.getArrayAttr($0)";
 
   Attr elementAttr = element;
 }
 
 def AffineMapArrayAttr : TypedArrayAttrBase<AffineMapAttr,
                                       "AffineMap array attribute"> {
   let constBuilderCall = "$_builder.getAffineMapArrayAttr($0)";

 //===----------------------------------------------------------------------===//
 
 // A general mechanism to further confine the given `attr` with all the
 // `constraints`. This allows to compose complex constraints out of a series
 // of more primitive ones.
 class Confined<Attr attr, list<AttrConstraint> constraints> : Attr<
     And<!listconcat([attr.predicate],
                       !foreach(pred, constraints, pred.predicate))>,
-    !foldl(/*init*/attr.description, /*list*/constraints,
-           prev, cur, prev # " " # cur.description)> {
+    !foldl(/*init*/attr.summary, /*list*/constraints,
+           prev, cur, prev # " " # cur.summary)> {
   let storageType = attr.storageType;
   let returnType = attr.returnType;
   let convertFromStorage = attr.convertFromStorage;
   let constBuilderCall = attr.constBuilderCall;
   let defaultValue = attr.defaultValue;
   let valueType = attr.valueType;
   let isOptional = attr.isOptional;
 
   let baseAttr = attr;
 }
 
 // An AttrConstraint that holds if all attr constraints specified in
 // 'constraints' hold.
 class AllAttrConstraintsOf<list<AttrConstraint> constraints> : AttrConstraint<
     And<!listconcat([!head(constraints).predicate],
                       !foreach(pred, !tail(constraints), pred.predicate))>,
-    !interleave(!foreach(con, constraints, con.description), " and ")> {
+    !interleave(!foreach(con, constraints, con.summary), " and ")> {
 }
 
 class IntMinValue<int n> : AttrConstraint<
     CPred<"$_self.cast<::mlir::IntegerAttr>().getInt() >= " # n>,
     "whose minimum value is " # n>;
 
 class IntMaxValue<int n> : AttrConstraint<
     CPred<"$_self.cast<::mlir::IntegerAttr>().getInt() <= " # n>,

 
 // A region with the given number of blocks.
 class SizedRegion<int numBlocks> : Region<
   CPred<"::llvm::hasNItems($_self, " # numBlocks # ")">,
   "region with " # numBlocks # " blocks">;
 
 // A variadic region constraint. It expands to zero or more of the base region.
 class VariadicRegion<Region region>
-  : Region<region.predicate, region.description>;
+  : Region<region.predicate, region.summary>;
 
 //===----------------------------------------------------------------------===//
 // Successor definitions
 //===----------------------------------------------------------------------===//
 
 class Successor<Pred condition, string descr = ""> :
     SuccessorConstraint<condition, descr>;
 
 // Any successor.
 def AnySuccessor : Successor<?, "any successor">;
 
 // A variadic successor constraint. It expands to zero or more of the base
 // successor.
 class VariadicSuccessor<Successor successor>
-  : Successor<successor.predicate, successor.description>;
+  : Successor<successor.predicate, successor.summary>;
 
 //===----------------------------------------------------------------------===//
 // OpTrait definitions
 //===----------------------------------------------------------------------===//
 
 // OpTrait represents a trait regarding an op.
 class OpTrait;
 

 // affects op definition generator internals, like how op builders and
 // operand/attribute/result getters are generated.
 class GenInternalOpTrait<string prop> : OpTrait {
   string trait = "::mlir::OpTrait::" # prop;
 }
 
 // PredOpTrait is an op trait implemented by way of a predicate on the op.
 class PredOpTrait<string descr, Pred pred> : OpTrait {
-  string description = descr;
+  string summary = descr;
   Pred predicate = pred;
 }
 
 // Op defines an affine scope.
 def AffineScope : NativeOpTrait<"AffineScope">;
 // Op defines an automatic allocation scope.
 def AutomaticAllocationScope : NativeOpTrait<"AutomaticAllocationScope">;
 // Op supports operand broadcast behavior.

 
 // Class for providing additional information on the variables, i.e. arguments
 // and results, of an operation.
 class OpVariable<Constraint varConstraint, string desc = "",
                  list<OpVariableDecorator> varDecorators = []> {
   // The constraint, either attribute or type, of the argument.
   Constraint constraint = varConstraint;
 
-  // A description for the argument.
-  string description = desc;
+  // One-line human-readable description of the argument.
+  string summary = desc;
 
   // The list of decorators for this variable, e.g. side effects.
   list<OpVariableDecorator> decorators = varDecorators;
 }
 class Arg<Constraint constraint, string desc = "",
           list<OpVariableDecorator> decorators = []>
   : OpVariable<constraint, desc, decorators>;
 class Res<Constraint constraint, string desc = "",
StrFunc<"$" # name # ".getType().cast<::mlir::ShapedType>()"
                                  ".getNumElements()">;
 
 class ElementType<string name> : StrFunc<"getElementTypeOrSelf($" # name # ")">;
 
 class AllMatchPred<list<string> values> :
     CPred<"::llvm::is_splat(::llvm::makeArrayRef({"
           # !interleave(values, ", ") #"}))">;
 
-class AllMatch<list<string> values, string description> :
-    PredOpTrait<description, AllMatchPred<values>>;
+class AllMatch<list<string> values, string summary> :
+    PredOpTrait<summary, AllMatchPred<values>>;
 
 // TODO: Only works for non-variadic.
 class AllMatchSameOperatorPred<list<string> names, string operator> :
     AllMatchPred<!foreach(n, names, !subst("$_self", "$" # n, operator))>;
 
 class AllMatchSameOperatorTrait<list<string> names, string operator,
-                                string description> :
+                                string summary> :
     PredOpTrait<
-        "all of {" # !interleave(names, ", ") # "} have same " # description,
+        "all of {" # !interleave(names, ", ") # "} have same " # summary,
         AllMatchSameOperatorPred<names, operator>> {
   list<string> values = names;
 }
 
 class AllElementCountsMatch<list<string> names> :
     AllMatchSameOperatorTrait<names, ElementCount<"_self">.result,
                               "element count">;
 
 class AllElementTypesMatch<list<string> names> :
     AllMatchSameOperatorTrait<names, ElementType<"_self">.result,
                               "element type">;
 
 class AllRanksMatch<list<string> names> :
     AllMatchSameOperatorTrait<names, Rank<"_self">.result, "rank">;
 
 class AllShapesMatch<list<string> names> :
     AllMatchSameOperatorTrait<names, Shape<"_self">.result, "shape">;
 
 class AllTypesMatch<list<string> names> :
     AllMatchSameOperatorTrait<names, "$_self.getType()", "type">;
 
 // A type constraint that denotes `transform(lhs.getType()) == rhs.getType()`.
-class TypesMatchWith<string description, string lhsArg, string rhsArg,
+class TypesMatchWith<string summary, string lhsArg, string rhsArg,
                      string transform> :
-    PredOpTrait<description, CPred<
+    PredOpTrait<summary, CPred<
       !subst("$_self", "$" # lhsArg # ".getType()", transform)
       # " == $" # rhsArg # ".getType()">> {
   string lhs = lhsArg;
   string rhs = rhsArg;
   string transformer = transform;
 }
 
 // Type Constraint operand `idx`'s Element type is `type`.
 class TCopVTEtIs<int idx, Type type> : And<[
    CPred<"$_op.getNumOperands() > " # idx>,
    SubstLeaves<"$_self", "$_op.getOperand(" # idx # ").getType()",
      IsShapedTypePred>,
    SubstLeaves<"$_self", "getElementTypeOrSelf($_op.getOperand(" # idx # "))",
      type.predicate>]>;
 
 // Predicate to verify that a named argument or result's element type matches a
 // given type.
 class TypeIsPred<string name, Type type> :
    SubstLeaves<"$_self", "$" # name # ".getType()", type.predicate>;
 class TypeIs<string name, Type type> : PredOpTrait<
-  "'" # name # "' is " # type.description, TypeIsPred<name, type>>;
+  "'" # name # "' is " # type.summary, TypeIsPred<name, type>>;
 
 // Predicate to verify that a named argument or result's element type matches a
 // given type.
 class ElementTypeIsPred<string name, Type type> : And<[
    SubstLeaves<"$_self", "$" # name # ".getType()", IsShapedTypePred>,
    SubstLeaves<"$_self", "getElementTypeOrSelf($" # name # ")",
      type.predicate>]>;
 class ElementTypeIs<string name, Type type> : PredOpTrait<
-  "'" # name # "' is " # type.description, ElementTypeIsPred<name, type>>;
+  "'" # name # "' is " # type.summary, ElementTypeIsPred<name, type>>;
 
 // Predicate to verify that the i'th operand and the j'th operand have the same
 // elemental type.
 // Type Constraint operand `i`'s Element type is Same As operand `j`'s Element
 // type.
 class TCopVTEtIsSameAs<int i, int j> : And<[
     CPred<"$_op.getNumOperands() > " # !if(!gt(i,j),i,j)>,
     SubstLeaves<"$_self", "$_op.getOperand(" # i # ").getType()",

 // Define a new type, named `name`, belonging to `dialect` that inherits from
 // the given C++ base class.
 class TypeDef<Dialect dialect, string name,
               string baseCppClass = "::mlir::Type">
     : DialectType<dialect, CPred<"">, /*descr*/"", name # "Type"> {
   // The name of the C++ base class to use for this Type.
   string cppBaseClassName = baseCppClass;
 
-  // Short summary of the type.
-  string summary = ?;
+  // Additional, longer human-readable description of what the op does.
+  string description = "";
 
   // Name of storage class to generate or use.
   string storageClass = name # "TypeStorage";
   // Namespace (withing dialect c++ namespace) in which the storage class
   // resides.
   string storageNamespace = "detail";
   // Specify if the storage class is to be generated.
   bit genStorageClass = 1;

 
 // 'Parameters' should be subclasses of this or simple strings (which is a
 // shorthand for TypeParameter<"C++Type">).
 class TypeParameter<string type, string desc> {
   // Custom memory allocation code for storage constructor.
   code allocator = ?;
   // The C++ type of this parameter.
   string cppType = type;
-  // A description of this parameter.
-  string description = desc;
+  // One-line human-readable description of the argument.
+  string summary = desc;
   // The format string for the asm syntax (documentation only).
   string syntax = ?;
 }
 
 // For StringRefs, which require allocation.
 class StringRefParameter<string desc> :
     TypeParameter<"::llvm::StringRef", desc> {
   let allocator = [{$_dst = $_allocator.copyInto($_self);}];

mlir/include/mlir/TableGen/Constraint.h

public:
   // Returns the condition template that can be used to check if a type or
   // attribute satisfies this constraint.  The template may contain "{0}" that
   // must be substituted with an expression returning an mlir::Type or
   // mlir::Attribute.
   std::string getConditionTemplate() const;
 
   // Returns the user-readable description of this constraint. If the
   // description is not provided, returns the TableGen def name.
-  StringRef getDescription() const;
+  StringRef getSummary() const;
 
   // Constraint kind
   enum Kind { CK_Attr, CK_Region, CK_Successor, CK_Type, CK_Uncategorized };
 
   Kind getKind() const { return kind; }
 
   /// Get an opaque pointer to the constraint.
   const void *getAsOpaquePointer() const { return def; }

mlir/include/mlir/TableGen/OpTrait.h

 
 // OpTrait corresponding to a predicate on the operation.
 class PredOpTrait : public OpTrait {
 public:
   // Returns the template for constructing the predicate.
   std::string getPredTemplate() const;
 
   // Returns the description of what the predicate is verifying.
-  StringRef getDescription() const;
+  StringRef getSummary() const;
 
   static bool classof(const OpTrait *t) { return t->getKind() == Kind::Pred; }
 };
 
 // OpTrait controlling op definition generator internals.
 class InternalOpTrait : public OpTrait {
 public:
   // Returns the trait controlling op definition generator internals.

mlir/include/mlir/TableGen/Type.h

 };
 
 // Wrapper class with helper methods for accessing Types defined in TableGen.
 class Type : public TypeConstraint {
 public:
   explicit Type(const llvm::Record *record);
 
   // Returns the description of the type.
-  StringRef getTypeDescription() const;
+  StringRef getDescription() const;
 
   // Returns the dialect for the type if defined.
   Dialect getDialect() const;
 };
 
 } // end namespace tblgen
 } // end namespace mlir
 
 #endif // MLIR_TABLEGEN_TYPE_H_

mlir/include/mlir/TableGen/TypeDef.h

 class TypeParameter {
 public:
   explicit TypeParameter(const llvm::DagInit *def, unsigned num)
       : def(def), num(num) {}
 
   // Get the parameter name.
   StringRef getName() const;
   // If specified, get the custom allocator code for this parameter.
-  llvm::Optional<StringRef> getAllocator() const;
+  Optional<StringRef> getAllocator() const;
   // Get the C++ type of this parameter.
   StringRef getCppType() const;
   // Get a description of this parameter for documentation purposes.
-  llvm::Optional<StringRef> getDescription() const;
+  Optional<StringRef> getSummary() const;
   // Get the assembly syntax documentation.
   StringRef getSyntax() const;
 
 private:
   const llvm::DagInit *def;
   const unsigned num;
 };
 
 } // end namespace tblgen
 } // end namespace mlir
 
 #endif // MLIR_TABLEGEN_TYPEDEF_H

mlir/lib/TableGen/Constraint.cpp

Pred Constraint::getPredicate() const {
   const auto *pred = dyn_cast<llvm::DefInit>(val->getValue());
   return Pred(pred);
 }
 
 std::string Constraint::getConditionTemplate() const {
   return getPredicate().getCondition();
 }
 
-StringRef Constraint::getDescription() const {
-  // If a summary is found, we use that given that it is a focused single line
-  // comment.
+StringRef Constraint::getSummary() const {
   if (Optional<StringRef> summary = def->getValueAsOptionalString("summary"))
     return *summary;
-  // If a summary can't be found, look for a specific description field to use
-  // for the constraint.
-  StringRef desc = def->getValueAsString("description");
-  if (!desc.empty())
-    return desc;
-  // Otherwise, fallback to the name of the constraint definition.
   return def->getName();
 }
 
 AppliedConstraint::AppliedConstraint(Constraint &&constraint,
                                      llvm::StringRef self,
                                      std::vector<std::string> &&entities)
     : constraint(constraint), self(std::string(self)),
       entities(std::move(entities)) {}

mlir/lib/TableGen/OpTrait.cpp

llvm::StringRef InternalOpTrait::getTrait() const {
   return def->getValueAsString("trait");
 }
 
 std::string PredOpTrait::getPredTemplate() const {
   auto pred = Pred(def->getValueInit("predicate"));
   return pred.getCondition();
 }
 
-llvm::StringRef PredOpTrait::getDescription() const {
-  return def->getValueAsString("description");
+llvm::StringRef PredOpTrait::getSummary() const {
+  return def->getValueAsString("summary");
 }
 
 OpInterface InterfaceOpTrait::getOpInterface() const {
   return OpInterface(def);
 }
 
 std::string InterfaceOpTrait::getTrait() const {
   llvm::StringRef trait = def->getValueAsString("trait");

mlir/lib/TableGen/Type.cpp

 
 // Return the C++ class name for this type (which may just be ::mlir::Type).
 StringRef TypeConstraint::getCPPClassName() const {
   return def->getValueAsString("cppClassName");
 }
 
 Type::Type(const llvm::Record *record) : TypeConstraint(record) {}
 
-StringRef Type::getTypeDescription() const {
-  return def->getValueAsString("typeDescription");
+StringRef Type::getDescription() const {
+  return def->getValueAsString("description");
 }
 
 Dialect Type::getDialect() const {
   return Dialect(def->getValueAsDef("dialect"));
 }

mlir/lib/TableGen/TypeDef.cpp

 
 bool TypeDef::operator<(const TypeDef &other) const {
   return getName() < other.getName();
 }
 
 StringRef TypeParameter::getName() const {
   return def->getArgName(num)->getValue();
 }
-llvm::Optional<StringRef> TypeParameter::getAllocator() const {
+Optional<StringRef> TypeParameter::getAllocator() const {
   llvm::Init *parameterType = def->getArg(num);
   if (isa<llvm::StringInit>(parameterType))
     return llvm::Optional<StringRef>();
 
   if (auto *typeParameter = dyn_cast<llvm::DefInit>(parameterType)) {
     llvm::RecordVal *code = typeParameter->getDef()->getValue("allocator");
     if (!code)
       return llvm::Optional<StringRef>();
StringRef TypeParameter::getCppType() const {
   if (auto *stringType = dyn_cast<llvm::StringInit>(parameterType))
     return stringType->getValue();
   if (auto *typeParameter = dyn_cast<llvm::DefInit>(parameterType))
     return typeParameter->getDef()->getValueAsString("cppType");
   llvm::PrintFatalError(
       "Parameters DAG arguments must be either strings or defs "
       "which inherit from TypeParameter\n");
 }
-llvm::Optional<StringRef> TypeParameter::getDescription() const {
+Optional<StringRef> TypeParameter::getSummary() const {
   auto *parameterType = def->getArg(num);
   if (auto *typeParameter = dyn_cast<llvm::DefInit>(parameterType)) {
     const auto *desc = typeParameter->getDef()->getValue("description");
     if (llvm::StringInit *ci = dyn_cast<llvm::StringInit>(desc->getValue()))
       return ci->getValue();
   }
-  return llvm::Optional<StringRef>();
+  return Optional<StringRef>();
 }
 StringRef TypeParameter::getSyntax() const {
   auto *parameterType = def->getArg(num);
   if (auto *stringType = dyn_cast<llvm::StringInit>(parameterType))
     return stringType->getValue();
   if (auto *typeParameter = dyn_cast<llvm::DefInit>(parameterType)) {
     const auto *syntax = typeParameter->getDef()->getValue("syntax");
     if (syntax && isa<llvm::StringInit>(syntax->getValue()))
       return dyn_cast<llvm::StringInit>(syntax->getValue())->getValue();
     return getCppType();
   }
   llvm::PrintFatalError("Parameters DAG arguments must be either strings or "
                         "defs which inherit from TypeParameter");
 }

mlir/test/mlir-tblgen/op-attribute.td

 // RECORD-LABEL: def SomeTypedArrayAttr
 // RECORD: Attr elementAttr = SomeAttr;
 
 def Test_Dialect_2 : Dialect {
   let name = "dialect_2";
 }
 def MyStruct : StructAttr<"MyStruct", Test_Dialect_2, 
 [StructFieldAttr<"potatoes", I64ElementsAttr>]> {
-  let description = "A structure describing a number of potatoes.";
+  let summary = "A structure describing a number of potatoes.";
 }
 
 def StructAttrOp : NS_Op<"struct_attr_op", []> {
   let arguments = (ins
     MyStruct:$potatoes
   );
 }
 
 // DECL: dialect_2::MyStruct potatoes();

mlir/tools/mlir-tblgen/EnumsGen.cpp

static void emitUnderlyingToSymFnForBitEnum(const Record &enumDef,
   os << "}\n";
 }
 
 static void emitEnumDecl(const Record &enumDef, raw_ostream &os) {
   EnumAttr enumAttr(enumDef);
   StringRef enumName = enumAttr.getEnumClassName();
   StringRef cppNamespace = enumAttr.getCppNamespace();
   std::string underlyingType = std::string(enumAttr.getUnderlyingType());
-  StringRef description = enumAttr.getDescription();
+  StringRef description = enumAttr.getSummary();
   StringRef strToSymFnName = enumAttr.getStringToSymbolFnName();
   StringRef symToStrFnName = enumAttr.getSymbolToStringFnName();
   StringRef symToStrFnRetType = enumAttr.getSymbolToStringFnRetType();
   StringRef underlyingToSymFnName = enumAttr.getUnderlyingToSymbolFnName();
   auto enumerants = enumAttr.getAllCases();
 
   llvm::SmallVector<StringRef, 2> namespaces;
   llvm::SplitString(cppNamespace, namespaces, "::");

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

os << "static ::mlir::LogicalResult " << name
           "valueKind, unsigned valueGroupStartIndex) {\n";
 
     os << "  if (!("
        << tgfmt(constraint.getConditionTemplate(), &fctx.withSelf("type"))
        << ")) {\n"
        << formatv(
               "    return op->emitOpError(valueKind) << \" #\" << "
               "valueGroupStartIndex << \" must be {0}, but got \" << type;\n",
-              constraint.getDescription())
+              constraint.getSummary())
        << "  }\n"
        << "  return ::mlir::success();\n"
        << "}\n\n";
   }
 }
 
 //===----------------------------------------------------------------------===//
 // Utility structs and functions
if (allowMissingAttr) {
       // set. This does effectively assume that the default value is valid.
       // TODO: verify the debug value is valid (perhaps in debug mode only).
       body << "  if (" << varName << ") {\n";
     }
 
     body << tgfmt("    if (!($0)) return $1\"attribute '$2' "
                   "failed to satisfy constraint: $3\");\n",
                   /*ctx=*/nullptr, tgfmt(condition, &ctx.withSelf(varName)),
-                  emitErrorPrefix, attrName, attr.getDescription());
+                  emitErrorPrefix, attrName, attr.getSummary());
     if (allowMissingAttr)
       body << "  }\n";
     body << "  }\n";
   }
 }
 
 OpEmitter::OpEmitter(const Operator &op,
                      const StaticVerifierFunctionEmitter &staticVerifierEmitter)
void OpEmitter::genVerifier() {
   genOperandResultVerifier(body, op.getOperands(), "operand");
   genOperandResultVerifier(body, op.getResults(), "result");
 
   for (auto &trait : op.getTraits()) {
     if (auto *t = dyn_cast<tblgen::PredOpTrait>(&trait)) {
       body << tgfmt("  if (!($0))\n    "
                     "return emitOpError(\"failed to verify that $1\");\n",
                     &verifyCtx, tgfmt(t->getPredTemplate(), &verifyCtx),
-                    t->getDescription());
+                    t->getSummary());
     }
   }
 
   genRegionVerifier(body);
   genSuccessorVerifier(body);
 
   if (hasCustomVerify) {
     FmtContext fctx;
for (unsigned i = 0; i < numRegions; ++i) {
 
     body << formatv("      (void)region;\n"
                     "      if (!({0})) {\n        "
                     "return emitOpError(\"region #\") << index << \" {1}"
                     "failed to "
                     "verify constraint: {2}\";\n      }\n",
                     constraint,
                     region.name.empty() ? "" : "('" + region.name + "') ",
-                    region.constraint.getDescription())
+                    region.constraint.getSummary())
          << "      ++index;\n"
          << "    }\n";
   }
   body << "  }\n";
 }
 
 void OpEmitter::genSuccessorVerifier(OpMethodBody &body) {
   // If we have no successors, there is nothing more to do.
auto constraint = tgfmt(successor.constraint.getConditionTemplate(),
                           .str();
 
     body << formatv("      (void)successor;\n"
                     "      if (!({0})) {\n        "
                     "return emitOpError(\"successor #\") << index << \"('{1}') "
                     "failed to "
                     "verify constraint: {2}\";\n      }\n",
                     constraint, successor.name,
-                    successor.constraint.getDescription())
+                    successor.constraint.getSummary())
          << "      ++index;\n"
          << "    }\n";
   }
   body << "  }\n";
 }
 
 /// Add a size count trait to the given operation class.
 static void addSizeCountTrait(OpClass &opClass, StringRef traitKind,

mlir/tools/mlir-tblgen/OpDocGen.cpp

 
 /// Emit the given named constraint.
 template <typename T>
 static void emitNamedConstraint(const T &it, raw_ostream &os) {
   if (!it.name.empty())
     os << "`" << it.name << "`";
   else
     os << "&laquo;unnamed&raquo;";
-  os << " | " << it.constraint.getDescription() << "\n";
+  os << " | " << it.constraint.getSummary() << "\n";
 }
 
 //===----------------------------------------------------------------------===//
 // Operation Documentation
 //===----------------------------------------------------------------------===//
 
 /// Emit the assembly format of an operation.
 static void emitAssemblyFormat(StringRef opName, StringRef format,
if (op.getNumAttributes() != 0) {
     // TODO: Attributes are only documented by TableGen name, with no further
     // info. This should be improved.
     os << "\n#### Attributes:\n\n";
     os << "| Attribute | MLIR Type | Description |\n"
        << "| :-------: | :-------: | ----------- |\n";
     for (const auto &it : op.getAttributes()) {
       StringRef storageType = it.attr.getStorageType();
       os << "`" << it.name << "` | " << storageType << " | "
-         << it.attr.getDescription() << "\n";
+         << it.attr.getSummary() << "\n";
     }
   }
 
   // Emit each of the operands.
   if (op.getNumOperands() != 0) {
     os << "\n#### Operands:\n\n";
     os << "| Operand | Description |\n"
        << "| :-----: | ----------- |\n";
for (const llvm::Record *opDef : opDefs)
     emitOpDoc(Operator(opDef), os);
 }
 
 //===----------------------------------------------------------------------===//
 // Type Documentation
 //===----------------------------------------------------------------------===//
 
 static void emitTypeDoc(const Type &type, raw_ostream &os) {
-  os << "### " << type.getDescription() << "\n";
-  emitDescription(type.getTypeDescription(), os);
+  os << "### " << type.getSummary() << "\n";
+  emitDescription(type.getDescription(), os);
   os << "\n";
 }
 
 //===----------------------------------------------------------------------===//
 // TypeDef Documentation
 //===----------------------------------------------------------------------===//
 
 /// Emit the assembly format of a type.
if (td.getMnemonic() && td.getPrinterCode() && *td.getPrinterCode() == "" &&
       td.getParserCode() && *td.getParserCode() == "")
     emitTypeAssemblyFormat(td, os);
   if (td.hasDescription())
     mlir::tblgen::emitDescription(td.getDescription(), os);
 
   // Emit attribute documentation.
   SmallVector<TypeParameter, 4> parameters;
   td.getParameters(parameters);
-  if (parameters.size() != 0) {
+  if (!parameters.empty()) {
     os << "\n#### Type parameters:\n\n";
     os << "| Parameter | C++ type | Description |\n"
        << "| :-------: | :-------: | ----------- |\n";
     for (const auto &it : parameters) {
-      auto desc = it.getDescription();
+      auto desc = it.getSummary();
       os << "| " << it.getName() << " | `" << td.getCppClassName() << "` | "
          << (desc ? *desc : "") << " |\n";
     }
   }
 
   os << "\n";
 }
 

mlir/tools/mlir-tblgen/OpFormatGen.cpp

for (TypeResolution &resolver :
     body << "  for (::mlir::Type type : " << variable->name << "Types) {\n"
          << "    (void)type;\n"
          << "    if (!("
          << tgfmt(constraint.getConditionTemplate(),
                   &verifierFCtx.withSelf("type"))
          << ")) {\n"
          << formatv("      return parser.emitError(parser.getNameLoc()) << "
                     "\"'{0}' must be {1}, but got \" << type;\n",
-                    variable->name, constraint.getDescription())
+                    variable->name, constraint.getSummary())
          << "    }\n"
          << "  }\n";
   }
 
   // Initialize the set of buildable types.
   if (!buildableTypes.empty()) {
     FmtContext typeBuilderCtx;
     typeBuilderCtx.withBuilder("parser.getBuilder()");

mlir/tools/mlir-tblgen/RewriterGen.cpp

for (int i = 0, e = tree.getNumArgs(); i != e; ++i) {
 
     auto self = formatv("{0}", argName);
     emitMatchCheck(
         opName,
         tgfmt(constraint.getConditionTemplate(), &fmtCtx.withSelf(self)),
         formatv("\"operand {0} of native code call '{1}' failed to satisfy "
                 "constraint: "
                 "'{2}'\"",
-                i, tree.getNativeCodeTemplate(), constraint.getDescription()));
+                i, tree.getNativeCodeTemplate(), constraint.getSummary()));
   }
 
   LLVM_DEBUG(llvm::dbgs() << "done emitting match for native code call\n");
 }
 
 // Helper function to match patterns.
 void PatternEmitter::emitOpMatch(DagNode tree, StringRef opName, int depth) {
   Operator &op = tree.getDialectOp(opMap);
if (operand->constraint != constraint) {
       auto self = formatv("(*{0}.getODSOperands({1}).begin()).getType()",
                           opName, argIndex);
       emitMatchCheck(
           opName,
           tgfmt(constraint.getConditionTemplate(), &fmtCtx.withSelf(self)),
           formatv("\"operand {0} of op '{1}' failed to satisfy constraint: "
                   "'{2}'\"",
                   operand - op.operand_begin(), op.getOperationName(),
-                  constraint.getDescription()));
+                  constraint.getSummary()));
     }
   }
 
   // Capture the value
   auto name = tree.getArgName(argIndex);
   // `$_` is a special symbol to ignore op argument matching.
   if (!name.empty() && name != "_") {
     // We need to subtract the number of attributes before this operand to get
if (!matcher.isUnspecified()) {
     // If a constraint is specified, we need to generate C++ statements to
     // check the constraint.
     emitMatchCheck(
         opName,
         tgfmt(matcher.getConditionTemplate(), &fmtCtx.withSelf("tblgen_attr")),
         formatv("\"op '{0}' attribute '{1}' failed to satisfy constraint: "
                 "{2}\"",
                 op.getOperationName(), namedAttr->name,
-                matcher.getAsConstraint().getDescription()));
+                matcher.getAsConstraint().getSummary()));
   }
 
   // Capture the value
   auto name = tree.getArgName(argIndex);
   // `$_` is a special symbol to ignore op argument matching.
   if (!name.empty() && name != "_") {
     os << formatv("{0} = tblgen_attr;\n", name);
   }
for (auto &appliedConstraint : pattern.getConstraints()) {
 
     auto condition = constraint.getConditionTemplate();
     if (isa<TypeConstraint>(constraint)) {
       auto self = formatv("({0}.getType())",
                           symbolInfoMap.getValueAndRangeUse(entities.front()));
       emitMatchCheck(
           opName, tgfmt(condition, &fmtCtx.withSelf(self.str())),
           formatv("\"value entity '{0}' failed to satisfy constraint: {1}\"",
-                  entities.front(), constraint.getDescription()));
+                  entities.front(), constraint.getSummary()));
 
     } else if (isa<AttrConstraint>(constraint)) {
       PrintFatalError(
           loc, "cannot use AttrConstraint in Pattern multi-entity constraints");
     } else {
       // TODO: replace formatv arguments with the exact specified
       // args.
       if (entities.size() > 4) {
if (isa<TypeConstraint>(constraint)) {
       for (; i < 4; ++i)
         names.push_back("<unused>");
       emitMatchCheck(opName,
                      tgfmt(condition, &fmtCtx.withSelf(self), names[0],
                            names[1], names[2], names[3]),
                      formatv("\"entities '{0}' failed to satisfy constraint: "
                              "{1}\"",
                              llvm::join(entities, ", "),
-                             constraint.getDescription()));
+                             constraint.getSummary()));
     }
   }
 
   // Some of the operands could be bound to the same symbol name, we need
   // to enforce equality constraint on those.
   // TODO: we should be able to emit equality checks early
   // and short circuit unnecessary work if vars are not equal.
   for (auto symbolInfoIt = symbolInfoMap.begin();

mlir/tools/mlir-tblgen/StructsGen.cpp

)";
 
   os << "};\n\n";
 }
 
 static void emitStructDecl(const Record &structDef, raw_ostream &os) {
   StructAttr structAttr(&structDef);
   StringRef structName = structAttr.getStructClassName();
   StringRef cppNamespace = structAttr.getCppNamespace();
-  StringRef description = structAttr.getDescription();
+  StringRef description = structAttr.getSummary();
   auto fields = structAttr.getAllFields();
 
   // Wrap in the appropriate namespace.
   llvm::SmallVector<StringRef, 2> namespaces;
   llvm::SplitString(cppNamespace, namespaces, "::");
 
   for (auto ns : namespaces)
     os << "namespace " << ns << " {\n";

mlir/unittests/TableGen/structs.td

 def Test_Struct : StructAttr<"TestStruct", Test_Dialect, [
                 StructFieldAttr<"sample_integer", I32Attr>,
                 StructFieldAttr<"sample_float", F32Attr>,
                 StructFieldAttr<"sample_elements", I32ElementsAttr>,
                 StructFieldAttr<"sample_optional_integer",
                                 OptionalAttr<I32Attr>>,
                 StructFieldAttr<"sample_default_valued_integer",
                                 DefaultValuedAttr<I32Attr, "42">>] > {
-  let description = "Structure for test data";
+  let summary = "Structure for test data";
 }