Should it be an error to match a non-List to a List pattern?

The same questions applies to all other similar patterns (maps, sets, records, etc).

The following snippet compiles without issue but will never match:

```dart
if (node.argumentList case [_, final NamedExpression injector]) {
buffer.write(injector.expression);
}
```

That's because `node.argumentList` is not a `List`: it's an [ArgumentList](https://pub.dev/documentation/analyzer/latest/dart_ast_ast/ArgumentList-class.html) (which doesn't implement `List`).

What I _meant_ to write was:

```dart
if (node.argumentList.arguments case [_, final NamedExpression injector]) {
buffer.write(injector.expression);
}
```

As I wanted to match against [arguments](https://pub.dev/documentation/analyzer/latest/dart_ast_ast/ArgumentList/arguments.html), which is a `List`.

Shouldn't the compiler/analyzer be able to trivially determine that the first example cannot possibly match?

Or is it allowed because we could have a secret type that implements `ArgumentList` **and** `List`–essentially the issue being that `ArgumentList` lacks the final class modifier?

Start with the issue's Dart pattern-matching examples and the linked ArgumentList and arguments API documentation, then review the discussion for the unresolved type-system question. Done would require a settled specification and compiler/analyzer behavior for impossible pattern matches, including the possibility of a type implementing both ArgumentList and List.

Written by the indexing model from the issue text.