Take names of synthesized contextual functions from expected type

If expected type has parameter names, use them for the generated contextual closure.

Author: odersky

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

@@ -205,12 +205,12 @@ object desugar {
 
   def makeImplicitParameters(
       tpts: List[Tree], implicitFlag: FlagSet,
-      mkParamName: () => TermName,
+      mkParamName: Int => TermName,
       forPrimaryConstructor: Boolean = false
   )(using Context): List[ValDef] =
     for (tpt, i) <- tpts.zipWithIndex yield {
        val paramFlags: FlagSet = if (forPrimaryConstructor) LocalParamAccessor else Param
-       val epname = mkParamName()
+       val epname = mkParamName(i)
        ValDef(epname, tpt, EmptyTree).withFlags(paramFlags | implicitFlag)
     }
 
@@ -254,7 +254,7 @@ object desugar {
           // using clauses, we only need names that are unique among the
           // parameters of the method since shadowing does not affect
           // implicit resolution in Scala 3.
-          mkParamName = () =>
+          mkParamName = i =>
             val index = seenContextBounds + 1 // Start at 1 like FreshNameCreator.
             val ret = ContextBoundParamName(EmptyTermName, index)
             seenContextBounds += 1
@@ -1602,9 +1602,12 @@ object desugar {
       case vd: ValDef => vd
     }
 
-  def makeContextualFunction(formals: List[Tree], body: Tree, erasedParams: List[Boolean])(using Context): Function = {
+  def makeContextualFunction(formals: List[Tree], paramNamesOrNil: List[TermName], body: Tree, erasedParams: List[Boolean])(using Context): Function = {
     val mods = Given
-    val params = makeImplicitParameters(formals, mods, mkParamName = () => ContextFunctionParamName.fresh())
+    val params = makeImplicitParameters(formals, mods,
+      mkParamName = i =>
+        if paramNamesOrNil.isEmpty then ContextFunctionParamName.fresh()
+        else paramNamesOrNil(i))
     FunctionWithMods(params, body, Modifiers(mods), erasedParams)
   }
 

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

@@ -3204,6 +3204,9 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
 
   protected def makeContextualFunction(tree: untpd.Tree, pt: Type)(using Context): Tree = {
     val defn.FunctionOf(formals, _, true) = pt.dropDependentRefinement: @unchecked
+    val paramNamesOrNil = pt match
+      case RefinedType(_, _, rinfo: MethodType) => rinfo.paramNames
+      case _ => Nil
 
     // The getter of default parameters may reach here.
     // Given the code below
@@ -3236,7 +3239,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       case _ => paramTypes.map(_ => false)
     }
 
-    val ifun = desugar.makeContextualFunction(paramTypes, tree, erasedParams)
+    val ifun = desugar.makeContextualFunction(paramTypes, paramNamesOrNil, tree, erasedParams)
     typr.println(i"make contextual function $tree / $pt ---> $ifun")
     typedFunctionValue(ifun, pt)
   }