Strong mode implicit generic instantiations should be limited to known targets

[leafpetersen]

[Update: 2018.06.05] The new CFE implements this correctly, analyzer handles all but the generic function typed variable case correctly.

Per language team decision, we will not support implicit instantiation (via inference) of arbitrary function expressions, but instead only for statically resolvable tearoffs. That is, a reference to a generic function declaration or a closurization of a generic method can be simultaneously instantiated at the tearoff point, but a general function expression cannot be.

Examples:

void take(int f(int x)) {}

T foo<T>(T x) {}

class A {
  T bar<T>(T x) {}
}

T Function<T>(T x) returnFoo() => foo;

void test() {
  T baz<T>(T x) {};
  take(foo); // instantiated to int
  take((foo)); // instantiated to int
  take(new A().bar); // instantiated to int
  take (baz); // instantiated to int
  take(<T>(T x) => x); // Error, not instantiated
  var g = foo;
  take(g); // Error, not instantiated
  take(returnFoo()); // Error not instantiated
}

[Updated 2017.06.02 with bug fix]

[kevmoo]

@leafpetersen is this critical for 1.22?

[leafpetersen]

No, doesn't need to be 1.22 at all. Very small change in inference, no impact on non strong mode code.

[srawlins]

This feature has been reversed.