Make struct dialects have the same field name as everything else, 'dialect'.

[fedelebron]

Summary

Also make the behavior of getting a dialect more forgiving, in the case where
there isn't a dialect associated with an attribute.

Depends On D86807

[rriddle]

mlir/lib/TableGen/Attribute.cpp

129

MLIR variable names should be camelCase, here and below.

131

nit: Drop the trivial braces here.

[mehdi_amini]

LGTM (with River's nit addressed), thanks!

[fedelebron]

Lint fixes.

[fedelebron]

Changes done :)

mlir/lib/TableGen/Attribute.cpp

129

Ah interesting, this differs from LLVM's style, from whence this code came.

[fedelebron]

Fixing some targets.

mlir/include/mlir/IR/OpBase.td

class StructFieldAttr<string thisName, Attr thisType> {
 
   // Attribute type wrapped by the struct attr.
   Attr type = thisType;
 }
 
 // Structured attribute that wraps a DictionaryAttr and provides both a
 // validation method and set of accessors for a fixed set of fields. This is
 // useful when representing data that would normally be in a structure.
-class StructAttr<string name, Dialect dialect,
+class StructAttr<string name, Dialect d,
                  list<StructFieldAttr> attributes> :
     DictionaryAttrBase<CPred<"$_self.isa<" # name # ">()">,
         "DictionaryAttr with field(s): " #
         StrJoin<!foreach(a, attributes, "'" # a.name # "'"), ", ">.result #
         " (each field having its own constraints)"> {
   // Name for this StructAttr.
   string className = name;
 
   // Return type should match the name of the structure.
   let returnType = name;
 
   // Storage type should match the name of the structure.
   let storageType = name;
 
   // The dialect this StructAttr belongs to.
-  Dialect structDialect = dialect;
+  Dialect dialect = d;
 
   // List of fields that the StructAttr contains.
   list<StructFieldAttr> fields = attributes;
 }
 
 // Attributes containing symbol references.
 def SymbolRefAttr : Attr<CPred<"$_self.isa<::mlir::SymbolRefAttr>()">,
                         "symbol reference attribute"> {

mlir/lib/TableGen/Attribute.cpp

 }
 
 StringRef Attribute::getDerivedCodeBody() const {
   assert(isDerivedAttr() && "only derived attribute has 'body' field");
   return def->getValueAsString("body");
 }
 
 Dialect Attribute::getDialect() const {
-  return Dialect(def->getValueAsDef("dialect"));
+  const llvm::RecordVal *R = def->getValue("dialect");
+  if (R && R->getValue()) {
+    if (DefInit *DI = dyn_cast<DefInit>(R->getValue())) {
+      return Dialect(DI->getDef());
+    }
+  }
+  return Dialect(nullptr);
 }
 
 ConstantAttr::ConstantAttr(const DefInit *init) : def(init->getDef()) {
   assert(def->isSubClassOf("ConstantAttr") &&
          "must be subclass of TableGen 'ConstantAttr' class");
 }
 
 Attribute ConstantAttr::getAttribute() const {

 StructAttr::StructAttr(const llvm::DefInit *init)
     : StructAttr(init->getDef()) {}
 
 StringRef StructAttr::getStructClassName() const {
   return def->getValueAsString("className");
 }
 
 StringRef StructAttr::getCppNamespace() const {
-  Dialect dialect(def->getValueAsDef("structDialect"));
+  Dialect dialect(def->getValueAsDef("dialect"));
   return dialect.getCppNamespace();
 }
 
 std::vector<StructFieldAttr> StructAttr::getAllFields() const {
   std::vector<StructFieldAttr> attributes;
 
   const auto *inits = def->getValueAsListInit("fields");
   attributes.reserve(inits->size());