Type pattern matching inconsistency

[Metziell]

While I was playing with the new list patterns in C# 11, I noticed an inconsistency of sorts with the type pattern.

Assuming top-level statements in a console application, if I write this:

var cls = new MySubClass(111, "some text", true);
var typePattern = cls is MyClass and { Number: > 10, Text.Length: > 5, Flag: true }; // compile error
var typePatternReversed = cls is { Number: > 10, Text.Length: > 5, Flag: true } and MyClass; // it's ok

record MyClass(int Number, string? Text);
record MySubClass(int Number, string? Text, bool Flag) : MyClass(Number, Text);

...then I only get a compile-time error on the pattern in typePattern, because Flag doesn't exist in MyClass. Type matching first limits the property matching to the matched type. The pattern in typePatternReversed however basically ignores the type part - because the property pattern infers the MySubClass type, which inherits from MyClass, the type check seems to always be true.

For completeness, if I negate the type patterns:

var typePatternNot = cls is not MyClass and { Number: > 10, Text.Length: > 5, Flag: true }; // compile error
var typePatternNotReversed = cls is { Number: > 10, Text.Length: > 5, Flag: true } and not MyClass; // compile error

...then I get two compile-time errors as those patterns cannot be matched.

For the sake of consistency I would expect the type pattern to always limit the property pattern type regardless of order.

[Rekkonnect]

Given that your property pattern block doesn't apply to the MyClass constraint directly, I agree that both should either work or not work.