[mlir][ods] AttrOrTypeDef format: parse types

[Mogball]

Summary

Add template specialization to FieldParser for parsing types.

[mehdi_amini]

Nice, thanks!

[kiranchandramohan]

@Mogball Thanks for the quick fix. I can now use the assembly format in D113755.

mlir/include/mlir/IR/DialectImplementation.h

struct FieldParser<
   static FailureOr<AttributeT> parse(AsmParser &parser) {
     AttributeT value;
     if (parser.parseAttribute(value))
       return failure();
     return value;
   }
 };
 
+/// Parse a type.
+template <typename TypeT>
+struct FieldParser<
+    TypeT, std::enable_if_t<std::is_base_of<Type, TypeT>::value, TypeT>> {
+  static FailureOr<TypeT> parse(AsmParser &parser) {
+    TypeT value;
+    if (parser.parseType(value))
+      return failure();
+    return value;
+  }
+};
+
 /// Parse any integer.
 template <typename IntT>
 struct FieldParser<IntT,
                    std::enable_if_t<std::is_integral<IntT>::value, IntT>> {
   static FailureOr<IntT> parse(AsmParser &parser) {
     IntT value;
     if (parser.parseInteger(value))
       return failure();

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

 
 def TestAttrParams: Test_Attr<"TestAttrParams"> {
   let parameters = (ins "int":$v0, "int":$v1);
 
   let mnemonic = "attr_params";
   let assemblyFormat = "`<` params `>`";
 }
 
+// Test types can be parsed/printed.
+def TestAttrWithTypeParam : Test_Attr<"TestAttrWithTypeParam"> {
+  let parameters = (ins "::mlir::IntegerType":$int_type,
+                        "::mlir::Type":$any_type);
+  let mnemonic = "attr_with_type";
+  let assemblyFormat = "`<` $int_type `,` $any_type `>`";
+}
+
 #endif // TEST_ATTRDEFS

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 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>
   attr0 = #test.attr_with_format<3 : two = "hello", four = [1, 2, 3] : 42 : i64>,
   // CHECK: #test.attr_with_format<5 : two = "a_string", four = [4, 5, 6, 7, 8] : 8 : i8>
   attr1 = #test.attr_with_format<5 : two = "a_string", four = [4, 5, 6, 7, 8] : 8 : i8>,
   // 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>
+  attr3 = #test.attr_params<42, 24>,
+  // CHECK: #test.attr_with_type<i32, vector<4xi32>>
+  attr4 = #test.attr_with_type<i32, vector<4xi32>>
 }
 
 // CHECK-LABEL: @test_roundtrip_default_parsers_struct
 // CHECK: !test.no_parser<255, [1, 2, 3, 4, 5], "foobar", 4>
 // CHECK: !test.struct_capture_all<v0 = 0, v1 = 1, v2 = 2, v3 = 3>
 func private @test_roundtrip_default_parsers_struct(!test.no_parser<255, [1, 2, 3, 4, 5], "foobar", 4>) -> !test.struct_capture_all<v3 = 3, v1 = 1, v2 = 2, v0 = 0>

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

 func private @test_type_syntax_error() -> !test.type_with_format<42, two = "hi", three = #test.attr_with_format<42>>
 
 // -----
 
 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>
 }
+
+// -----
+
+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>>
+}