Implement implicit dependent function types

Author: odersky

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -1328,10 +1328,7 @@ object Types {
         val funType = defn.FunctionOf(
           formals1 mapConserve (_.underlyingIfRepeated(mt.isJavaMethod)),
           mt.nonDependentResultApprox, mt.isImplicitMethod && !ctx.erasedTypes)
-        if (mt.isDependent) {
-          assert(!mt.isImplicitMethod)
-          RefinedType(funType, nme.apply, mt)
-        }
+        if (mt.isDependent) RefinedType(funType, nme.apply, mt)
         else funType
     }
 

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

@@ -719,12 +719,10 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       completeParams(params)
       val params1 = params.map(typedExpr(_).asInstanceOf[ValDef])
       val resultTpt = typed(body)
-      val mt = MethodType.fromSymbols(params1.map(_.symbol), resultTpt.tpe)
+      val companion = if (isImplicit) ImplicitMethodType else MethodType
+      val mt = companion.fromSymbols(params1.map(_.symbol), resultTpt.tpe)
       if (mt.isParamDependent)
         ctx.error(i"$mt is an illegal function type because it has inter-parameter dependencies", tree.pos)
-      if (isImplicit)
-        ctx.error(i"dependent function type $mt may not be implicit", tree.pos)
-
       val resTpt = TypeTree(mt.nonDependentResultApprox).withPos(body.pos)
       val typeArgs = params1.map(_.tpt) :+ resTpt
       val tycon = TypeTree(funCls.typeRef)
@@ -1723,7 +1721,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
   }
 
   protected def makeImplicitFunction(tree: untpd.Tree, pt: Type)(implicit ctx: Context): Tree = {
-    val defn.FunctionOf(formals, resType, true) = pt.dealias
+    val defn.FunctionOf(formals, _, true) = pt.dealias.dropDependentRefinement
     val paramTypes = formals.map(fullyDefinedType(_, "implicit function parameter", tree.pos))
     val ifun = desugar.makeImplicitFunction(paramTypes, tree)
     typr.println(i"make implicit function $tree / $pt ---> $ifun")

library/src/dotty/DottyPredef.scala

@@ -38,4 +38,5 @@ object DottyPredef {
   final def assertFail(): Unit = throw new java.lang.AssertionError("assertion failed")
   final def assertFail(message: => Any): Unit = throw new java.lang.AssertionError("assertion failed: " + message)
 
+  @inline final def implicitly[T](implicit ev: T): T = ev
 }

tests/pos/depfuntype.scala

@@ -15,4 +15,21 @@ object Test {
   val d: C = c
   val z = depfun3(d)
   val z1: d.M = z
+
+  // Reproduced here because the one from DottyPredef is lacking a Tasty tree and
+  // therefore can't be inlined when testing non-bootstrapped.
+  // But inlining `implicitly` is vital to make the definition of `ifun` below work.
+  inline final def implicitly[T](implicit ev: T): T = ev
+
+  type IDF = implicit (x: C) => x.M
+
+  implicit val ic: C = ???
+
+  val ifun: IDF = implicitly[C].m
+
+  val u = ifun(c)
+  val u1: Int = u
+
+  val v = ifun(d)
+  val v1: d.M = v
 }