Fix #7778: infer parameter type for contextual functions

Given a contextual function of the form

    (using x1, ..., xN) => f

If `f` is a contextual function type of the form `(T1, ..., TN) ?=> T`,
then give the type `T1` to `x1` and so on.

Author: liufengyun

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -1336,9 +1336,9 @@ object desugar {
     Function(param :: Nil, Block(vdefs, body))
   }
 
-  def makeContextualFunction(formals: List[Type], body: Tree, isErased: Boolean)(implicit ctx: Context): Tree = {
+  def makeContextualFunction(formals: List[TypeTree], body: Tree, isErased: Boolean)(implicit ctx: Context): Function = {
     val mods = if (isErased) Given | Erased else Given
-    val params = makeImplicitParameters(formals.map(TypeTree), mods)
+    val params = makeImplicitParameters(formals, mods)
     FunctionWithMods(params, body, Modifiers(mods))
   }
 

compiler/src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -98,6 +98,11 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
     case _ => tree
   }
 
+  def stripAnnotated(tree: Tree): Tree = tree match {
+    case Annotated(arg, _) => arg
+    case _ => tree
+  }
+
   /** The number of arguments in an application */
   def numArgs(tree: Tree): Int = unsplice(tree) match {
     case Apply(fn, args) => numArgs(fn) + args.length

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

@@ -598,7 +598,7 @@ object ProtoTypes {
    */
   private def wildApprox(tp: Type, theMap: WildApproxMap, seen: Set[TypeParamRef], internal: Set[TypeLambda])(using Context): Type = tp match {
     case tp: NamedType => // default case, inlined for speed
-      val isPatternBoundTypeRef = tp.isInstanceOf[TypeRef] && tp.symbol.is(Flags.Case) && !tp.symbol.isClass
+      val isPatternBoundTypeRef = tp.isInstanceOf[TypeRef] && tp.symbol.isPatternBound
       if (isPatternBoundTypeRef) WildcardType(tp.underlying.bounds)
       else if (tp.symbol.isStatic || (tp.prefix `eq` NoPrefix)) tp
       else tp.derivedSelect(wildApprox(tp.prefix, theMap, seen, internal))

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

@@ -1057,7 +1057,14 @@ class Typer extends Namer
      *  @post: If result exists, `paramIndex` is defined for the name of
      *         every parameter in `params`.
      */
-    lazy val calleeType: Type = fnBody match {
+    lazy val calleeType: Type = untpd.stripAnnotated(fnBody) match {
+      case ident: Ident if isContextual =>
+        val tp = typedIdent(ident, WildcardType).tpe.widen
+        if defn.isContextFunctionType(tp) && params.size == defn.functionArity(tp)
+        then
+          paramIndex = params.map(_.name).zipWithIndex.toMap
+          tp.select(nme.apply)
+        else NoType
       case app @ Apply(expr, args) =>
         paramIndex = {
           for (param <- params; idx <- paramIndices(param, args))
@@ -2450,9 +2457,9 @@ class Typer extends Namer
 
   protected def makeContextualFunction(tree: untpd.Tree, pt: Type)(using Context): Tree = {
     val defn.FunctionOf(formals, _, true, _) = pt.dropDependentRefinement
-    val ifun = desugar.makeContextualFunction(formals, tree, defn.isErasedFunctionType(pt))
+    val ifun = desugar.makeContextualFunction(formals.map(_ => untpd.TypeTree()), tree, defn.isErasedFunctionType(pt))
     typr.println(i"make contextual function $tree / $pt ---> $ifun")
-    typed(ifun, pt)
+    typedFunctionValue(ifun, pt)
   }
 
   /** Typecheck and adapt tree, returning a typed tree. Parameters as for `typedUnadapted` */