Change how (un)pickling erased methods work

We basically encode the `isErased` list of booleans between the tag and the parameters.

Author: natsukagami

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

@@ -119,6 +119,12 @@ class TastyPrinter(bytes: Array[Byte]) {
         val tag = readByte()
         sb.append(" ").append(astTagToString(tag))
         indent += 2
+        if tag == ERASEDMETHODtype then
+          val erasedEnd =
+            val r = readNat()
+            currentAddr + r
+          val isErased = until(erasedEnd) { if readByte() == 1 then "T" else "F" }
+          sb.append(s"(${isErased.mkString("")})")
         if (tag >= firstLengthTreeTag) {
           val len = readNat()
           sb.append(s"(${lengthStr(len.toString)})")
@@ -133,7 +139,7 @@ class TastyPrinter(bytes: Array[Byte]) {
               printName(); printTree(); printTrees()
             case RETURN | HOLE =>
               printNat(); printTrees()
-            case METHODtype | POLYtype | TYPELAMBDAtype =>
+            case METHODtype | ERASEDMETHODtype | POLYtype | TYPELAMBDAtype =>
               printTree()
               while (currentAddr.index < end.index && !isModifierTag(nextByte)) { printTree(); printName(); }
               printTrees()

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

@@ -19,6 +19,7 @@ import config.Config
 import collection.mutable
 import reporting.{Profile, NoProfile}
 import dotty.tools.tasty.TastyFormat.ASTsSection
+import dotty.tools.dotc.transform.TypeUtils.isErasedClass
 
 object TreePickler:
   class StackSizeExceeded(val mdef: tpd.MemberDef) extends Exception
@@ -288,8 +289,8 @@ 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 // TODO @natsukagami change this
-      pickleMethodic(METHODtype, tpe, mods)
+      val tag = if tpe.isErasedMethod then ERASEDMETHODtype else METHODtype
+      pickleMethodic(tag, tpe, mods)
     case tpe: ParamRef =>
       assert(pickleParamRef(tpe), s"orphan parameter reference: $tpe")
     case tpe: LazyRef =>
@@ -298,6 +299,12 @@ class TreePickler(pickler: TastyPickler) {
 
   def pickleMethodic(tag: Int, tpe: LambdaType, mods: FlagSet)(using Context): Unit = {
     writeByte(tag)
+    if tag == ERASEDMETHODtype then
+      withLength {
+        tpe.companion.asInstanceOf[ErasedMethodCompanion]
+          .isErased
+          .foreach { isErased => writeByte(if isErased then 1 else 0) }
+      }
     withLength {
       pickleType(tpe.resultType, richTypes = true)
       tpe.paramNames.lazyZip(tpe.paramInfos).foreach { (name, tpe) =>

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

@@ -399,12 +399,21 @@ class TreeUnpickler(reader: TastyReader,
               defn.MatchCaseClass.typeRef.appliedTo(readType(), readType())
             case POLYtype =>
               readMethodic(_ => PolyType, _.toTypeName)
+            case ERASEDMETHODtype =>
+              val isErased =
+                val end = readEnd()
+                collectWhile(end != currentAddr) {
+                  readByte() == 1
+                }
+              def methodTypeCompanion(mods: FlagSet): MethodTypeCompanion =
+                if mods.is(Implicit) then ErasedImplicitMethodType(isErased)
+                else if mods.is(Given) then ErasedContextualMethodType(isErased)
+                else ErasedMethodType(isErased)
+              readMethodic(methodTypeCompanion, _.toTermName)
             case METHODtype =>
               def methodTypeCompanion(mods: FlagSet): MethodTypeCompanion =
                 if mods.is(Implicit) then ImplicitMethodType
-                // else if mods.isAllOf(Erased | Given) then ErasedContextualMethodType // TODO @natsukagami handle this
                 else if mods.is(Given) then ContextualMethodType
-                // else if mods.is(Erased) then ErasedMethodType // TODO @natsukagami handle this
                 else MethodType
               readMethodic(methodTypeCompanion, _.toTermName)
             case TYPELAMBDAtype =>

tasty/src/dotty/tools/tasty/TastyFormat.scala

@@ -580,6 +580,7 @@ object TastyFormat {
   // final val ??? = 179
   final val METHODtype = 180
   final val APPLYsigpoly = 181
+  final val ERASEDMETHODtype = 182
 
   final val MATCHtype = 190
   final val MATCHtpt = 191
@@ -793,6 +794,7 @@ object TastyFormat {
     case BYNAMEtpt => "BYNAMEtpt"
     case POLYtype => "POLYtype"
     case METHODtype => "METHODtype"
+    case ERASEDMETHODtype => "ERASEDMETHODtype"
     case TYPELAMBDAtype => "TYPELAMBDAtype"
     case LAMBDAtpt => "LAMBDAtpt"
     case MATCHtype => "MATCHtype"