Make normalize handle implicit function types

This is necessary so that we can typecheck the last 4 statements
of i2146.scala.

Author: odersky

compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala

@@ -422,8 +422,8 @@ object ProtoTypes {
 
   /** The normalized form of a type
    *   - unwraps polymorphic types, tracking their parameters in the current constraint
-   *   - skips implicit parameters; if result type depends on implicit parameter,
-   *     replace with Wildcard.
+   *   - skips implicit parameters of methods and functions;
+   *     if result type depends on implicit parameter, replace with fresh type dependent parameter.
    *   - converts non-dependent method types to the corresponding function types
    *   - dereferences parameterless method types
    *   - dereferences nullary method types provided the corresponding function type
@@ -437,9 +437,10 @@ object ProtoTypes {
    */
   def normalize(tp: Type, pt: Type)(implicit ctx: Context): Type = Stats.track("normalize") {
     tp.widenSingleton match {
-      case poly: PolyType => normalize(constrained(poly).resultType, pt)
+      case poly: PolyType =>
+        normalize(constrained(poly).resultType, pt)
       case mt: MethodType =>
-        if (mt.isImplicit) resultTypeApprox(mt)
+        if (mt.isImplicit) normalize(resultTypeApprox(mt), pt)
         else if (mt.isDependent) tp
         else {
           val rt = normalize(mt.resultType, pt)
@@ -451,8 +452,11 @@ object ProtoTypes {
               if (mt.paramInfos.nonEmpty || ft <:< pt) ft else rt
           }
         }
-      case et: ExprType => et.resultType
-      case _ => tp
+      case et: ExprType =>
+        normalize(et.resultType, pt)
+      case wtp =>
+        if (defn.isImplicitFunctionType(wtp)) normalize(wtp.dealias.argInfos.last, pt)
+        else tp
     }
   }
 

tests/pos/i2146.check

@@ -0,0 +1,6 @@
+(A(),B())
+(A(),B())
+(A(),B())
+A()
+(A(),B())
+(A(),B())

tests/pos/i2146.scala

@@ -0,0 +1,24 @@
+object Test {
+  case class A()
+  case class B()
+
+  def simple[A]: implicit A => A = implicitly[A]
+
+  def foo[A, B]: implicit A => implicit B => (A, B) =
+    (implicitly[A], implicitly[B])
+
+  implicit val a: A = A()
+  implicit val b: B = B()
+
+  def main(args: Array[String]) = {
+    println(foo[A, B])
+    println(foo[A, B](a))
+    println(foo(a)(b))
+    val s: implicit A => A = simple[A]
+    println(s)
+    val x0: implicit A => implicit B => (A, B) = foo[A, B]
+    println(x0)
+    val x1: implicit B => (A, B) = foo[A, B]
+    println(x1)
+  }
+}