[mlir] Fix a crash of attribute tests when given a non-integer type

[sotoshigoto]

Summary

The crash issue occurs in the TestBuiltinAttributeInterface when a
dense attribute with non-integer elements is provided. The tryGetValues
function should first check conditions, including casting T from the
element's type and verifying whether the elements are empty or not. This
fix resolves the crash issue reported in:

• https://github.com/llvm/llvm-project/issues/60581
• https://github.com/llvm/llvm-project/issues/61871

[rkayaith]

mlir/test/IR/elements-attr-interface.mlir

29–34

I'm not too familiar with this interface, but this change doesn't seem right to me. Successfully returning an empty range seems like the desired behaviour.

[sotoshigoto]

mlir/test/IR/elements-attr-interface.mlir

29–34

Thanks for your review! I'll address the empty range behavior by checking for attribute casting on empty elements.

[sotoshigoto]

addressed review comment

[sotoshigoto]

retry to upload patch

mlir/include/mlir/IR/BuiltinAttributeInterfaces.td

let extraClassDeclaration = [{
 
     //===------------------------------------------------------------------===//
     // Failable Value Iteration
 
     /// If this attribute supports iterating over element values of type `T`,
     /// return the iterable range. Otherwise, return std::nullopt.
     template <typename T>
     DefaultValueCheckT<T, std::optional<iterator_range<T>>> tryGetValues() const {
-      if (empty())
-        return std::nullopt;
       if (std::optional<iterator<T>> beginIt = try_value_begin<T>())
         return iterator_range<T>(getShapedType(), *beginIt, value_end<T>());
       return std::nullopt;
     }
     template <typename T>
     DefaultValueCheckT<T, std::optional<iterator<T>>> try_value_begin() const;
 
     /// If this attribute supports iterating over element values of type `T`,
     /// return the iterable range. Otherwise, return std::nullopt.
     template <typename T, typename = DerivedAttrValueCheckT<T>>
     std::optional<DerivedAttrValueIteratorRange<T>> tryGetValues() const {
       auto values = tryGetValues<Attribute>();
-      if (empty())
-        return std::nullopt;
       if (!values)
         return std::nullopt;
 
       // Check that an element can be casted as 'T', which is a derived attribute.
+      if (!empty())
         if (!(*(value_begin<Attribute>())).dyn_cast<T>())
           return std::nullopt;
 
       auto castFn = [](Attribute attr) { return ::llvm::cast<T>(attr); };
       return DerivedAttrValueIteratorRange<T>(
         getShapedType(),
         llvm::map_range(*values, static_cast<T (*)(Attribute)>(castFn))
       );
     }
     template <typename T, typename = DerivedAttrValueCheckT<T>>

mlir/test/IR/elements-attr-interface.mlir

 arith.constant dense<[1.0, 2.0, 3.0, 4.0, 5.0]> : tensor<5xf32>
 
 // expected-error@below {{Test iterating `int64_t`: 10, 11, 12, 13, 14}}
 // expected-error@below {{Test iterating `uint64_t`: 10, 11, 12, 13, 14}}
 // expected-error@below {{Test iterating `APInt`: 10, 11, 12, 13, 14}}
 // expected-error@below {{Test iterating `IntegerAttr`: 10 : i64, 11 : i64, 12 : i64, 13 : i64, 14 : i64}}
 arith.constant dense<[10, 11, 12, 13, 14]> : tensor<5xi64>
 
 // Check that we don't crash on empty element attributes.
-// expected-error@below {{Test iterating `int64_t`: unable to iterate type}}
-// expected-error@below {{Test iterating `uint64_t`: unable to iterate type}}
-// expected-error@below {{Test iterating `APInt`: unable to iterate type}}
-// expected-error@below {{Test iterating `IntegerAttr`: unable to iterate type}}
+// expected-error@below {{Test iterating `int64_t`: }}
+// expected-error@below {{Test iterating `uint64_t`: }}
+// expected-error@below {{Test iterating `APInt`: }}
+// expected-error@below {{Test iterating `IntegerAttr`: }}
 arith.constant dense<> : tensor<0xi64>
 
 // Check that we handle an external constant parsed from the config.
 // expected-error@below {{Test iterating `int64_t`: unable to iterate type}}
 // expected-error@below {{Test iterating `uint64_t`: 1, 2, 3}}
 // expected-error@below {{Test iterating `APInt`: unable to iterate type}}
 // expected-error@below {{Test iterating `IntegerAttr`: unable to iterate type}}
 arith.constant #test.e1di64_elements<blob1> : tensor<3xi64>
 
 {-#
   dialect_resources: {
     test: {
       blob1: "0x08000000010000000000000002000000000000000300000000000000"
     }
   }
 #-}