I think most of this needs to go into the '## Object' section.

First, note that _ is a wildcard, but <type>() is not.

On the other hand, <type>() isn't precisely the syntax of an object pattern, but it does overlap significantly (for instance, int() is an object pattern; in contrast, we can't use void Function({String s})() as an object pattern, even though void Function({String s}) is a <type>).

The old text below is not very informative, but a wildcard is an identifier pattern in its own right (as in switch (e) { _ => 1 } or var (_, _) = (2, 3);). We can add a keyword or a type to make it a variable pattern. For example:

void main() {
  switch (1) { case var _: break; }
  switch (1) { case final _: break; }
  switch (1) { case int _: break; }
}

We might want to make lines 443-444 a bit more explicit or detailed, but otherwise I think they do convey the correct information. So we could just leave them unchanged.

Line 446-447 in the old text could also be kept unchanged (the new text doesn't really fit in this section).

Again, I think it would be OK to keep lines 455-464 from the old text unchanged.

What I wanted to propose in #5926 was actually that there should be an extra paragraph here at the end of this section, perhaps something like the following:

This approach works fine for non-generic types like int and String. However, if you wish to test whether the matched value has a generic type then you need to specify the type arguments explicitly. The section about object patterns shows how you can use object patterns to infer the type arguments, which may be both more convenient and safer. Here is an example:

Iterable<int> iter = [2, 3, 4];
switch (iter) {
  case List<int> _:
    print('It was a list whose first element is ${iter[0].isEven}');
}

If we had used case List _: rather than case List<int> _: then it means case List<dynamic> _:, which in turn means that iter does not get promoted, and iter[0] is a compile-time error.

Then we could have something like the following at the end of the 'Object' section:

An extreme example is the case where the object pattern doesn't specify any properties at all. In this case the object pattern amounts to a type test. It is particularly useful in the case where the given type is generic, because the actual type arguments are inferred from the static type of the matched value. For example:

Iterable<int> iter = [2, 3, 4];
switch (iter) {
  case List():
    print('It was a list whose first element is ${iter[0].isEven}');
}

The object pattern List() is inferred to mean List<int>() because the static type of iter is Iterable<int>, and this means that the invocation of iter[0].isEven is type correct.

Hence, it may be a good habit to use an "empty" object pattern like List() when you just want to test the type of the matched value, rather than using a wildcard like List<int> _.