[mlir][Properties] Shorten "Property" to "Prop" in most places

Since the property system isn't currently in heavy use, it's probably
the right time to fix a choice I made when expanding ODS property
support.

Specifically, most of the property subclasses, like OptionalProperty
or IntProperty, wrote out the word "Property" in full. The
corresponding classes in the Attribute hierarchy uses the short-form
"Attr" in those cases, as in OptionalAttr or DefaultValuedAttr.

This commit changes all those uses of "Property" to "Prop" in order to
prevent excessively verbose tablegen files that needlessly repeat the
full name of a core concept that can be abbreviated.

So, this commit renames all the FooProperty classes to FooProp, and
keeps the existing names as alias with a Deprecated<> on them to warn
people.

In addition, this commit updates the documentation around properties
to mention the constraint support.

Author: krzysz00

mlir/docs/DefiningDialects/Operations.md

@@ -102,8 +102,9 @@ their semantics via a special [TableGen backend][TableGenBackend]:
     constraints over attributes. A notable subclass hierarchy is `Attr`, which
     stands for constraints for attributes whose values are of common types.
 *   The `Property` class hierarchy: They are used to specify non-attribute-backed
-    properties that are inherent to operations. This will be expanded to a
-    `PropertyConstraint` class or something similar in the future.
+    properties that are inherent to operations. These properties can have
+    constraints imposed them using their `predicate` field or the
+    `ConfinedProp` class.
 
 An operation is defined by specializing the `Op` class with concrete contents
 for all the fields it requires. For example, `tf.AvgPool` is defined as
@@ -202,15 +203,15 @@ let arguments = (ins
   ...
   <attr-constraint>:$<attr-name>,
   ...
-  <property-constraint>:$<property-name>,
+  <property>:$<property-name>,
 );
 ```
 
 Here `<type-constraint>` is a TableGen `def` from the `TypeConstraint` class
 hierarchy. Similarly, `<attr-constraint>` is a TableGen `def` from the
-`AttrConstraint` class hierarchy and `<property-constraint>` is a subclass
-of `Property` (though a `PropertyConstraint` hierarchy is planned).
-See [Constraints](#constraints) for more information.
+`AttrConstraint` class hierarchy and `<property>` is a subclass
+of `Property` (constraints can be imposed onto it using its `predicate` field
+or the `ConfinedProp` subclass).
 
 There is no requirements on the relative order of operands and attributes; they
 can mix freely. The relative order of operands themselves matters. From each
@@ -334,13 +335,13 @@ TODO: Design and implement more primitive constraints
 
 #### Optional and default-valued properties
 
-To declare a property with a default value, use `DefaultValuedProperty<..., "...">`.
+To declare a property with a default value, use `DefaultValuedProp<..., "...">`.
 If the property's storage data type is different from its interface type,
 for example, in the case of array properties (which are stored as `SmallVector`s
 but use `ArrayRef` as an interface type), add the storage-type equivalent
 of the default value as the third argument.
 
-To declare an optional property, use `OptionalProperty<...>`.
+To declare an optional property, use `OptionalProp<...>`.
 This wraps the underlying property in an `std::optional` and gives it a
 default value of `std::nullopt`.
 
@@ -449,7 +450,7 @@ def MyOp : ... {
     I32Attr:$i32_attr,
     F32Attr:$f32_attr,
     ...
-    I32Property:$i32_prop,
+    I32Prop:$i32_prop,
     ...
   );
 
@@ -1011,7 +1012,7 @@ foo.op is_read_only
 foo.op
 ```
 
-The same logic applies to a `UnitProperty`.
+The same logic applies to a `UnitProp`.
 
 ##### Optional "else" Group
 

mlir/include/mlir/Dialect/Affine/IR/AffineOps.td

