[mlir] Improve FieldParser list container detection

[rkayaith]

Summary

The current detection logic will fail for containers with an overloaded
push_back member. This causes issues with types like std::vector and
SmallVector<SomeNonTriviallyCopyableT>, which have both
push_back(const T&) and push_back(T&&).

[rkayaith]

add test

[rkayaith]

rebase

mlir/include/mlir/IR/DialectImplementation.h

if (result.has_value()) {
       if (succeeded(*result))
         return {std::optional<IntT>(value)};
       return failure();
     }
     return {std::nullopt};
   }
 };
 
+namespace detail {
+template <typename T>
+using has_push_back_t = decltype(std::declval<T>().push_back(
+    std::declval<typename T::value_type &&>()));
+} // namespace detail
+
 /// Parse any container that supports back insertion as a list.
 template <typename ContainerT>
-struct FieldParser<
-    ContainerT, std::enable_if_t<std::is_member_function_pointer<
-                                     decltype(&ContainerT::push_back)>::value,
+struct FieldParser<ContainerT,
+                   std::enable_if_t<llvm::is_detected<detail::has_push_back_t,
+                                                      ContainerT>::value,
                                     ContainerT>> {
   using ElementT = typename ContainerT::value_type;
   static FailureOr<ContainerT> parse(AsmParser &parser) {
     ContainerT elements;
     auto elementParser = [&]() {
       auto element = FieldParser<ElementT>::parse(parser);
       if (failed(element))
         return failure();
-      elements.push_back(*element);
+      elements.push_back(std::move(*element));
       return success();
     };
     if (parser.parseCommaSeparatedList(elementParser))
       return failure();
     return elements;
   }
 };
 

mlir/test/lib/Dialect/Test/TestAttrDefs.td

 }
 
 def TestParamFour : ArrayRefParameter<"int", ""> {
   let cppStorageType = "llvm::SmallVector<int>";
   let parser = "::parseIntArray($_parser)";
   let printer = "::printIntArray($_printer, $_self)";
 }
 
+
+def TestParamVector : ArrayRefParameter<"int", ""> {
+  let cppStorageType = "std::vector<int>";
+}
+
 def TestParamUnsigned : AttrParameter<"uint64_t", ""> {}
 
 def TestAttrWithFormat : Test_Attr<"TestAttrWithFormat"> {
   let parameters = (
     ins
     TestParamOne:$one,
     TestParamTwo:$two,
     "::mlir::IntegerAttr":$three,
     TestParamFour:$four,
     TestParamUnsigned:$five,
+    TestParamVector:$six,
     // Array of another attribute.
     ArrayRefParameter<
       "AttrWithTypeBuilderAttr", // The parameter C++ type.
       "An example of an array of another Attribute" // Parameter description.
       >: $arrayOfAttrWithTypeBuilderAttr
   );
 
   let mnemonic = "attr_with_format";
   let assemblyFormat = [{
-    `<` $one `:` struct($two, $four) `:` $three `:` $five `,`
+    `<` $one `:` struct($two, $four) `:` $three `:` $five `:` `[` $six `]` `,`
     `[` `` $arrayOfAttrWithTypeBuilderAttr `]` `>`
   }];
   let genVerifyDecl = 1;
 }
 
 def TestAttrWithOptionalSigned : Test_Attr<"TestAttrWithOptionalSigned"> {
   let parameters = (ins OptionalParameter<"std::optional<int64_t>">:$value);
   let assemblyFormat = "`<` $value `>`";

mlir/test/lib/Dialect/Test/TestAttributes.cpp

return emitError()
            << elements.size() << ", but expected: " << type.getNumElements();
   }
   if (type.getRank() != 1 || !type.getElementType().isSignlessInteger(64))
     return emitError() << "expected single rank 64-bit shape type, but got: "
                        << type;
   return success();
 }
 
