[mlir][ods] Add convertFromStorage field to parameters

[Mogball]

Summary

This patch adds a convertFromStorage field to attribute or type parameters that can implement more complex logic for converting from the parameter's C++ storage type (e.g. Optional<SmallVector<T>>) to its C++ type (e.g. Optional<ArrayRef<T>>).

[rriddle]

Can you add documentation for this field in the AttributesAndTypes.md doc?

LG, description looks a little weird in one spot though: complex logical for converting

[Mogball]

update docs

[Mogball]

rebase

mlir/include/mlir/IR/AttrTypeBase.td

class AttrOrTypeParameter<string type, string desc, string accessorType = ""> {
   code comparator = ?;
   // The C++ type of this parameter.
   string cppType = type;
   // The C++ type of the accessor for this parameter.
   string cppAccessorType = !if(!empty(accessorType), type, accessorType);
   // The C++ storage type of of this parameter if it is a reference, e.g.
   // `std::string` for `StringRef` or `SmallVector` for `ArrayRef`.
   string cppStorageType = ?;
+  // The C++ code to convert from the storage type to the parameter type.
+  string convertFromStorage = "$_self";
   // One-line human-readable description of the argument.
   string summary = desc;
   // The format string for the asm syntax (documentation only).
   string syntax = ?;
   // The default parameter parser is `::mlir::FieldParser<T>::parse($_parser)`,
   // which returns `FailureOr<T>`. Specialize `FieldParser` to support parsing
   // for your type. Or you can provide a customer printer. For attributes,
   // "$_type" will be replaced with the required attribute type.

mlir/include/mlir/TableGen/AttrOrTypeDef.h

public:
   StringRef getCppType() const;
 
   /// Get the C++ accessor type of this parameter.
   StringRef getCppAccessorType() const;
 
   /// Get the C++ storage type of this parameter.
   StringRef getCppStorageType() const;
 
+  /// Get the C++ code to convert from the storage type to the parameter type.
+  StringRef getConvertFromStorage() const;
+
   /// Get an optional C++ parameter parser.
   Optional<StringRef> getParser() const;
 
   /// Get an optional C++ parameter printer.
   Optional<StringRef> getPrinter() const;
 
   /// Get a description of this parameter for documentation purposes.
   Optional<StringRef> getSummary() const;

mlir/lib/TableGen/AttrOrTypeDef.cpp

Optional<StringRef> AttrOrTypeParameter::getAllocator() const {
   return getDefValue<llvm::StringInit>("allocator");
 }
 
 StringRef AttrOrTypeParameter::getComparator() const {
   return getDefValue<llvm::StringInit>("comparator").value_or("$_lhs == $_rhs");
 }
 
 StringRef AttrOrTypeParameter::getCppType() const {
-  llvm::Init *parameterType = getDef();
-  if (auto *stringType = dyn_cast<llvm::StringInit>(parameterType))
+  if (auto *stringType = dyn_cast<llvm::StringInit>(getDef()))
     return stringType->getValue();
-  if (auto *param = dyn_cast<llvm::DefInit>(parameterType))
-    return param->getDef()->getValueAsString("cppType");
-  llvm::PrintFatalError(
-      "Parameters DAG arguments must be either strings or defs "
-      "which inherit from AttrOrTypeParameter\n");
+  return getDefValue<llvm::StringInit>("cppType").getValue();
 }
 
 StringRef AttrOrTypeParameter::getCppAccessorType() const {
   return getDefValue<llvm::StringInit>("cppAccessorType")
       .value_or(getCppType());
 }
 
 StringRef AttrOrTypeParameter::getCppStorageType() const {
   return getDefValue<llvm::StringInit>("cppStorageType").value_or(getCppType());
 }
 
+StringRef AttrOrTypeParameter::getConvertFromStorage() const {
+  return getDefValue<llvm::StringInit>("convertFromStorage")
+      .getValueOr("$_self");
+}
+
 Optional<StringRef> AttrOrTypeParameter::getParser() const {
   return getDefValue<llvm::StringInit>("parser");
 }
 
