[mlir] Enhance classof() checks in StructsGen

[antiagainst]

Summary

Previously we only check that each field is of the correct
mlir::Attribute subclass. This commit enhances to also consider
the attribute's types, by leveraging the constraints already
encoded in TableGen attribute definitions.

[merge_guards_bot]

Unit tests: fail. 61177 tests passed, 3 failed and 729 were skipped.

failed: libc++.std/thread/thread_mutex/thread_mutex_requirements/thread_mutex_requirements_mutex/thread_mutex_class/try_lock.pass.cpp
failed: libc++.std/thread/thread_mutex/thread_mutex_requirements/thread_mutex_requirements_mutex/thread_mutex_recursive/lock.pass.cpp
failed: libc++.std/thread/thread_mutex/thread_mutex_requirements/thread_mutex_requirements_mutex/thread_mutex_recursive/try_lock.pass.cpp

clang-tidy: fail. Please fix clang-tidy findings.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[rsuderman]

Looks good to me.

mlir/tools/mlir-tblgen/StructsGen.cpp

 //===- StructsGen.cpp - MLIR struct utility generator ---------------------===//
 //
 // Part of the MLIR 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
 //
 //===----------------------------------------------------------------------===//
 //
 // StructsGen generates common utility functions for grouping attributes into a
 // set of structured data.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/TableGen/Attribute.h"
 #include "mlir/TableGen/Format.h"
 #include "mlir/TableGen/GenInfo.h"
 #include "mlir/TableGen/Operator.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 #include "llvm/TableGen/TableGenBackend.h"
 
 using llvm::raw_ostream;
 using llvm::Record;
 using llvm::RecordKeeper;
 using llvm::StringRef;
+using mlir::tblgen::FmtContext;
 using mlir::tblgen::StructAttr;
 
 static void
 emitStructClass(const Record &structDef, StringRef structName,
                 llvm::ArrayRef<mlir::tblgen::StructFieldAttr> fields,
                 StringRef description, raw_ostream &os) {
   const char *structInfo = R"(
 // {0}
if (!derived)
      return false;
    if (derived.size() != {0})
      return false;
 )";
 
   os << llvm::formatv(classofInfo, structName) << " {";
   os << llvm::formatv(classofInfoHeader, fields.size());
 
+  FmtContext fctx;
   const char *classofArgInfo = R"(
   auto {0} = derived.get("{0}");
-  if (!{0} || !{0}.isa<{1}>())
+  if (!{0} || !({1}))
     return false;
 )";
   for (auto field : fields) {
     auto name = field.getName();
     auto type = field.getType();
-    auto storage = type.getStorageType();
-    os << llvm::formatv(classofArgInfo, name, storage);
+    std::string condition =
+        tgfmt(type.getConditionTemplate(), &fctx.withSelf(name));
+    os << llvm::formatv(classofArgInfo, name, condition);
   }
 
   const char *classofEndInfo = R"(
   return true;
 }
 )";
   os << classofEndInfo;
 }

mlir/unittests/TableGen/StructsGenTest.cpp

 //===- StructsGenTest.cpp - TableGen StructsGen Tests ---------------------===//
 //
 // Part of the MLIR 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/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>
 
 namespace mlir {
 
 // Pull in generated enum utility declarations
 #include "StructAttrGenTest.h.inc"
 // And definitions
 #include "StructAttrGenTest.cpp.inc"
 // Helper that returns an example test::TestStruct for testing its
 // implementation.
 static test::TestStruct getTestStruct(mlir::MLIRContext *context) {
   auto integerType = mlir::IntegerType::get(32, context);
   auto integerAttr = mlir::IntegerAttr::get(integerType, 127);
 
-  auto floatType = mlir::FloatType::getF16(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::DenseElementsAttr::get(elementsType, {1, 2, 3, 4, 5, 6});
+      mlir::DenseIntElementsAttr::get(elementsType, {1, 2, 3, 4, 5, 6});
 
   return test::TestStruct::get(integerAttr, floatAttr, elementsAttr, context);
 }
 
 // Validates that test::TestStruct::classof correctly identifies a valid
 // test::TestStruct.
 TEST(StructsGenTest, ClassofTrue) {
   mlir::MLIRContext context;
TEST(StructsGenTest, ClassofBadNameFalse) {
   auto wrongId = mlir::Identifier::get("wrong", &context);
   auto wrongAttr = mlir::NamedAttribute(wrongId, expectedValues[0].second);
   newValues.push_back(wrongAttr);
 
   auto badDictionary = mlir::DictionaryAttr::get(newValues, &context);
   ASSERT_FALSE(test::TestStruct::classof(badDictionary));
 }
 
+// Validates that test::TestStruct::classof fails when a NamedAttribute has an
+// incorrect type.
+TEST(StructsGenTest, ClassofBadTypeFalse) {
+  mlir::MLIRContext context;
+  mlir::DictionaryAttr structAttr = getTestStruct(&context);
+  auto expectedValues = structAttr.getValue();
+  ASSERT_EQ(expectedValues.size(), 3u);
+
+  // Create a copy of all but the last NamedAttributes.
+  llvm::SmallVector<mlir::NamedAttribute, 4> newValues(
+      expectedValues.begin(), expectedValues.end() - 1);
+
+  // Add a copy of the last attribute with the wrong type.
+  auto i64Type = mlir::IntegerType::get(64, &context);
+  auto elementsType = mlir::RankedTensorType::get({3}, i64Type);
+  auto elementsAttr =
+      mlir::DenseIntElementsAttr::get(elementsType, ArrayRef<int64_t>{1, 2, 3});
+  mlir::Identifier id = expectedValues.back().first;
+  auto wrongAttr = mlir::NamedAttribute(id, elementsAttr);
+  newValues.push_back(wrongAttr);
+
+  auto badDictionary = mlir::DictionaryAttr::get(newValues, &context);
+  ASSERT_FALSE(test::TestStruct::classof(badDictionary));
+}
+
 // Validates that test::TestStruct::classof fails when a NamedAttribute is
 // missing.
 TEST(StructsGenTest, ClassofMissingFalse) {
   mlir::MLIRContext context;
   mlir::DictionaryAttr structAttr = getTestStruct(&context);
   auto expectedValues = structAttr.getValue();
   ASSERT_EQ(expectedValues.size(), 3u);
 

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", ElementsAttr>] > {
+                StructFieldAttr<"sample_elements", I32ElementsAttr>] > {
   let description = "Structure for test data";
 }