New phase: FunctionalInterfaces. Rewires closures to implement more specific types of Function SAMs.

[DarkDimius]

No description provided.

[DarkDimius]

@AlexSikia, you could be interested to reuse this.

[DarkDimius]

@odersky please review.

[smarter]

So, currently something like:

val x: Function1[Int,Int] = elem => elem + 1

Is rewritten as:

val x: Function1[Int, Int] = {
  def $anonfun(elem: Int): Int = elem.+(1)
  closure($anonfun) // Pretty-print of Closure(Nil, $anonfun, EmptyTree)
}

But if instead it was rewritten as:

val x: Function1[Int, Int] = {
  def $anonfun(elem: Int): Int = elem.+(1)
  closure($anonfun:Function1[Int,Int]) // Pretty-print of Closure(Nil, $anonfun, Function1[Int, Int])
}

Then this phase would not be needed: you could just replace Function1[Int, Int] by the corresponding specialized version in the Specialize phase (which does not exist yet), no?

[DarkDimius]

But if instead it was rewritten as:

EmptyTree as tpt in Closure means that this is FunctionX. I'm not getting the difference between first version and rewritten one, in both you have the very same closure.

I believe that this commit is entirely different from what specialization is about. Specialization knows nothing about SAM's and their particularities.
What specialization does is it generates specialized methods\classes, makes generic bridges for them and dispatches to specialized methods where possible.
This change is neither about defining new methods nor about dispatching to them. And SAM's cannot have new bridges. I'm not aware how specialization can be reused to implement this.

[smarter]

What your phase does:

Closure(Nil, $anonfun, EmptyTree) ===>  Closure(Nil, $anonfun, Function$mcXX...)

One of the thing that specialization does:

new Foo[Int] ===> new Foo$mcXX...

It seems like it wouldn't be very hard to extend specialization to do:

Closure(Nil, $anonfun, Function1[Int]) ===>  Closure(Nil, $anonfun, Function1$mcXX...)

(As a bonus, it would also work for SAM types which are not FunctionN.)

[DarkDimius]

Closure(Nil, $anonfun, EmptyTree) ===> Closure(Nil, $anonfun, Function$mcXX...)

No it's not what it does! It does
Closure(Nil, $anonfun, EmptyTree) ===> Closure(Nil, $anonfun, JFunction$mcXX...)
Where JFunction is java-defined.
At some point we can extend specialization to able to do it. But I'd better extend this phase to allow to implement specialization-generated SAM's, not to make specialization itself bigger.

[odersky]

Make private?

[odersky]

Otherwise LGTM