 Optional<StringRef> AttrOrTypeParameter::getPrinter() const {
   return getDefValue<llvm::StringInit>("printer");
 }
 

mlir/test/mlir-tblgen/attr-or-type-format.td

 // ATTR:   if (odsParser.parseComma())
 // ATTR:     return {};
 // ATTR:   _result_complex = ::parseAttrParamA(odsParser, odsType);
 // ATTR:   if (::mlir::failed(_result_complex))
 // ATTR:     return {};
 // ATTR:   if (odsParser.parseRParen())
 // ATTR:     return {};
 // ATTR:   return TestAAttr::get(odsParser.getContext(),
-// ATTR:                         *_result_value,
-// ATTR:                         *_result_complex);
+// ATTR:                         (*_result_value),
+// ATTR:                         (*_result_complex));
 // ATTR: }
 
 // ATTR: void TestAAttr::print(::mlir::AsmPrinter &odsPrinter) const {
 // ATTR:   odsPrinter << ' ' << "hello";
 // ATTR:   odsPrinter << ' ' << "=";
 // ATTR:   odsPrinter << ' ';
 // ATTR:   odsPrinter.printStrippedAttrOrType(getValue());
 // ATTR:   odsPrinter << ",";

 // ATTR:     StringRef _paramKey;
 // ATTR:     if (odsParser.parseKeyword(&_paramKey))
 // ATTR:       return {};
 // ATTR:     if (!_loop_body(_paramKey)) return {};
 // ATTR:     if ((odsStructIndex != 2 - 1) && odsParser.parseComma())
 // ATTR:       return {};
 // ATTR:   }
 // ATTR:   return TestBAttr::get(odsParser.getContext(),
-// ATTR:                         *_result_v0,
-// ATTR:                         *_result_v1);
+// ATTR:                         (*_result_v0),
+// ATTR:                         (*_result_v1));
 // ATTR: }
 
 // ATTR: void TestBAttr::print(::mlir::AsmPrinter &odsPrinter) const {
 // ATTR:   odsPrinter << "v0 = ";
 // ATTR:   ::printAttrParamA(odsPrinter, getV0());
 // ATTR:   odsPrinter << ", ";
 // ATTR:   odsPrinter << "v1 = ";
 // ATTR:   ::printAttrB(odsPrinter, getV1());

 // ATTR:   if (::mlir::failed(_result_v0))
 // ATTR:     return {};
 // ATTR:   if (odsParser.parseComma())
 // ATTR:     return {};
 // ATTR:   _result_v1 = ::mlir::FieldParser<int>::parse(odsParser);
 // ATTR:   if (::mlir::failed(_result_v1))
 // ATTR:     return {};
 // ATTR:   return TestFAttr::get(odsParser.getContext(),
-// ATTR:     *_result_v0,
-// ATTR:     *_result_v1);
+// ATTR:     (*_result_v0),
+// ATTR:     (*_result_v1));
 // ATTR: }
 
 def AttrC : TestAttr<"TestF"> {
   let parameters = (ins "int":$v0, "int":$v1);
 
   let mnemonic = "attr_c";
   let assemblyFormat = "params";
 }

 // TYPE:     if (!_loop_body(_paramKey)) return {};
 // TYPE:     if ((odsStructIndex != 2 - 1) && odsParser.parseComma())
 // TYPE:       return {};
 // TYPE:   }
 // TYPE:   _result_v3 = someFcnCall();
 // TYPE:   if (::mlir::failed(_result_v3))
 // TYPE:     return {};
 // TYPE:   return TestDType::get(odsParser.getContext(),
-// TYPE:                         *_result_v0,
-// TYPE:                         *_result_v1,
-// TYPE:                         *_result_v2,
-// TYPE:                         *_result_v3);
+// TYPE:                         (*_result_v0),
+// TYPE:                         (*_result_v1),
+// TYPE:                         (*_result_v2),
+// TYPE:                         (*_result_v3));
 // TYPE: }
 
 // TYPE: void TestDType::print(::mlir::AsmPrinter &odsPrinter) const {
 // TYPE:   odsPrinter << getV0();
 // TYPE:   myPrinter(getV1());
 // TYPE:   odsPrinter << "v2 = ";
 // TYPE:   odsPrinter << getV2();
 // TYPE:   myPrinter(getV3());

