[mlir][AttrTypeGen] Add support for specifying a "accessor" type of a parameter

[rriddle]

Summary

This allows for using a different type when accessing a parameter than the
one used for storage. This allows for returning parameters by reference,
enables using more optimized/convient reference results, and more.

Depends On D108589

mlir/include/mlir/IR/OpBase.td

let builderCall = !if(!empty(parameters),
                            "");
   // The predicate for when this def is used as a constraint.
   let predicate = CPred<"$_self.isa<" # dialect.cppNamespace #
                                  "::" # cppClassName # ">()">;
 }
 
 // 'Parameters' should be subclasses of this or simple strings (which is a
 // shorthand for AttrOrTypeParameter<"C++Type">).
-class AttrOrTypeParameter<string type, string desc> {
+class AttrOrTypeParameter<string type, string desc, string accessorType = ""> {
   // Custom memory allocation code for storage constructor.
   code allocator = ?;
   // Custom comparator used to compare two instances for equality.
   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);
   // One-line human-readable description of the argument.
   string summary = desc;
   // The format string for the asm syntax (documentation only).
   string syntax = ?;
 }
-class AttrParameter<string type, string desc> : AttrOrTypeParameter<type, desc>;
-class TypeParameter<string type, string desc> : AttrOrTypeParameter<type, desc>;
+class AttrParameter<string type, string desc, string accessorType = "">
+ : AttrOrTypeParameter<type, desc, accessorType>;
+class TypeParameter<string type, string desc, string accessorType = "">
+ : AttrOrTypeParameter<type, desc, accessorType>;
 
 // For StringRefs, which require allocation.
 class StringRefParameter<string desc = ""> :
     AttrOrTypeParameter<"::llvm::StringRef", desc> {
   let allocator = [{$_dst = $_allocator.copyInto($_self);}];
 }
 
 // For APFloats, which require comparison.

mlir/include/mlir/TableGen/AttrOrTypeDef.h

public:
   Optional<StringRef> getAllocator() const;
 
   // If specified, get the custom comparator code for this parameter.
   Optional<StringRef> getComparator() const;
 
   // Get the C++ type of this parameter.
   StringRef getCppType() const;
 
+  // Get the C++ accessor type of this parameter.
+  StringRef getCppAccessorType() const;
+
   // Get a description of this parameter for documentation purposes.
   Optional<StringRef> getSummary() const;
 
   // Get the assembly syntax documentation.
   StringRef getSyntax() const;
 
   // Return the underlying def of this parameter.
   const llvm::Init *getDef() const;

mlir/lib/TableGen/AttrOrTypeDef.cpp

if (auto *stringType = dyn_cast<llvm::StringInit>(parameterType))
     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");
 }
 
+StringRef AttrOrTypeParameter::getCppAccessorType() const {
+  if (auto *param = dyn_cast<llvm::DefInit>(def->getArg(index))) {
+    if (Optional<StringRef> type =
+            param->getDef()->getValueAsOptionalString("cppAccessorType"))
+      return *type;
+  }
+  return getCppType();
+}
+
 Optional<StringRef> AttrOrTypeParameter::getSummary() const {
   auto *parameterType = def->getArg(index);
   if (auto *param = dyn_cast<llvm::DefInit>(parameterType)) {
     const auto *desc = param->getDef()->getValue("summary");
     if (llvm::StringInit *ci = dyn_cast<llvm::StringInit>(desc->getValue()))
       return ci->getValue();
   }
   return Optional<StringRef>();

mlir/test/mlir-tblgen/attrdefs.td

def E_AttrWithTypeBuilder : TestAttr<"AttrWithTypeBuilder"> {
   let mnemonic = "attr_with_type_builder";
   let parameters = (ins "::mlir::IntegerAttr":$attr);
   let typeBuilder = "$_attr.getType()";
 }
 
 // DEF-LABEL: struct AttrWithTypeBuilderAttrStorage
 // DEF: AttrWithTypeBuilderAttrStorage (::mlir::IntegerAttr attr)
 // DEF-NEXT: : ::mlir::AttributeStorage(attr.getType()), attr(attr)
+
+def F_ParamWithAccessorTypeAttr : TestAttr<"ParamWithAccessorType"> {
+  let parameters = (ins AttrParameter<"std::string", "", "StringRef">:$param);
+}
+
+// DECL-LABEL: class ParamWithAccessorTypeAttr
+// DECL: StringRef getParam()
+// DEF: ParamWithAccessorTypeAttrStorage
+// DEF-NEXT: ParamWithAccessorTypeAttrStorage (std::string param)
+// DEF: StringRef ParamWithAccessorTypeAttr::getParam()
+

mlir/tools/mlir-tblgen/AttrOrTypeDefGen.cpp

void DefGenerator::emitDefDecl(const AttrOrTypeDef &def) {
 
   if (def.genAccessors()) {
     SmallVector<AttrOrTypeParameter, 4> parameters;
     def.getParameters(parameters);
 
     for (AttrOrTypeParameter &parameter : parameters) {
       SmallString<16> name = parameter.getName();
       name[0] = llvm::toUpper(name[0]);
-      os << formatv("    {0} get{1}() const;\n", parameter.getCppType(), name);
+      os << formatv("    {0} get{1}() const;\n", parameter.getCppAccessorType(),
+                    name);
     }
   }
 
   // Emit any interface method declarations.
   for (const Trait &trait : def.getTraits()) {
     if (const auto *traitDef = dyn_cast<InterfaceTrait>(&trait)) {
       if (traitDef->shouldDeclareMethods())
         emitInterfaceMethodDecls(traitDef, os);
if (def.genAccessors() && def.genStorageClass()) {
               .toVector(paramStorageName);
         } else {
           paramStorageName = param.getName();
         }
 
         SmallString<16> name = param.getName();
         name[0] = llvm::toUpper(name[0]);
         os << formatv("{0} {3}::get{1}() const {{ return getImpl()->{2}; }\n",
-                      param.getCppType(), name, paramStorageName,
+                      param.getCppAccessorType(), name, paramStorageName,
                       def.getCppClassName());
       }
     }
   }
 
   // If mnemonic is specified maybe print definitions for the parser and printer
   // code, if they're specified.
   if (def.getMnemonic())