[mlir] Support default valued attribute in StructsGen

[antiagainst]

Summary

Its handling is similar to optional attributes, except for the
getter method.

[rsuderman]

Looks good to me. One nit: it may be worth reordering the includes into the test to remove that pesky pre-merge check error.

[antiagainst]

In D87055#2253886, @rsuderman wrote:

Looks good to me. One nit: it may be worth reordering the includes into the test to remove that pesky pre-merge check error.

The warning is a bit strange to me. The include files are already sorted.. So I'll just ignore it.

mlir/tools/mlir-tblgen/StructsGen.cpp

)";
   const char *getFieldInfoOptional = R"(
   if ({0}) {
     auto {0}_id = ::mlir::Identifier::get("{0}", context);
     fields.emplace_back({0}_id, {0});
   }
 )";
 
   for (auto field : fields) {
-    if (field.getType().isOptional())
+    if (field.getType().isOptional() || field.getType().hasDefaultValue())
       os << llvm::formatv(getFieldInfoOptional, field.getName());
     else
       os << llvm::formatv(getFieldInfo, field.getName());
   }
 
   const char *getEndInfo = R"(
   ::mlir::Attribute dict = ::mlir::DictionaryAttr::get(fields, context);
   return dict.dyn_cast<{0}>();

 bool {0}::classof(::mlir::Attribute attr))";
 
   const char *classofInfoHeader = R"(
   if (!attr)
     return false;
   auto derived = attr.dyn_cast<::mlir::DictionaryAttr>();
   if (!derived)
     return false;
-  int empty_optionals = 0;
+  int num_absent_attrs = 0;
 )";
 
   os << llvm::formatv(classofInfo, structName) << " {";
   os << llvm::formatv(classofInfoHeader);
 
   FmtContext fctx;
   const char *classofArgInfo = R"(
   auto {0} = derived.get("{0}");
   if (!{0} || !({1}))
     return false;
 )";
   const char *classofArgInfoOptional = R"(
   auto {0} = derived.get("{0}");
   if (!{0})
-    ++empty_optionals;
+    ++num_absent_attrs;
   else if (!({1}))
     return false;
 )";
   for (auto field : fields) {
     auto name = field.getName();
     auto type = field.getType();
     std::string condition =
         std::string(tgfmt(type.getConditionTemplate(), &fctx.withSelf(name)));
-    if (type.isOptional())
+    if (type.isOptional() || type.hasDefaultValue())
       os << llvm::formatv(classofArgInfoOptional, name, condition);
     else
       os << llvm::formatv(classofArgInfo, name, condition);
   }
 
   const char *classofEndInfo = R"(
-  return derived.size() + empty_optionals == {0};
+  return derived.size() + num_absent_attrs == {0};
 }
 )";
   os << llvm::formatv(classofEndInfo, fields.size());
 }
 
 static void
 emitAccessorDef(llvm::StringRef structName,
                 llvm::ArrayRef<mlir::tblgen::StructFieldAttr> fields,
)";
   auto derived = this->cast<::mlir::DictionaryAttr>();
   auto {1} = derived.get("{1}");
   if (!{1})
     return nullptr;
   assert({1}.isa<{0}>() && "incorrect Attribute type found.");
   return {1}.cast<{0}>();
 }
 )";
+  const char *fieldInfoDefaultValued = R"(
+{0} {2}::{1}() const {
+  auto derived = this->cast<::mlir::DictionaryAttr>();
+  auto {1} = derived.get("{1}");
+  if (!{1}) {
+    ::mlir::Builder builder(getContext());
+    return {3};
+  }
+  assert({1}.isa<{0}>() && "incorrect Attribute type found.");
+  return {1}.cast<{0}>();
+}
+)";
+  FmtContext fmtCtx;
+  fmtCtx.withBuilder("builder");
+
   for (auto field : fields) {
     auto name = field.getName();
     auto type = field.getType();
     auto storage = type.getStorageType();
-    if (type.isOptional())
+    if (type.isOptional()) {
       os << llvm::formatv(fieldInfoOptional, storage, name, structName);
-    else
+    } else if (type.hasDefaultValue()) {
+      std::string defaultValue = tgfmt(type.getConstBuilderTemplate(), &fmtCtx,
+                                       type.getDefaultValue());
+      os << llvm::formatv(fieldInfoDefaultValued, storage, name, structName,
+                          defaultValue);
+    } else {
       os << llvm::formatv(fieldInfo, storage, name, structName);
     }
   }
+}
 
 static void emitStructDef(const Record &structDef, raw_ostream &os) {
   StructAttr structAttr(&structDef);
   StringRef cppNamespace = structAttr.getCppNamespace();
   StringRef structName = structAttr.getStructClassName();
   mlir::tblgen::FmtContext ctx;
   auto fields = structAttr.getAllFields();
 

mlir/unittests/TableGen/StructsGenTest.cpp

 //===- StructsGenTest.cpp - TableGen StructsGen Tests ---------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/IR/Attributes.h"
+#include "mlir/IR/Builders.h"
 #include "mlir/IR/Identifier.h"
 #include "mlir/IR/StandardTypes.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "gmock/gmock.h"
 #include <type_traits>
 
static test::TestStruct getTestStruct(mlir::MLIRContext *context) {
 
   auto floatType = mlir::FloatType::getF32(context);
   auto floatAttr = mlir::FloatAttr::get(floatType, 0.25);
 
   auto elementsType = mlir::RankedTensorType::get({2, 3}, integerType);
   auto elementsAttr =
       mlir::DenseIntElementsAttr::get(elementsType, {1, 2, 3, 4, 5, 6});
   auto optionalAttr = nullptr;
+  auto defaultValuedAttr = nullptr;
 
   return test::TestStruct::get(integerAttr, floatAttr, elementsAttr,
-                               optionalAttr, context);
+                               optionalAttr, defaultValuedAttr, context);
 }
 
 /// Validates that test::TestStruct::classof correctly identifies a valid
 /// test::TestStruct.
 TEST(StructsGenTest, ClassofTrue) {
   mlir::MLIRContext context(false);
   auto structAttr = getTestStruct(&context);
   ASSERT_TRUE(test::TestStruct::classof(structAttr));

 }
 
 TEST(StructsGenTest, EmptyOptional) {
   mlir::MLIRContext context;
   auto structAttr = getTestStruct(&context);
   EXPECT_EQ(structAttr.sample_optional_integer(), nullptr);
 }
 
+TEST(StructsGenTest, GetDefaultValuedAttr) {
+  mlir::MLIRContext context;
+  mlir::Builder builder(&context);
+  auto structAttr = getTestStruct(&context);
+  EXPECT_EQ(structAttr.sample_default_valued_integer(),
+            builder.getI32IntegerAttr(42));
+}
+
 } // namespace mlir

mlir/unittests/TableGen/structs.td

def Test_Dialect : Dialect {
   let name = "test";
 }
 
 def Test_Struct : StructAttr<"TestStruct", Test_Dialect, [
                 StructFieldAttr<"sample_integer", I32Attr>,
                 StructFieldAttr<"sample_float", F32Attr>,
                 StructFieldAttr<"sample_elements", I32ElementsAttr>,
                 StructFieldAttr<"sample_optional_integer",
-                                OptionalAttr<I32Attr>>] > {
+                                OptionalAttr<I32Attr>>,
+                StructFieldAttr<"sample_default_valued_integer",
+                                DefaultValuedAttr<I32Attr, "42">>] > {
   let description = "Structure for test data";
 }