Handle FunProtos in wildcard approximations

That way we can cache implicit searches involving FunProtos in the
required types.

Author: odersky

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

@@ -324,6 +324,13 @@ object ProtoTypes {
     def typedArgs: List[Tree] = typedArgs(force = true)
     def unforcedTypedArgs: List[Tree] = typedArgs(force = false)
 
+    private def unforcedArgType(arg: untpd.Tree)(implicit ctx: Context): Type = {
+      val targ = state.typedArg(arg)
+      if (targ != null) targ.tpe else WildcardType
+    }
+
+    def unforcedArgTypes(implicit ctx: Context) = args.map(unforcedArgType)
+
     /** Type single argument and remember the unadapted result in `myTypedArg`.
      *  used to avoid repeated typings of trees when backtracking.
      */
@@ -393,6 +400,32 @@ object ProtoTypes {
     override def withContext(ctx: Context): FunProtoTyped = this
   }
 
+  /** A wildcard approximation of FunProtos used in implicit search */
+  abstract class WildFunProto(argTypes: List[Type], resType: Type)
+  extends CachedGroundType with ProtoType {
+  
+    def isMatchedBy(tp: Type, keepConstraint: Boolean = false)(implicit ctx: Context): Boolean = true
+
+    def fold[T](x: T, ta: TypeAccumulator[T])(implicit ctx: Context): T =
+      ta(ta.foldOver(x, argTypes), resType)
+
+    def map(tm: TypeMap)(implicit ctx: Context): ProtoType =
+      derivedWildFunProto(argTypes.mapconserve(tm), tm(resType))
+
+    def derivedWildFunProto(argTypes: List[Type], resType: Type)(implicit ctx: Context) =
+      if ((argTypes `eq` this.argTypes) && (resType `eq` this.resType)) this
+      else WildFunProto(argTypes, resType)
+  }
+
+  class CachedWildFunProto(argTypes: List[Type], resultType: Type) extends WildFunProto(argTypes, resultType) {
+    override def computeHash(bs: Hashable.Binders): Int = doHash(bs, argTypes, resultType)
+  }
+
+  object WildFunProto {
+    def apply(argTypes: List[Type], resType: Type)(implicit ctx: Context) =
+      unique(new CachedWildFunProto(argTypes, resType))
+  }
+
   /** A prototype for implicitly inferred views:
    *
    *    []: argType => resultType
@@ -661,7 +694,9 @@ object ProtoTypes {
           wildApprox(tp.argType, theMap, seen),
           wildApprox(tp.resultType, theMap, seen))
     case tp: FunProto =>
-      WildcardType
+      WildFunProto(
+        tp.unforcedArgTypes.mapConserve(wildApprox(_, theMap, seen)),
+        wildApprox(tp.resType, theMap, seen))
     case  _: ThisType | _: BoundType => // default case, inlined for speed
       tp
     case _ =>