[mlir][ods] Look through OpVariable for constraint

[jpienaar]

Summary

If one uses an OpVariable (such as via Res) then the constraint of interest is in the constraint field.

[rriddle]

It'd be nice if there was a cleaner way in tablegen to do this kind of stuff.

mlir/lib/TableGen/Constraint.cpp

 
 #include "mlir/TableGen/Constraint.h"
 #include "llvm/TableGen/Record.h"
 
 using namespace mlir::tblgen;
 
 Constraint::Constraint(const llvm::Record *record)
     : def(record), kind(CK_Uncategorized) {
-  if (record->isSubClassOf("TypeConstraint")) {
+  // Look through OpVariable's to their constraint.
+  if (def->isSubClassOf("OpVariable"))
+    def = def->getValueAsDef("constraint");
+  if (def->isSubClassOf("TypeConstraint")) {
     kind = CK_Type;
-  } else if (record->isSubClassOf("AttrConstraint")) {
+  } else if (def->isSubClassOf("AttrConstraint")) {
     kind = CK_Attr;
-  } else if (record->isSubClassOf("RegionConstraint")) {
+  } else if (def->isSubClassOf("RegionConstraint")) {
     kind = CK_Region;
-  } else if (record->isSubClassOf("SuccessorConstraint")) {
+  } else if (def->isSubClassOf("SuccessorConstraint")) {
     kind = CK_Successor;
   } else {
-    assert(record->isSubClassOf("Constraint"));
+    assert(def->isSubClassOf("Constraint"));
   }
 }
 
 Constraint::Constraint(Kind kind, const llvm::Record *record)
-    : def(record), kind(kind) {}
+    : def(record), kind(kind) {
+  // Look through OpVariable's to their constraint.
+  if (def->isSubClassOf("OpVariable"))
+    def = def->getValueAsDef("constraint");
+}
 
 Pred Constraint::getPredicate() const {
   auto *val = def->getValue("predicate");
 
   // If no predicate is specified, then return the null predicate (which
   // corresponds to true).
   if (!val)
     return Pred();

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

 // CHECK:   static void build(OpBuilder &odsBuilder, OperationState &odsState, /*optional*/Type b, /*optional*/Value a)
 
 // Check that all types match constraint results in generating builder.
 // ---
 
 def NS_FOp : NS_Op<"op_with_all_types_constraint",
     [AllTypesMatch<["a", "b"]>]> {
   let arguments = (ins AnyType:$a);
-  let results = (outs AnyType:$b);
+  let results = (outs Res<AnyType, "output b", []>:$b);
 }
 
 // CHECK-LABEL: class FOp :
 // CHECK: static LogicalResult inferReturnTypes
 
 def NS_GOp : NS_Op<"op_with_fixed_return_type", []> {
   let arguments = (ins AnyType:$a);
   let results = (outs I32:$b);