[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/docs/AttributesAndTypes.md

 Below show cases an example Attribute and Type definition. We generally recommend
 defining Attribute and Type classes in different `.td` files to better encapsulate
 the different constructs, and define a proper layering between them. This
 recommendation extends to all of the MLIR constructs, including [Interfaces](Interfaces.md),
 Operations, etc.
 
 ```tablegen
 // Include the definition of the necessary tablegen constructs for defining
-// our types. 
+// our types.
 include "mlir/IR/AttrTypeBase.td"
 
 // It's common to define a base classes for types in the same dialect. This
 // removes the need to pass in the dialect for each type, and can also be used
 // to define a few fields ahead of time.
 class MyDialect_Type<string name, string typeMnemonic, list<Trait> traits = []>
     : TypeDef<My_Dialect, name, traits> {
   let mnemonic = typeMnemonic;
def My_IntegerType : MyDialect_Type<"Integer", "int"> {
   let genVerifyDecl = 1;
 }
 ```
 
 Below is an example of an Attribute:
 
 ```tablegen
 // Include the definition of the necessary tablegen constructs for defining
-// our attributes. 
+// our attributes.
 include "mlir/IR/AttrTypeBase.td"
 
 // It's common to define a base classes for attributes in the same dialect. This
 // removes the need to pass in the dialect for each attribute, and can also be used
 // to define a few fields ahead of time.
 class MyDialect_Attr<string name, string attrMnemonic, list<Trait> traits = []>
     : AttrDef<My_Dialect, name, traits> {
   let mnemonic = attrMnemonic;
 }
 
 // Here is a simple definition of an "integer" attribute, with a type and value parameter.
 def My_IntegerAttr : MyDialect_Attr<"Integer", "int"> {
   let summary = "An Attribute containing a integer value";
   let description = [{
     An integer attribute is a literal attribute that represents an integral
     value of the specified integer type.
   }];
   /// Here we've defined two parameters, one is the `self` type of the attribute
   /// (i.e. the type of the Attribute itself), and the other is the integer value
-  /// of the attribute. 
+  /// of the attribute.
   let parameters = (ins AttributeSelfTypeParameter<"">:$type, "APInt":$value);
-  
   /// Here we've defined a custom builder for the type, that removes the need to pass
-  /// in an MLIRContext instance; as it can be infered from the `type`. 
+  /// in an MLIRContext instance; as it can be infered from the `type`.
   let builders = [
     AttrBuilderWithInferredContext<(ins "Type":$type,
                                         "const APInt &":$value), [{
       return $_get(type.getContext(), type, value);
     }]>
   ];
 
   /// Here we define the textual format of the attribute declaratively, which will
   /// automatically generate parser and printer logic. This will allow for
   /// instances of the attribute to be output as, for example:
   ///
   ///    #my.int<50> : !my.int<32> // a 32-bit integer of value 50.
   ///
   let assemblyFormat = "`<` $value `>`";
-  
   /// Indicate that our attribute will add additional verification to the parameters.
   let genVerifyDecl = 1;
 
   /// Indicate to the ODS generator that we do not want the default builders,
   /// as we have defined our own simpler ones.
   let skipDefaultBuilders = 1;
 }
 ```

 ###### Non-POD Parameters
 
 Parameters that aren't plain-old-data (e.g. references) may need to define a
 `cppStorageType` to contain the data until it is copied into the allocator. For
 example, `StringRefParameter` uses `std::string` as its storage type, whereas
 `ArrayRefParameter` uses `SmallVector` as its storage type. The parsers for
 these parameters are expected to return `FailureOr<$cppStorageType>`.
 
+To add a custom conversion between the `cppStorageType` and the C++ type of the
+parameter, parameters can override `convertFromStorage`, which by default is
+`"$_self"` (i.e., it attempts an implicit conversion from `cppStorageType`).
+
 ###### Optional Parameters
 
 Optional parameters in the assembly format can be indicated by setting
 `isOptional`. The C++ type of an optional parameter is required to satisfy the
 following requirements:
 
 - is default-constructible
 - is contextually convertible to `bool`

 
 ```c++
 void MyDialect::initialize() {
     /// Add the defined attributes to the dialect.
   addAttributes<
 #define GET_ATTRDEF_LIST
 #include "MyDialect/Attributes.cpp.inc"
   >();
-  
     /// Add the defined types to the dialect.
   addTypes<
 #define GET_TYPEDEF_LIST
 #include "MyDialect/Types.cpp.inc"
   >();
 }
 ```

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);