Inferring invariant type arguments in object patterns

[munificent]

Given:

typedef Inv<T> = T Function(T);

Consider:

Object obj = ...
if (obj case Inv()) { ... }

What does this mean? In particular, what type argument do we infer for Inv in the object pattern? Do we infer a type? Or does that pattern just mean "check that the value has the class Inv but then doesn't actually do a full type test?

If we think of it as a class test, it's almost like we treat it as:

Object obj = ...
if (obj case Inv<var T>()) { ... }

Almost as if the case itself is generic. But we don't actually have type patterns.

If we allow this, then what happens if there is further code that expects us to now know a type, like:

Object obj = ...
if (obj case Inv() && var x) { ... }

Is there a type we can promote x to?

Or:

Object obj = ...
if (obj case Inv(call: var y)) { ... }

What is the type of y?

@leafpetersen and I talked about this some and we're currently leaning towards making this an error: If a type in an object pattern has an invariant type parameter and the matched value type doesn't give us enough context to infer a type, then it's simply an error. You either need to use a more specific matched value type (i.e. not Object in the example here), or you need to write the type argument on the pattern (i.e. case Inv<String>() or whatever). There's no way to to write a pattern that means "match Inv for any T".

[munificent]

Closing as duplicate of #2783.