[mlir] Don't include the attribute self type in a `params` directive

[rriddle]

Summary

The self type is handled separately from normal parameters, and
the use of the params directive currently breaks attributes that
want to use it (e.g. in a struct directive).

mlir/docs/AttributesAndTypes.md

- `qualified`: mark a parameter to be printed with its leading dialect and
   mnemonic.
 - `struct`: generate a "struct-like" parser and printer for a list of key-value
   pairs.
 - `custom`: dispatch a call to user-define parser and printer functions
 - `ref`: in a custom directive, references a previously bound variable
 
 ###### `params` Directive
 
-This directive is used to refer to all parameters of an attribute or type. When
-used as a top-level directive, `params` generates a parser and printer for a
+This directive is used to refer to all parameters of an attribute or type, except
+for the attribute self type (which is handled separately from normal parameters).
+When used as a top-level directive, `params` generates a parser and printer for a
 comma-separated list of the parameters. For example:
 
 ```tablegen
 def MyPairType : TypeDef<My_Dialect, "MyPairType"> {
   let parameters = (ins "int":$a, "int":$b);
   let mnemonic = "pair";
   let assemblyFormat = "`<` params `>`";
 }

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

 def TestAttrSelfTypeParameterFormat
     : Test_Attr<"TestAttrSelfTypeParameterFormat", [TypedAttrInterface]> {
   let parameters = (ins "int":$a, AttributeSelfTypeParameter<"">:$type);
 
   let mnemonic = "attr_self_type_format";
   let assemblyFormat = "`<` $a `>`";
 }
 
+def TestAttrSelfTypeParameterStructFormat
+    : Test_Attr<"TestAttrSelfTypeParameterStructFormat", [TypedAttrInterface]> {
+  let parameters = (ins "int":$a, AttributeSelfTypeParameter<"">:$type);
+
+  let mnemonic = "attr_self_type_struct_format";
+  let assemblyFormat = "`<` struct(params) `>`";
+}
+
 // Test overridding attribute builders with a custom builder.
 def TestOverrideBuilderAttr : Test_Attr<"TestOverrideBuilder"> {
   let mnemonic = "override_builder";
   let parameters = (ins "int":$a);
   let assemblyFormat = "`<` $a `>`";
 
   let skipDefaultBuilders = 1;
   let genVerifyDecl = 1;

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

attributes {
   // 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,
+  // CHECK: #test.attr_self_type_struct_format<a = 5> : i32
+  attr6 = #test.attr_self_type_struct_format<a = 5> : i32,
   // CHECK: #test.custom_anchor<5>
-  attr6 = #test.custom_anchor<5>,
+  attr7 = #test.custom_anchor<5>,
   // CHECK: #test.custom_anchor<5, true>
-  attr7 = #test.custom_anchor<5, true>
+  attr8 = #test.custom_anchor<5, true>
 }
 
 // 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>
 // CHECK: !test.optional_param<, 6>
 // CHECK: !test.optional_param<5, 6>
 // CHECK: !test.optional_params<"a">

mlir/tools/mlir-tblgen/AttrOrTypeFormatGen.cpp

FailureOr<FormatElement *> DefFormatParser::parseParamsDirective(SMLoc loc,
   // Collect all of the attribute's or type's parameters and ensure that none of
   // the parameters have already been captured.
   std::vector<ParameterElement *> vars;
   for (const auto &it : llvm::enumerate(def.getParameters())) {
     if (seenParams.test(it.index())) {
       return emitError(loc, "`params` captures duplicate parameter: " +
                                 it.value().getName());
     }
+    // Self-type parameters are handled separately from the rest of the
+    // parameters.
+    if (isa<AttributeSelfTypeParameter>(it.value()))
+      continue;
     seenParams.set(it.index());
     vars.push_back(create<ParameterElement>(it.value()));
   }
   return create<ParamsDirective>(std::move(vars));
 }
 
 FailureOr<FormatElement *> DefFormatParser::parseStructDirective(SMLoc loc,
                                                                  Context ctx) {