[mlir][ODS] Add support for passing properties to `ref` in `custom`

[zero9178]

Summary

This is essentially a follow up to https://reviews.llvm.org/D155072

This adds support for also passing properties as ref parameter to custom. This requires the property to have been bound previously and will error otherwise. This makes it possible for an implementation of custom to take previously parsed data into account, creating nice context-dependent grammars :-)

mlir/test/IR/properties.mlir

 // GENERIC-SAME:  <{prop = "content for properties"}> : () -> ()
 test.with_wrapped_properties <{prop = "content for properties"}>
 
 // CHECK: test.using_property_in_custom
 // CHECK-SAME: [1, 4, 20]
 // GENERIC: "test.using_property_in_custom"()
 // GENERIC-SAME: prop = array<i64: 1, 4, 20>
 test.using_property_in_custom [1, 4, 20]
+
+// CHECK: test.using_property_ref_in_custom
+// CHECK-SAME: 1 + 4 = 5
+// GENERIC: "test.using_property_ref_in_custom"()
+// GENERIC-SAME: <{
+// GENERIC-SAME: first = 1
+// GENERIC-SAME: second = 4
+// GENERIC-SAME: }>
+test.using_property_ref_in_custom 1 + 4 = 5

mlir/test/lib/Dialect/Test/TestDialect.cpp

return parser.parseLSquare() || parser.parseInteger(value[0]) ||
          parser.parseRSquare();
 }
 
 static void printUsingPropertyInCustom(OpAsmPrinter &printer, Operation *op,
                                        ArrayRef<int64_t> value) {
   printer << '[' << value << ']';
 }
 
+static bool parseIntProperty(OpAsmParser &parser, int64_t &value) {
+  return failed(parser.parseInteger(value));
+}
+
+static void printIntProperty(OpAsmPrinter &printer, Operation *op,
+                             int64_t value) {
+  printer << value;
+}
+
+static bool parseSumProperty(OpAsmParser &parser, int64_t &second,
+                             int64_t first) {
+  int64_t sum;
+  auto loc = parser.getCurrentLocation();
+  if (parser.parseInteger(second) || parser.parseEqual() ||
+      parser.parseInteger(sum))
+    return true;
+  if (sum != second + first) {
+    parser.emitError(loc, "Expected sum to equal first + second");
+    return true;
+  }
+  return false;
+}
+
+static void printSumProperty(OpAsmPrinter &printer, Operation *op,
+                             int64_t second, int64_t first) {
+  printer << second << " = " << (second + first);
+}
+
 #include "TestOpEnums.cpp.inc"
 #include "TestOpInterfaces.cpp.inc"
 #include "TestTypeInterfaces.cpp.inc"
 
 #define GET_OP_CLASSES
 #include "TestOps.cpp.inc"

mlir/test/lib/Dialect/Test/TestOps.td

def TestOpWithWrappedProperties : TEST_Op<"with_wrapped_properties"> {
   );
 }
 
 def TestOpUsingPropertyInCustom : TEST_Op<"using_property_in_custom"> {
   let assemblyFormat = "custom<UsingPropertyInCustom>($prop) attr-dict";
   let arguments = (ins ArrayProperty<"int64_t", 3>:$prop);
 }
 
+def TestOpUsingPropertyRefInCustom : TEST_Op<"using_property_ref_in_custom"> {
+  let assemblyFormat = "custom<IntProperty>($first) `+` custom<SumProperty>($second, ref($first)) attr-dict";
+  let arguments = (ins IntProperty<"int64_t">:$first, IntProperty<"int64_t">:$second);
+}
+
 // Op with a properties struct defined out-of-line. The struct has custom
 // printer/parser.
 
 def PropertiesWithCustomPrint : Property<"PropertiesWithCustomPrint"> {
   let convertToAttribute = [{
     getPropertiesAsAttribute($_ctxt, $_storage)
   }];
   let convertFromAttribute = [{

mlir/test/mlir-tblgen/op-format-invalid.td

def VariableInvalidN : TestFormat_Op<[{
   let regions = (region AnyRegion:$region);
 }
 
 // CHECK: error: property 'prop' is already bound
 def VariableInvalidO : TestFormat_Op<[{
   custom<Test>($prop, $prop) attr-dict
 }]>, Arguments<(ins IntProperty<"int64_t">:$prop)>;
 
+// CHECK: error: property 'prop' must be bound before it is referenced
+def VariableInvalidP : TestFormat_Op<[{
+  custom<Test>(ref($prop)) attr-dict
+}]>, Arguments<(ins IntProperty<"int64_t">:$prop)>;
+
 //===----------------------------------------------------------------------===//
 // Coverage Checks
 //===----------------------------------------------------------------------===//
 
 // CHECK: error: type of result #0, named 'result', is not buildable and a buildable type cannot be inferred
 // CHECK: note: suggest adding a type constraint to the operation or adding a 'type($result)' directive to the custom assembly format
 def ZCoverageInvalidA : TestFormat_Op<[{
   attr-dict

mlir/tools/mlir-tblgen/OpFormatGen.cpp

if (const NamedAttribute *attr = findArg(op.getAttributes(), name)) {
     } else if (!seenAttrs.insert(attr)) {
       return emitError(loc, "attribute '" + name + "' is already bound");
     }
 
     return create<AttributeVariable>(attr);
   }
 
   if (const NamedProperty *property = findArg(op.getProperties(), name)) {
-    if (ctx != CustomDirectiveContext)
+    if (ctx != CustomDirectiveContext && ctx != RefDirectiveContext)
       return emitError(
           loc, "properties currently only supported in `custom` directive");
 
+    if (ctx == RefDirectiveContext) {
+      if (!seenProperties.count(property))
+        return emitError(loc, "property '" + name +
+                                  "' must be bound before it is referenced");
+    } else {
       if (!seenProperties.insert(property).second)
         return emitError(loc, "property '" + name + "' is already bound");
+    }
 
     return create<PropertyVariable>(property);
   }
 
   // Operands
   if (const NamedTypeConstraint *operand = findArg(op.getOperands(), name)) {
     if (ctx == TopLevelContext || ctx == CustomDirectiveContext) {
       if (fmt.allOperands || !seenOperands.insert(operand).second)