-LogicalResult
-TestAttrWithFormatAttr::verify(function_ref<InFlightDiagnostic()> emitError,
-                               int64_t one, std::string two, IntegerAttr three,
-                               ArrayRef<int> four, uint64_t five,
-                               ArrayRef<AttrWithTypeBuilderAttr> arrayOfAttrs) {
+LogicalResult TestAttrWithFormatAttr::verify(
+    function_ref<InFlightDiagnostic()> emitError, int64_t one, std::string two,
+    IntegerAttr three, ArrayRef<int> four, uint64_t five, ArrayRef<int> six,
   if (four.size() != static_cast<unsigned>(one))
     return emitError() << "expected 'one' to equal 'four.size()'";
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Utility Functions for Generated Attributes
 //===----------------------------------------------------------------------===//

mlir/test/mlir-tblgen/attr-or-type-format-roundtrip.mlir

 // RUN: mlir-opt %s | mlir-opt | FileCheck %s
 
 // CHECK-LABEL: @test_roundtrip_parameter_parsers
 // CHECK: !test.type_with_format<111, three = #test<attr_ugly begin 5 : index end>, two = "foo">
 // CHECK: !test.type_with_format<2147, three = "hi", two = "hi">
 func.func private @test_roundtrip_parameter_parsers(!test.type_with_format<111, three = #test<attr_ugly begin 5 : index end>, two = "foo">) -> !test.type_with_format<2147, two = "hi", three = "hi">
 attributes {
-  // CHECK: #test.attr_with_format<3 : two = "hello", four = [1, 2, 3] : 42 : i64 : 0, [ 10 : i16]
-  attr0 = #test.attr_with_format<3 : two = "hello", four = [1, 2, 3] : 42 : i64 : 0, [10 : i16]>,
-  // CHECK: #test.attr_with_format<5 : two = "a_string", four = [4, 5, 6, 7, 8] : 8 : i8 : 255, [ 10 : i16]>,
-  attr1 = #test.attr_with_format<5 : two = "a_string", four = [4, 5, 6, 7, 8] : 8 : i8 : 255, [10 : i16]>,
+  // CHECK: #test.attr_with_format<3 : two = "hello", four = [1, 2, 3] : 42 : i64 : 0 : [4, 5, 6], [ 10 : i16]
+  attr0 = #test.attr_with_format<3 : two = "hello", four = [1, 2, 3] : 42 : i64 : 0 : [4, 5, 6], [10 : i16]>,
+  // CHECK: #test.attr_with_format<5 : two = "a_string", four = [4, 5, 6, 7, 8] : 8 : i8 : 255 : [9, 10, 11], [ 10 : i16]>,
+  attr1 = #test.attr_with_format<5 : two = "a_string", four = [4, 5, 6, 7, 8] : 8 : i8 : 255 : [9, 10, 11], [10 : i16]>,
   // CHECK: #test<attr_ugly begin 5 : index end>
   attr2 = #test<attr_ugly begin 5 : index end>,
   // CHECK: #test.attr_params<42, 24>
   attr3 = #test.attr_params<42, 24>,
   // CHECK: #test.attr_with_type<i32, vector<4xi32>>
   attr4 = #test.attr_with_type<i32, vector<4xi32>>,
   // CHECK: #test.attr_self_type_format<5> : i32
   attr5 = #test.attr_self_type_format<5> : i32,

mlir/test/mlir-tblgen/attr-or-type-format.mlir

 // expected-error@+2 {{expected ':'}}
 // expected-error@+1 {{failed to parse TestTypeWithFormat parameter 'three'}}
 func.func private @test_type_syntax_error() -> !test.type_with_format<42, two = "hi", three = #test.attr_with_format<42>>
 
 // -----
 
 func.func private @test_verifier_fails() -> () attributes {
   // expected-error@+1 {{expected 'one' to equal 'four.size()'}}
-  attr = #test.attr_with_format<42 : two = "hello", four = [1, 2, 3] : 42 : i64 : 0, [10 : i16]>
+  attr = #test.attr_with_format<42 : two = "hello", four = [1, 2, 3] : 42 : i64 : 0 : [4, 5, 6], [10 : i16]>
 }
 
 // -----
 
 func.func private @test_attr_with_type_failed_to_parse_type() -> () attributes {
   // expected-error@+2 {{invalid kind of type specified}}
   // expected-error@+1 {{failed to parse TestAttrWithTypeParam parameter 'int_type'}}
   attr = #test.attr_with_type<vector<4xi32>, vector<4xi32>>
 }