Simplify how function value erased parameters are inferred

We can just extract erased parameter information when eta-expanding, and
have no erasedness inference. That way, synthetic function values copy
over their erased parameters, while handwritten lambdas need to be explicitly annotated.

Author: natsukagami

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

@@ -3918,6 +3918,10 @@ object Types {
       companion.eq(ContextualMethodType) ||
       companion.isInstanceOf[ErasedContextualMethodType]
 
+    def erasedParams: List[Boolean] = companion match
+      case c: ErasedMethodCompanion => c.isErased
+      case _ => paramInfos.map(_ => false)
+
     def withoutErased(using Context): MethodType =
       val newCompanion = companion match {
         case _: ErasedMethodType => MethodType

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

@@ -285,8 +285,9 @@ object EtaExpansion extends LiftImpure {
     val body = Apply(lifted, ids)
     if (mt.isContextualMethod) body.setApplyKind(ApplyKind.Using)
     val fn =
-      if (mt.isContextualMethod) new untpd.FunctionWithMods(params, body, Modifiers(Given), params.map(_ => false))
-      else if (mt.isImplicitMethod) new untpd.FunctionWithMods(params, body, Modifiers(Implicit), params.map(_ => false))
+      if (mt.isContextualMethod) new untpd.FunctionWithMods(params, body, Modifiers(Given), mt.erasedParams)
+      else if (mt.isImplicitMethod) new untpd.FunctionWithMods(params, body, Modifiers(Implicit), mt.erasedParams)
+      else if (mt.isErasedMethod) new untpd.FunctionWithMods(params, body, Modifiers(), mt.erasedParams)
       else untpd.Function(params, body)
     if (defs.nonEmpty) untpd.Block(defs.toList map (untpd.TypedSplice(_)), fn) else fn
   }

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

@@ -1444,14 +1444,6 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         NoType
     }
 
-    lazy 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)
-    }
-
     pt match {
       case pt: TypeVar
       if untpd.isFunctionWithUnknownParamType(tree) && !calleeType.exists =>
@@ -1467,7 +1459,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     /** Returns the type and whether the parameter is erased */
     def protoFormal(i: Int): (Type, Boolean) =
       if (protoFormals.length == params.length) (protoFormals(i), isDefinedErased(i))
-      else (errorType(WrongNumberOfParameters(protoFormals.length), tree.srcPos), isDefinedErased(i))
+      else (errorType(WrongNumberOfParameters(protoFormals.length), tree.srcPos), false)
 
     /** Is `formal` a product type which is elementwise compatible with `params`? */
     def ptIsCorrectProduct(formal: Type) =
@@ -1504,23 +1496,21 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       val inferredParams: List[untpd.ValDef] =
         for ((param, i) <- params.zipWithIndex) yield
           val (formal, isErased) = protoFormal(i)
-          val (param0, isErased1) =
-            if (!param.tpt.isEmpty) (param, false)
+          val param0 =
+            if (!param.tpt.isEmpty) param
             else
               val knownFormal = isFullyDefined(formal, ForceDegree.failBottom)
-              val (paramType, isErased1) =
-                if knownFormal then (formal, false)
-                else
-                  val tpe = inferredFromTarget(param, formal, calleeType, paramIndex)
-                    .orElse(errorType(AnonymousFunctionMissingParamType(param, tree, formal), param.srcPos))
-                  (tpe, calleeIsErased(i))
+              val paramType =
+                if knownFormal then formal
+                else inferredFromTarget(param, formal, calleeType, paramIndex)
+                  .orElse(errorType(AnonymousFunctionMissingParamType(param, tree, formal), param.srcPos))
               val paramTpt = untpd.TypedSplice(
                   (if knownFormal then InferredTypeTree() else untpd.TypeTree())
                     .withType(paramType.translateFromRepeated(toArray = false))
                     .withSpan(param.span.endPos)
                 )
-              (cpy.ValDef(param)(tpt = paramTpt), isErased1)
-          if isErased || isErased1 then param0.withAddedFlags(Flags.Erased) else param0
+              cpy.ValDef(param)(tpt = paramTpt)
+          if isErased then param0.withAddedFlags(Flags.Erased) else param0
       desugared = desugar.makeClosure(inferredParams, fnBody, resultTpt, isContextual, tree.span)
 
     typed(desugared, pt)