Decouple ImplicitFunctionN from FunctionN.

[nicolasstucki]

This removes an illegal method override mentioned in #2000.

[odersky]

Not sure about the change in this logic. Questions:

• Do we want to convert implicit functions to functions, or to other SAM types? Does this case even arise? I was assuming that an implicit function is always immediately applied.
• What would happen if we kept the previous code here?

[nicolasstucki]

It is from implicit function to function, previously this worked because implicit functions where a subtype of functions.

A concrete case that fails without this change is

-- [E007] Type Mismatch Error: /Users/nicolasstucki/GitHub/dotty/tests/partest-generated/run/implicitFuns.scala --------
148 |        println(if (thisTransaction.isAborted) "aborted" else s"result: $res")
    |                                                                              ^
    |                                                                        found:    implicit Transaction => Unit
    |                                                                        required: Transaction => Any

where

  def transaction[T](op: Transaction => T) = {
    ...
  }

  def main(args: Array[String]) = {
    transaction {
      implicit thisTransaction =>
        val res = f1(args.length)
        println(if (thisTransaction.isAborted) "aborted" else s"result: $res")
    }
  }

Is there a better way to implement this coercion from implicit function to function?

[odersky]

@nicolasstucki Thanks for explaining! So we need to make implicit functions compatible with normal functions after all. This means we have the following choices:

• add a specific conversion, as in this PR. This is conceptually heavy. Every new kind of conversion adds considerable complexity to the spec.
• drop implicit modifier on apply method of implicit function, but treat it as an implicit anyway. This is also irregular.
• Make implicit functions subtypes of functions, but omit the check on implicit overrides. This is the status quo. To keep it bullet proof we have to keep implicit functions effectively final (which they are, as of now, because of the impossibility to define apply).

To come to a resolution here I think it's best to answer first the question whether implicit functions should be final or not. Making them non-final gives us a lot of new power. For instance:

 class Dummy
 implicit val d: Dummy = new Dummy
 class Ref[T](var elem: T) extends implicit Dummy => T {
    def apply(implicit d: Dummy): T = elem
 }

 val r = new Ref(22)
 val y = r    // y has type Int, not Ref[Int]!

Super powerful. But do we want it?

[nicolasstucki]

I do not have any use cases for this. We should still double check that with #2014 we can not override the apply of an implicit function with def apply(d: Dummy) (in the example above), this was perviously possible.

[odersky]

We should still double check that with #2014 we can not override the apply of an implicit function with def apply(d: Dummy) (in the example above), this was perviously possible.

I tried it in the REPL: Now it's no longer possible.

[nicolasstucki]

Then this PR is irrelevant now.