Slightly change how erased parameters are inferred in closures

Erasedness will now always be inferred from the function body, especially
when `calleeType` value is available. Otherwise, it's better just to stick
to the original definition.
The target type is not considered, and type checking should fail when signatures
do not match.

Author: natsukagami

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

@@ -1441,6 +1441,15 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         NoType
     }
 
+    val calleeIsErased = calleeType.widen match {
+      case mt: MethodType if mt.isErasedMethod =>
+        val companion = mt.companion.asInstanceOf[ErasedMethodCompanion]
+        params.map(p => companion.isErased(paramIndex(p.name)))
+        // companion.isErased
+      case _ => params.map(_ => false)
+    }
+      // println(s"callee type = ${calleeType.widen}")
+
     pt match {
       case pt: TypeVar
       if untpd.isFunctionWithUnknownParamType(tree) && !calleeType.exists =>
@@ -1453,15 +1462,9 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
 
     val (protoFormals, resultTpt) = decomposeProtoFunction(pt, params.length, tree.srcPos)
 
-    val protoIsErased = pt match {
-      case RefinedType(_, _, mt: MethodType) if mt.isErasedMethod =>
-        mt.companion.asInstanceOf[ErasedMethodCompanion].isErased
-      case _ => List.fill(protoFormals.length)(false)
-    }
-
     /** Returns the type and whether the parameter is erased */
     def protoFormal(i: Int): (Type, Boolean) =
-      if (protoFormals.length == params.length) (protoFormals(i), protoIsErased(i) || isDefinedErased(i))
+      if (protoFormals.length == params.length) (protoFormals(i), calleeIsErased(i) || isDefinedErased(i))
       else (errorType(WrongNumberOfParameters(protoFormals.length), tree.srcPos), isDefinedErased(i))
 
     /** Is `formal` a product type which is elementwise compatible with `params`? */
@@ -1500,7 +1503,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         for ((param, i) <- params.zipWithIndex) yield
           if (!param.tpt.isEmpty) param
           else
-            val (formal, isProtoErased) = protoFormal(i)
+            val (formal, isErased) = protoFormal(i)
             val knownFormal = isFullyDefined(formal, ForceDegree.failBottom)
             val paramType =
               if knownFormal then formal
@@ -1511,8 +1514,8 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
                   .withType(paramType.translateFromRepeated(toArray = false))
                   .withSpan(param.span.endPos)
               )
-            val isErased = isProtoErased || paramType.hasAnnotation(defn.ErasedParamAnnot)
-            cpy.ValDef(param)(tpt = paramTpt)
+            val param1 = if isErased then param.withAddedFlags(Flags.Erased) else param
+            cpy.ValDef(param1)(tpt = paramTpt)
       desugared = desugar.makeClosure(inferredParams, fnBody, resultTpt, isContextual, tree.span)
 
     typed(desugared, pt)