Some sweeping changes to argument handling for erased methods

Basically, I grepped for `isErasedMethod` and changed every
argument handling code to make use of the `ErasedMethodCompanion`.

There are be some pretty repetitive
    .zip(list of bool).flatMap((f, s) => if s then None else Some(f))
patterns, I wonder if there is any better way to write them?

Author: natsukagami

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

@@ -259,7 +259,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
             if tp.isContextualMethod then Given
             else if tp.isImplicitMethod then Implicit
             else EmptyFlags
-          val maybeErased = if tp.isErasedMethod then Erased else EmptyFlags
+          val maybeErased = if tp.isErasedMethod then Erased else EmptyFlags // TODO @natsukagami change this
 
           def makeSym(info: Type) = newSymbol(sym, name, TermParam | maybeImplicit | maybeErased, info, coord = sym.coord)
 

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

@@ -543,7 +543,10 @@ object Denotations {
           case tp2: MethodType
           if TypeComparer.matchingMethodParams(tp1, tp2)
              && tp1.isImplicitMethod == tp2.isImplicitMethod
-             && tp1.isErasedMethod == tp2.isErasedMethod =>
+             && tp1.isErasedMethod == tp2.isErasedMethod
+             && (!tp1.isErasedMethod || ( // same set of erased parameters
+              tp1.companion.asInstanceOf[ErasedMethodCompanion].isErased ==
+              tp2.companion.asInstanceOf[ErasedMethodCompanion].isErased)) =>
             val resType = infoMeet(tp1.resType, tp2.resType.subst(tp2, tp1), safeIntersection)
             if resType.exists then
               tp1.derivedLambdaType(mergeParamNames(tp1, tp2), tp1.paramInfos, resType)

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

@@ -638,7 +638,13 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
     case tp: MethodType =>
       def paramErasure(tpToErase: Type) =
         erasureFn(sourceLanguage, semiEraseVCs, isConstructor, isSymbol, wildcardOK)(tpToErase)
-      val (names, formals0) = if (tp.isErasedMethod) (Nil, Nil) else (tp.paramNames, tp.paramInfos)
+      val (names, formals0) = if (tp.isErasedMethod)
+        tp.paramNames
+          .zip(tp.paramInfos)
+          .zip(tp.companion.asInstanceOf[ErasedMethodCompanion].isErased)
+          .flatMap((p, e) => if e then None else Some(p))
+          .unzip
+      else (tp.paramNames, tp.paramInfos)
       val formals = formals0.mapConserve(paramErasure)
       eraseResult(tp.resultType) match {
         case rt: MethodType =>

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

@@ -1837,7 +1837,7 @@ object Types {
       case mt: MethodType if !mt.isParamDependent =>
         val formals1 = if (dropLast == 0) mt.paramInfos else mt.paramInfos dropRight dropLast
         val isContextual = mt.isContextualMethod && !ctx.erasedTypes
-        val isErased = mt.isErasedMethod && !ctx.erasedTypes
+        val isErased = mt.isErasedMethod && !ctx.erasedTypes // TODO @natsukagami fix this
         val result1 = mt.nonDependentResultApprox match {
           case res: MethodType => res.toFunctionType(isJava)
           case res => res
@@ -3691,7 +3691,11 @@ object Types {
             else Signature(tp, sourceLanguage)
         this match
           case tp: MethodType =>
-            val params = if (isErasedMethod) Nil else tp.paramInfos
+            val params = if (isErasedMethod)
+              tp.paramInfos
+                .zip(tp.companion.asInstanceOf[ErasedMethodCompanion].isErased)
+                .flatMap((p, e) => if e then None else Some(p))
+            else tp.paramInfos
             resultSignature.prependTermParams(params, sourceLanguage)
           case tp: PolyType =>
             resultSignature.prependTypeParams(tp.paramNames.length)
@@ -3902,9 +3906,7 @@ object Types {
       companion.isInstanceOf[ErasedImplicitMethodType] ||
       isContextualMethod
     final override def isErasedMethod: Boolean =
-      companion.isInstanceOf[ErasedMethodType] ||
-      companion.isInstanceOf[ErasedImplicitMethodType] ||
-      companion.isInstanceOf[ErasedContextualMethodType]
+      companion.isInstanceOf[ErasedMethodCompanion]
     final override def isContextualMethod: Boolean =
       companion.eq(ContextualMethodType) ||
       companion.isInstanceOf[ErasedContextualMethodType]
@@ -4030,11 +4032,14 @@ object Types {
   }
   private def erasedMt(t: String, isErased: List[Boolean]) =
     s"Erased${t}(${isErased.map(if _ then "erased _" else "_").mkString(", ")})"
-  class ErasedMethodType(val isErased: List[Boolean]) extends MethodTypeCompanion(erasedMt("MethodType", isErased))
+  class ErasedMethodCompanion(prefixString: String, val isErased: List[Boolean])
+    extends MethodTypeCompanion(erasedMt(prefixString, isErased))
+
+  class ErasedMethodType(isErased: List[Boolean]) extends ErasedMethodCompanion("MethodType", isErased)
   object ContextualMethodType extends MethodTypeCompanion("ContextualMethodType")
-  class ErasedContextualMethodType(val isErased: List[Boolean]) extends MethodTypeCompanion(erasedMt("ContextualMethodType", isErased))
+  class ErasedContextualMethodType(isErased: List[Boolean]) extends ErasedMethodCompanion("ContextualMethodType", isErased)
   object ImplicitMethodType extends MethodTypeCompanion("ImplicitMethodType")
-  class ErasedImplicitMethodType(val isErased: List[Boolean]) extends MethodTypeCompanion(erasedMt("ImplicitMethodType", isErased))
+  class ErasedImplicitMethodType(isErased: List[Boolean]) extends ErasedMethodCompanion("ImplicitMethodType", isErased)
 
   /** A ternary extractor for MethodType */
   object MethodTpe {

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -288,7 +288,7 @@ class TreePickler(pickler: TastyPickler) {
       var mods = EmptyFlags
       if tpe.isContextualMethod then mods |= Given
       else if tpe.isImplicitMethod then mods |= Implicit
-      if tpe.isErasedMethod then mods |= Erased
+      if tpe.isErasedMethod then mods |= Erased // TODO @natsukagami change this
       pickleMethodic(METHODtype, tpe, mods)
     case tpe: ParamRef =>
       assert(pickleParamRef(tpe), s"orphan parameter reference: $tpe")

compiler/src/dotty/tools/dotc/transform/ContextFunctionResults.scala

@@ -92,7 +92,9 @@ object ContextFunctionResults:
     def normalParamCount(tp: Type): Int = tp.widenExpr.stripPoly match
       case mt @ MethodType(pnames) =>
         val rest = normalParamCount(mt.resType)
-        if mt.isErasedMethod then rest else pnames.length + rest
+        if mt.isErasedMethod then
+          mt.companion.asInstanceOf[ErasedMethodCompanion].isErased.count(_ == false) + rest
+        else pnames.length + rest
       case _ => contextParamCount(tp, contextResultCount(sym))
 
     normalParamCount(sym.info)

compiler/src/dotty/tools/dotc/transform/Erasure.scala

@@ -825,7 +825,12 @@ object Erasure {
       val Apply(fun, args) = tree
       val origFun = fun.asInstanceOf[tpd.Tree]
       val origFunType = origFun.tpe.widen(using preErasureCtx)
-      val ownArgs = if origFunType.isErasedMethod then Nil else args
+      val erasedCompanion = if origFunType.isErasedMethod then
+        Some(origFunType.asInstanceOf[MethodType].companion.asInstanceOf[ErasedMethodCompanion])
+      else None
+      val ownArgs = erasedCompanion.map { companion =>
+        args.zip(companion.isErased).flatMap((a, e) => if e then None else Some(a))
+      }.getOrElse(args)
       val fun1 = typedExpr(fun, AnyFunctionProto)
       fun1.tpe.widen match
         case mt: MethodType =>

compiler/src/dotty/tools/dotc/transform/GenericSignatures.scala

@@ -304,7 +304,10 @@ object GenericSignatures {
         case mtpe: MethodType =>
           // erased method parameters do not make it to the bytecode.
           def effectiveParamInfoss(t: Type)(using Context): List[List[Type]] = t match {
-            case t: MethodType if t.isErasedMethod => effectiveParamInfoss(t.resType)
+            case t: MethodType if t.isErasedMethod =>
+              t.paramInfos.zip(t.companion.asInstanceOf[ErasedMethodCompanion].isErased)
+                .flatMap((i, e) => if e then None else Some(i))
+                :: effectiveParamInfoss(t.resType)
             case t: MethodType => t.paramInfos :: effectiveParamInfoss(t.resType)
             case _ => Nil
           }

compiler/src/dotty/tools/dotc/transform/PostTyper.scala

@@ -307,16 +307,18 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
             if (methType.isErasedMethod)
               tpd.cpy.Apply(tree)(
                 tree.fun,
-                tree.args.mapConserve(arg =>
-                  if methType.isResultDependent then
-                    Checking.checkRealizable(arg.tpe, arg.srcPos, "erased argument")
-                  if (methType.isImplicitMethod && arg.span.isSynthetic)
-                    arg match
-                      case _: RefTree | _: Apply | _: TypeApply if arg.symbol.is(Erased) =>
-                        dropInlines.transform(arg)
-                      case _ =>
-                        PruneErasedDefs.trivialErasedTree(arg)
-                  else dropInlines.transform(arg)))
+                tree.args.zip(methType.companion.asInstanceOf[ErasedMethodCompanion].isErased).map((arg, isErased) =>
+                  if !isErased then arg
+                  else
+                    if methType.isResultDependent then
+                      Checking.checkRealizable(arg.tpe, arg.srcPos, "erased argument")
+                    if (methType.isImplicitMethod && arg.span.isSynthetic)
+                      arg match
+                        case _: RefTree | _: Apply | _: TypeApply if arg.symbol.is(Erased) =>
+                          dropInlines.transform(arg)
+                        case _ =>
+                          PruneErasedDefs.trivialErasedTree(arg)
+                    else dropInlines.transform(arg)))
             else
               tree
           def app1 =

compiler/src/dotty/tools/dotc/transform/PruneErasedDefs.scala

@@ -13,6 +13,8 @@ import ast.tpd
 import SymUtils._
 import config.Feature
 import Decorators.*
+import dotty.tools.dotc.core.Types.ErasedMethodCompanion
+import dotty.tools.dotc.core.Types.MethodType
 
 /** This phase makes all erased term members of classes private so that they cannot
  *  conflict with non-erased members. This is needed so that subsequent phases like
@@ -39,7 +41,9 @@ class PruneErasedDefs extends MiniPhase with SymTransformer { thisTransform =>
 
   override def transformApply(tree: Apply)(using Context): Tree =
     if !tree.fun.tpe.widen.isErasedMethod then tree
-    else cpy.Apply(tree)(tree.fun, tree.args.map(trivialErasedTree))
+    else
+      val comp = tree.fun.tpe.widen.asInstanceOf[MethodType].companion.asInstanceOf[ErasedMethodCompanion]
+      cpy.Apply(tree)(tree.fun, tree.args.zip(comp.isErased).map((a, e) => if e then trivialErasedTree(a) else a))
 
   override def transformValDef(tree: ValDef)(using Context): Tree =
     checkErasedInExperimental(tree.symbol)