@@ -1193,7 +1193,7 @@ def AffineLinearizeIndexOp : Affine_Op<"linearize_index",
   let arguments = (ins Variadic<Index>:$multi_index,
     Variadic<Index>:$dynamic_basis,
     DenseI64ArrayAttr:$static_basis,
-    UnitProperty:$disjoint);
+    UnitProp:$disjoint);
   let results = (outs Index:$linear_index);
 
   let assemblyFormat = [{

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

@@ -60,7 +60,7 @@ class LLVM_IntArithmeticOpWithOverflowFlag<string mnemonic, string instName,
                                    list<Trait> traits = []> :
     LLVM_ArithmeticOpBase<AnySignlessInteger, mnemonic, instName,
     !listconcat([DeclareOpInterfaceMethods<IntegerOverflowFlagsInterface>], traits)> {
-  dag iofArg = (ins EnumProperty<"IntegerOverflowFlags", "", "IntegerOverflowFlags::none">:$overflowFlags);
+  dag iofArg = (ins EnumProp<"IntegerOverflowFlags", "", "IntegerOverflowFlags::none">:$overflowFlags);
   let arguments = !con(commonArgs, iofArg);
 
   string mlirBuilder = [{
@@ -558,7 +558,7 @@ class LLVM_CastOpWithOverflowFlag<string mnemonic, string instName, Type type,
                   Type resultType, list<Trait> traits = []> :
     LLVM_Op<mnemonic, !listconcat([Pure], [DeclareOpInterfaceMethods<IntegerOverflowFlagsInterface>], traits)>,
     LLVM_Builder<"$res = builder.Create" # instName # "($arg, $_resultType, /*Name=*/\"\", op.hasNoUnsignedWrap(), op.hasNoSignedWrap());"> {
-  let arguments = (ins type:$arg, EnumProperty<"IntegerOverflowFlags", "", "IntegerOverflowFlags::none">:$overflowFlags);
+  let arguments = (ins type:$arg, EnumProp<"IntegerOverflowFlags", "", "IntegerOverflowFlags::none">:$overflowFlags);
   let results = (outs resultType:$res);
   let builders = [LLVM_OneResultOpBuilder];
   let assemblyFormat = "$arg `` custom<OverflowFlags>($overflowFlags) attr-dict `:` type($arg) `to` type($res)";

mlir/include/mlir/IR/Properties.td

@@ -14,6 +14,7 @@
 #define PROPERTIES
 
 include "mlir/IR/Constraints.td"
+include "mlir/IR/Utils.td"
 
 // Base class for defining properties.
 class Property<string storageTypeParam = "", string desc = ""> {
@@ -211,7 +212,7 @@ defvar writeMlirBytecodeWithConvertToAttribute = [{
 // Primitive property kinds
 
 // Any kind of integer stored as properties.
-class IntProperty<string storageTypeParam, string desc = ""> :
+class IntProp<string storageTypeParam, string desc = ""> :
     Property<storageTypeParam, desc> {
   let summary = !if(!empty(desc), storageTypeParam, desc);
   let optionalParser = [{
@@ -228,10 +229,16 @@ class IntProperty<string storageTypeParam, string desc = ""> :
   }];
 }
 
-def I32Property : IntProperty<"int32_t">;
-def I64Property : IntProperty<"int64_t">;
+class IntProperty<string storageTypeParam, string desc = "">
+  : IntProp<storageTypeParam, desc>, Deprecated<"moved to the shorter name IntProp">;
 
-class EnumProperty<string storageTypeParam, string desc = "", string default = ""> :
+def I32Prop : IntProp<"int32_t">;
+def I64Prop : IntProp<"int64_t">;
+
+def I32Property : IntProp<"int32_t">, Deprecated<"moved to shorter name I32Prop">;
+def I64Property : IntProp<"int64_t">, Deprecated<"moved to shorter name I64Prop">;
+
+class EnumProp<string storageTypeParam, string desc = "", string default = ""> :
     Property<storageTypeParam, desc> {
   // TODO:  implement predicate for enum validity.
   let writeToMlirBytecode = [{
@@ -246,7 +253,12 @@ class EnumProperty<string storageTypeParam, string desc = "", string default = "
   let defaultValue = default;
 }
 
-def StringProperty : Property<"std::string", "string"> {
+class EnumProperty<string storageTypeParam, string desc = "", string default = ""> :
+  EnumProp<storageTypeParam, desc, default>,
+  Deprecated<"moved to shorter name EnumProp">;
+
+// Note: only a class so we can deprecate the old name
+class _cls_StringProp : Property<"std::string", "string"> {
   let interfaceType = "::llvm::StringRef";
   let convertFromStorage = "::llvm::StringRef{$_storage}";
   let assignToStorage = "$_storage = $_value.str()";
@@ -265,8 +277,11 @@ def StringProperty : Property<"std::string", "string"> {
     $_writer.writeOwnedString($_storage);
   }];
 }
+def StringProp : _cls_StringProp;
+def StringProperty : _cls_StringProp, Deprecated<"moved to shorter name StringProp">;
 
-def BoolProperty : IntProperty<"bool", "boolean"> {
+// Note: only a class so we can deprecate the old name
+class _cls_BoolProp : IntProp<"bool", "boolean"> {
   let printer = [{ $_printer << ($_storage ? "true" : "false") }];
   let readFromMlirBytecode = [{
     return $_reader.readBool($_storage);
@@ -275,8 +290,11 @@ def BoolProperty : IntProperty<"bool", "boolean"> {
     $_writer.writeOwnedBool($_storage);
   }];
 }
+def BoolProp : _cls_BoolProp;
+def BoolProperty : _cls_BoolProp, Deprecated<"moved to shorter name BoolProp">;
 
-def UnitProperty : Property<"bool", "unit property"> {
+// Note: only a class so we can deprecate the old name
+class _cls_UnitProp : Property<"bool", "unit property"> {
   let summary = "unit property";
   let description = [{
     A property whose presence or abscence is used as a flag.
@@ -337,14 +355,16 @@ def UnitProperty : Property<"bool", "unit property"> {
       return ::mlir::failure();
   }];
 }
+def UnitProp : _cls_UnitProp;
+def UnitProperty : _cls_UnitProp, Deprecated<"moved to shorter name UnitProp">;
 
 //===----------------------------------------------------------------------===//
 // Property field overwrites
 
 /// Class for giving a property a default value.
 /// This doesn't change anything about the property other than giving it a default
 /// which can be used by ODS to elide printing.
-class DefaultValuedProperty<Property p, string default = "", string storageDefault = ""> : Property<p.storageType, p.summary> {
+class DefaultValuedProp<Property p, string default = "", string storageDefault = ""> : Property<p.storageType, p.summary> {
   let defaultValue = default;
   let storageTypeValueOverride = storageDefault;
   let baseProperty = p;
@@ -365,11 +385,13 @@ class DefaultValuedProperty<Property p, string default = "", string storageDefau
   let readFromMlirBytecode = p.readFromMlirBytecode;
   let writeToMlirBytecode = p.writeToMlirBytecode;
 }
+class DefaultValuedProperty<Property p, string default = "", string storageDefault = "">
+  : DefaultValuedProp<p, default, storageDefault>, Deprecated<"moved to shorter name DefaultValuedProp">;
 
 /// Apply the predicate `pred` to the property `p`, ANDing it with any
 /// predicates it may already have. If `newSummary` is provided, replace the
 /// summary of `p` with `newSummary`.
-class ConfinedProperty<Property p, Pred pred, string newSummary = "">
+class ConfinedProp<Property p, Pred pred, string newSummary = "">
     : Property<p.storageType, !if(!empty(newSummary), p.summary, newSummary)> {
   let predicate = !if(!ne(p.predicate, TruePred), And<[p.predicate, pred]>, pred);
   let baseProperty = p;
@@ -391,6 +413,10 @@ class ConfinedProperty<Property p, Pred pred, string newSummary = "">
   let storageTypeValueOverride = p.storageTypeValueOverride;
 }
 
+class ConfinedProperty<Property p, Pred pred, string newSummary = "">
+  : ConfinedProp<p, pred, newSummary>,
+    Deprecated<"moved to shorter name ConfinedProp">;
+
 //===----------------------------------------------------------------------===//
 // Primitive property combinators
 
@@ -428,8 +454,8 @@ class _makeStorageWrapperPred<Property wrappedProp> {
 /// `SmallVector` of that property. This uses an `ArrayAttr` as its attribute form
 /// though subclasses can override this, as is the case with IntArrayAttr below.
 /// Those wishing to use a non-default number of SmallVector elements should
-/// subclass `ArrayProperty`.
-class ArrayProperty<Property elem = Property<>, string newSummary = ""> :
+/// subclass `ArrayProp`.
+class ArrayProp<Property elem = Property<>, string newSummary = ""> :
   Property<"::llvm::SmallVector<" # elem.storageType # ">",
     !if(!empty(newSummary), "array of " # elem.summary, newSummary)> {
   let interfaceType = "::llvm::ArrayRef<" # elem.storageType # ">";
@@ -548,9 +574,11 @@ class ArrayProperty<Property elem = Property<>, string newSummary = ""> :
       }()
     }]);
 }
+class ArrayProperty<Property elem = Property<>, string newSummary = "">
+  : ArrayProp<elem, newSummary>, Deprecated<"moved to shorter name ArrayProp">;
 
-class IntArrayProperty<Property elem, string newSummary=""> :
-    ArrayProperty<elem, newSummary> {
+class IntArrayProp<Property elem, string newSummary=""> :
+    ArrayProp<elem, newSummary> {
   // Bring back the trivial conversions we don't get in the general case.
   let convertFromAttribute = [{
     return convertFromAttribute($_storage, $_attr, $_diag);
@@ -559,6 +587,8 @@ class IntArrayProperty<Property elem, string newSummary=""> :
     return convertToAttribute($_ctxt, $_storage);
   }];
 }
+class IntArrayProperty<Property elem, string newSummary="">
+  : IntArrayProp<elem, newSummary>, Deprecated<"moved to shorter name IntArrayProp">;
 
 /// An optional property, stored as an std::optional<p.storageType>
 /// interfaced with as an std::optional<p.interfaceType>..
@@ -570,7 +600,7 @@ class IntArrayProperty<Property elem, string newSummary=""> :
 /// bracketing and delegate to the optional parser. In that case, the syntax is the
 /// syntax of the underlying property, or the keyword `none` in the rare cases that
 /// it is needed. This behavior can be disabled by setting `canDelegateParsing` to 0.
-class OptionalProperty<Property p, bit canDelegateParsing = 1>
+class OptionalProp<Property p, bit canDelegateParsing = 1>
     : Property<"std::optional<" # p.storageType # ">", "optional " # p.summary> {
 
   // In the cases where the underlying attribute is plain old data that's passed by
@@ -754,4 +784,7 @@ class OptionalProperty<Property p, bit canDelegateParsing = 1>
     "For delegated parsing to be used, the default value must be nullopt. " #
     "To use a non-trivial default, set the canDelegateParsing argument to 0";
 }
+class OptionalProperty<Property p, bit canDelegateParsing = 1>
+  : OptionalProp<p, canDelegateParsing>,
+    Deprecated<"moved to shorter name OptionalProp">;
 #endif // PROPERTIES