 // TYPE:     StringRef _paramKey;
 // TYPE:     if (odsParser.parseKeyword(&_paramKey))
 // TYPE:       return {};
 // TYPE:     if (!_loop_body(_paramKey)) return {};
 // TYPE:     if ((odsStructIndex != 2 - 1) && odsParser.parseComma())
 // TYPE:       return {};
 // TYPE:   }
 // TYPE:   return TestEType::get(odsParser.getContext(),
-// TYPE:     *_result_v0,
-// TYPE:     *_result_v1,
-// TYPE:     *_result_v2,
-// TYPE:     *_result_v3);
+// TYPE:     (*_result_v0),
+// TYPE:     (*_result_v1),
+// TYPE:     (*_result_v2),
+// TYPE:     (*_result_v3));
 // TYPE: }
 
 // TYPE: void TestEType::print(::mlir::AsmPrinter &odsPrinter) const {
 // TYPE:   odsPrinter << "v0 = ";
 // TYPE:   odsPrinter.printStrippedAttrOrType(getV0());
 // TYPE:   odsPrinter << ", ";
 // TYPE:   odsPrinter << "v2 = ";
 // TYPE:   odsPrinter.printStrippedAttrOrType(getV2());

 // TYPE-NEXT: getB()
 // TYPE-NEXT: getA()
 
 def TypeJ : TestType<"TestL"> {
   let parameters = (ins "int":$a, OptionalParameter<"Attribute">:$b);
   let mnemonic = "type_j";
   let assemblyFormat = "custom<A>($a) custom<B>($b, ref($a))";
 }
+
+// TYPE: ::mlir::Type TestMType::parse
+// TYPE: FailureOr<float> _result_a
+// TYPE: return TestMType::get
+// TYPE: static_cast<int>((*_result_a))
+
+def ConvertFromStorageParameter : TypeParameter<"int", ""> {
+  let cppStorageType = "float";
+  let convertFromStorage = "static_cast<int>($_self)";
+}
+
+def TypeK : TestType<"TestM"> {
+  let parameters = (ins ConvertFromStorageParameter:$a);
+  let mnemonic = "type_k";
+  let assemblyFormat = "$a";
+}

mlir/tools/mlir-tblgen/AttrOrTypeFormatGen.cpp

if (def.genVerifyDecl()) {
     os << tgfmt("return $_parser.getChecked<$0>($_loc, $_parser.getContext()",
                 &ctx, def.getCppClassName());
   } else {
     os << tgfmt("return $0::get($_parser.getContext()", &ctx,
                 def.getCppClassName());
   }
   for (const AttrOrTypeParameter &param : params) {
     os << ",\n    ";
+    std::string paramSelfStr;
+    llvm::raw_string_ostream selfOs(paramSelfStr);
     if (param.isOptional()) {
-      os << formatv("_result_{0}.value_or(", param.getName());
+      selfOs << formatv("(_result_{0}.value_or(", param.getName());
       if (Optional<StringRef> defaultValue = param.getDefaultValue())
-        os << tgfmt(*defaultValue, &ctx);
+        selfOs << tgfmt(*defaultValue, &ctx);
       else
-        os << param.getCppStorageType() << "()";
-      os << ")";
+        selfOs << param.getCppStorageType() << "()";
+      selfOs << "))";
     } else if (isa<AttributeSelfTypeParameter>(param)) {
-      os << tgfmt("$_type", &ctx);
+      selfOs << tgfmt("$_type", &ctx);
     } else {
-      os << formatv("*_result_{0}", param.getName());
+      selfOs << formatv("(*_result_{0})", param.getName());
     }
+    os << tgfmt(param.getConvertFromStorage(), &ctx.withSelf(selfOs.str()));
   }
   os << ");";
 }
 
 void DefFormat::genElementParser(FormatElement *el, FmtContext &ctx,
                                  MethodBody &os) {
   if (auto *literal = dyn_cast<LiteralElement>(el))
     return genLiteralParser(literal->getSpelling(), ctx, os);