This PR implements type parameter clause inference which lets us write a regular lambda where a polymorphic function type is expected:

val a: [T] => T => String = x => x.toString
// Inferred: [T] => (x: T) => x.toString

Additionally, we also allow regular eta-expansion (which adapts a method reference foo into an untyped lambda x => foo(x)) to proceed when the expected type is a polymorphic function type, the untyped lambda can then be adapted into a polymorphic lambda by type parameter clause inference:

val b: [T] => T => Option[T] = Option.apply
// Inferred: [T] => (x: T) => Option.apply(x)

This is similar to the proposed SIP-49 but instead of inferring the type parameter clause from the method reference we end up inferring it from the expected type, which means we allow the method reference and expected type to have different numbers of type parameters:

def pair[S, T](x: S, y: T): (S, T) = (x, y)
val c: [U] => (Int, U) => (Int, U) = pair
// Inferred: [U] => (x: Int, y: U) => pair[Int, U](x, y)

TODO:

• Propose an update to SIP-49 which matches this implementation.
• Move the code under a scala.language.experimental import.