remove variants of METHODtype tasty tag

Author: bishabosha

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

@@ -62,7 +62,10 @@ class TastyPrinter(bytes: Array[Byte])(implicit ctx: Context) {
         val length = treeColor("%5d".format(index(currentAddr) - index(startAddr)))
         sb.append(s"\n $length:" + " " * indent)
       }
-      def printNat() = sb.append(treeColor(" " + readNat()))
+      def printNat() = {
+        val idx = readNat()
+        sb.append(treeColor(" " + idx))
+      }
       def printName() = {
         val idx = readNat()
         sb.append(nameColor(" " + idx + " [" + nameRefToString(NameRef(idx)) + "]"))
@@ -86,11 +89,10 @@ class TastyPrinter(bytes: Array[Byte])(implicit ctx: Context) {
               printName(); printTree(); printTrees()
             case RETURN | HOLE =>
               printNat(); printTrees()
-            case METHODtype | ERASEDMETHODtype |
-                 GIVENMETHODtype | ERASEDGIVENMETHODtype | IMPLICITMETHODtype |
-                 POLYtype | TYPELAMBDAtype =>
+            case METHODtype | POLYtype | TYPELAMBDAtype =>
               printTree()
-              until(end) { printName(); printTree() }
+              while (currentAddr.index < end.index && !isModifierTag(nextByte)) { printTree(); printName(); }
+              printTrees()
             case PARAMtype =>
               printNat(); printNat()
             case _ =>

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

@@ -259,7 +259,7 @@ class TreePickler(pickler: TastyPickler) {
       writeByte(BYNAMEtype)
       pickleType(tpe.underlying)
     case tpe: HKTypeLambda =>
-      pickleMethodic(TYPELAMBDAtype, tpe)
+      pickleMethodic(TYPELAMBDAtype, tpe, EmptyFlags)
     case tpe: MatchType =>
       writeByte(MATCHtype)
       withLength {
@@ -268,26 +268,34 @@ class TreePickler(pickler: TastyPickler) {
         tpe.cases.foreach(pickleType(_))
       }
     case tpe: PolyType if richTypes =>
-      pickleMethodic(POLYtype, tpe)
+      pickleMethodic(POLYtype, tpe, EmptyFlags)
     case tpe: MethodType if richTypes =>
-      val tag = methodTypeTag(
-        isContextual = tpe.isContextualMethod,
-        isImplicit = tpe.isImplicitMethod && !tpe.isContextualMethod,
-        isErased = tpe.isErasedMethod)
-      pickleMethodic(tag, tpe)
+      val isContextual = tpe.isContextualMethod
+      val isImplicit   = tpe.isImplicitMethod && !tpe.isContextualMethod
+      val isErased     = tpe.isErasedMethod
+      verifyMethodTypeFlags(isContextual, isImplicit, isErased)
+      val mods = {
+        var mods = EmptyFlags
+        if (isContextual) mods |= Given
+        if (isImplicit) mods |= Implicit
+        if (isErased) mods |= Erased
+        mods
+      }
+      pickleMethodic(METHODtype, tpe, mods)
     case tpe: ParamRef =>
       assert(pickleParamRef(tpe), s"orphan parameter reference: $tpe")
     case tpe: LazyRef =>
       pickleType(tpe.ref)
   }
 
-  def pickleMethodic(tag: Int, tpe: LambdaType)(implicit ctx: Context): Unit = {
+  def pickleMethodic(tag: Int, tpe: LambdaType, mods: FlagSet)(implicit ctx: Context): Unit = {
     writeByte(tag)
     withLength {
       pickleType(tpe.resultType, richTypes = true)
       tpe.paramNames.lazyZip(tpe.paramInfos).foreach { (name, tpe) =>
-        pickleName(name); pickleType(tpe)
+        pickleType(tpe); pickleName(name)
       }
+      if (mods != EmptyFlags) pickleFlags(mods, tpe.isTermLambda)
     }
   }
 

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

@@ -212,15 +212,20 @@ class TreeUnpickler(reader: TastyReader,
 
     /** Read names in an interleaved sequence of (parameter) names and types/bounds */
     def readParamNames(end: Addr): List[Name] =
-      until(end) {
-        val name = readName()
-        skipTree()
-        name
-      }
+      until(end) { skipTree(); readName() }
 
     /** Read types or bounds in an interleaved sequence of (parameter) names and types/bounds */
     def readParamTypes[T <: Type](end: Addr)(implicit ctx: Context): List[T] =
-      until(end) { readNat(); readType().asInstanceOf[T] }
+      until(end) {
+        val result = readType().asInstanceOf[T]
+        readNat()
+        result
+      }
+
+    def skipMethodicParams(end: Addr): Addr = {
+      while(currentAddr.index < end.index && !isModifierTag(nextByte)) { skipTree(); readNat(); }
+      currentAddr
+    }
 
     /** Read reference to definition and return symbol created at that definition */
     def readSymRef()(implicit ctx: Context): Symbol = symbolAt(readAddr())
@@ -290,14 +295,17 @@ class TreeUnpickler(reader: TastyReader,
         val end = readEnd()
 
         def readMethodic[N <: Name, PInfo <: Type, LT <: LambdaType]
-            (companion: LambdaTypeCompanion[N, PInfo, LT], nameMap: Name => N): LT = {
+            (companionOp: FlagSet => LambdaTypeCompanion[N, PInfo, LT], nameMap: Name => N): LT = {
           val result = typeAtAddr.getOrElse(start, {
               val nameReader = fork
               nameReader.skipTree() // skip result
               val paramReader = nameReader.fork
-              val paramNames = nameReader.readParamNames(end).map(nameMap)
-              companion(paramNames)(
-                pt => registeringType(pt, paramReader.readParamTypes[PInfo](end)),
+              val modifiersReader = paramReader.fork
+              val firstFlag = modifiersReader.skipMethodicParams(end)
+              val mods = readModifiers(modifiersReader, end)
+              val paramNames = nameReader.readParamNames(firstFlag).map(nameMap)
+              companionOp(mods)(paramNames)(
+                pt => registeringType(pt, paramReader.readParamTypes[PInfo](firstFlag)),
                 pt => readType())
             })
           goto(end)
@@ -315,6 +323,25 @@ class TreeUnpickler(reader: TastyReader,
             tp.withVariances(vs)
           case _ => tp
 
+        def readModifiers(modReader: TreeReader, end: Addr): FlagSet = {
+          import modReader.reader._
+          var mods = EmptyFlags
+          while (currentAddr.index < end.index) {
+            readByte() match {
+              case IMPLICIT => mods |= Implicit
+              case ERASED   => mods |= Erased
+              case GIVEN    => mods |= Given
+              case tag => pickling.println(s"ignoring ``modifier``: ${astTagToString(tag)}")
+            }
+          }
+          verifyMethodTypeFlags(
+            isContextual = mods.is(Given),
+            isImplicit   = mods.is(Implicit),
+            isErased     = mods.is(Erased)
+          )
+          mods
+        }
+
         val result =
           (tag: @switch) match {
             case TERMREFin =>
@@ -361,19 +388,23 @@ class TreeUnpickler(reader: TastyReader,
             case MATCHtype =>
               MatchType(readType(), readType(), until(end)(readType()))
             case POLYtype =>
-              readMethodic(PolyType, _.toTypeName)
+              readMethodic(_ => PolyType, _.toTypeName)
             case METHODtype =>
-              readMethodic(MethodType, _.toTermName)
-            case ERASEDMETHODtype =>
-              readMethodic(ErasedMethodType, _.toTermName)
-            case GIVENMETHODtype =>
-              readMethodic(ContextualMethodType, _.toTermName)
-            case ERASEDGIVENMETHODtype =>
-              readMethodic(ErasedContextualMethodType, _.toTermName)
-            case IMPLICITMETHODtype =>
-              readMethodic(ImplicitMethodType, _.toTermName)
+              def methodTypeCompanion(mods: FlagSet): MethodTypeCompanion = {
+                if mods.is(Implicit) then
+                  ImplicitMethodType
+                else if mods.isAllOf(Erased | Given) then
+                  ErasedContextualMethodType
+                else if mods.is(Given) then
+                  ContextualMethodType
+                else if mods.is(Erased) then
+                  ErasedMethodType
+                else
+                  MethodType
+              }
+              readMethodic(methodTypeCompanion, _.toTermName)
             case TYPELAMBDAtype =>
-              readMethodic(HKTypeLambda, _.toTypeName)
+              readMethodic(_ => HKTypeLambda, _.toTypeName)
             case PARAMtype =>
               readTypeRef() match {
                 case binder: LambdaType => binder.paramRefs(readNat())

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

@@ -305,6 +305,7 @@ object TastyFormat {
       case DEFAULTGETTER => "DEFAULTGETTER"
       case SUPERACCESSOR => "SUPERACCESSOR"
       case INLINEACCESSOR => "INLINEACCESSOR"
+      case BODYRETAINER => "BODYRETAINER"
       case OBJECTCLASS => "OBJECTCLASS"
       case SIGNED => "SIGNED"
       case id => s"NotANameTag($id)"
@@ -460,21 +461,15 @@ object TastyFormat {
   final val TYPEREFin = 175
 
   final val METHODtype = 180
-  final val ERASEDMETHODtype = 181
-  final val GIVENMETHODtype = 182
-  final val ERASEDGIVENMETHODtype = 183
-  final val IMPLICITMETHODtype = 184
 
   final val MATCHtype = 190
   final val MATCHtpt = 191
 
-  def methodTypeTag(isContextual: Boolean, isImplicit: Boolean, isErased: Boolean): Int = {
-    val implicitOffset =
-      if (isContextual) 2
-      else if (isImplicit) { assert(!isErased); 4 }
-      else 0
-    val erasedOffset = if (isErased) 1 else 0
-    METHODtype + erasedOffset + implicitOffset
+  def methodTypeTag(isContextual: Boolean, isImplicit: Boolean, isErased: Boolean): Int =
+    throw new UnsupportedOperationException("deprecated: please use `verifyMethodTypeFlags`")
+
+  def verifyMethodTypeFlags(isContextual: Boolean, isImplicit: Boolean, isErased: Boolean): Unit = {
+    if (isImplicit) { if (isErased) throw new java.lang.AssertionError("Can't be implicit and erased") }
   }
 
   final val HOLE = 255
@@ -680,10 +675,6 @@ object TastyFormat {
     case BYNAMEtpt => "BYNAMEtpt"
     case POLYtype => "POLYtype"
     case METHODtype => "METHODtype"
-    case ERASEDMETHODtype => "ERASEDMETHODtype"
-    case GIVENMETHODtype => "GIVENMETHODtype"
-    case ERASEDGIVENMETHODtype => "ERASEDGIVENMETHODtype"
-    case IMPLICITMETHODtype => "IMPLICITMETHODtype"
     case TYPELAMBDAtype => "TYPELAMBDAtype"
     case LAMBDAtpt => "LAMBDAtpt"
     case MATCHtype => "MATCHtype"
@@ -702,10 +693,7 @@ object TastyFormat {
     case VALDEF | DEFDEF | TYPEDEF | TYPEPARAM | PARAM | NAMEDARG | RETURN | BIND |
          SELFDEF | REFINEDtype | TERMREFin | TYPEREFin | HOLE => 1
     case RENAMED | PARAMtype => 2
-    case POLYtype | TYPELAMBDAtype |
-         METHODtype | ERASEDMETHODtype |
-         GIVENMETHODtype | ERASEDGIVENMETHODtype |
-         IMPLICITMETHODtype => -1
+    case POLYtype | TYPELAMBDAtype | METHODtype => -1
     case _ => 0
   }
 }