Use the @ErasedParam annotation as a marker for erased parameter

... instead of storing a separate boolean list.

This has already been done, and will require no change to the TASTY format.

Author: natsukagami

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

@@ -3619,7 +3619,7 @@ object Types {
 
     def companion: LambdaTypeCompanion[ThisName, PInfo, This]
 
-    def erasedParams = List.fill(paramInfos.size)(false)
+    def erasedParams(using Context) = List.fill(paramInfos.size)(false)
 
     /** The type `[tparams := paramRefs] tp`, where `tparams` can be
      *  either a list of type parameter symbols or a list of lambda parameters
@@ -3910,25 +3910,26 @@ object Types {
 
     final override def isImplicitMethod: Boolean =
       companion.eq(ImplicitMethodType) ||
-      companion.isInstanceOf[ErasedImplicitMethodType] ||
+      companion.eq(ErasedImplicitMethodType) ||
       isContextualMethod
     final override def hasErasedParams: Boolean =
       companion.isInstanceOf[ErasedMethodCompanion]
     final override def isContextualMethod: Boolean =
       companion.eq(ContextualMethodType) ||
-      companion.isInstanceOf[ErasedContextualMethodType]
+      companion.eq(ErasedContextualMethodType)
 
-    override def erasedParams: List[Boolean] = companion match
-      case c: ErasedMethodCompanion => c.erasedParams
+    override def erasedParams(using Context): List[Boolean] = companion match
+      case c: ErasedMethodCompanion => c.erasedParams(paramInfos)
       case _ => super.erasedParams
 
     // Mark erased classes as erased parameters as well.
     def markErasedClasses(using Context): MethodType =
       val isErasedClass = paramInfos.map(_.isErasedClass)
       if isErasedClass.contains(true) then companion match
         case c: ErasedMethodCompanion =>
-          val erasedParams = c.erasedParams.zipWithConserve(isErasedClass) { (a, b) => a || b }
-          if erasedParams == c.erasedParams then this
+          val baseErasedParams = c.erasedParams(paramInfos)
+          val erasedParams = baseErasedParams.zipWithConserve(isErasedClass) { (a, b) => a || b }
+          if erasedParams == baseErasedParams then this
           else MethodType.companion(
               isContextual = isContextualMethod,
               isImplicit = isImplicitMethod,
@@ -4055,22 +4056,24 @@ object Types {
     def companion(isContextual: Boolean = false, isImplicit: Boolean = false, erasedParams: List[Boolean] = Nil): MethodTypeCompanion =
       val hasErased = erasedParams.contains(true)
       if (isContextual)
-        if (hasErased) ErasedContextualMethodType(erasedParams) else ContextualMethodType
+        if (hasErased) ErasedContextualMethodType else ContextualMethodType
       else if (isImplicit)
-        if (hasErased) ErasedImplicitMethodType(erasedParams) else ImplicitMethodType
+        if (hasErased) ErasedImplicitMethodType else ImplicitMethodType
       else
-        if (hasErased) ErasedMethodType(erasedParams) else MethodType
+        if (hasErased) ErasedMethodType else MethodType
   }
-  private def erasedMt(t: String, erasedParams: List[Boolean]) =
-    s"Erased${t}(${erasedParams.map(if _ then "erased _" else "_").mkString(", ")})"
-  sealed abstract class ErasedMethodCompanion(prefixString: String, val erasedParams: List[Boolean])
-    extends MethodTypeCompanion(erasedMt(prefixString, erasedParams))
+  sealed abstract class ErasedMethodCompanion(prefixString: String)
+    extends MethodTypeCompanion("Erased" + prefixString) {
 
-  class ErasedMethodType(erasedParams: List[Boolean]) extends ErasedMethodCompanion("MethodType", erasedParams)
+    def erasedParams(paramsInfo: List[Type])(using Context) =
+      paramsInfo.map(_.hasAnnotation(defn.ErasedParamAnnot))
+  }
+
+  object ErasedMethodType extends ErasedMethodCompanion("MethodType")
   object ContextualMethodType extends MethodTypeCompanion("ContextualMethodType")
-  class ErasedContextualMethodType(erasedParams: List[Boolean]) extends ErasedMethodCompanion("ContextualMethodType", erasedParams)
+  object ErasedContextualMethodType extends ErasedMethodCompanion("ContextualMethodType")
   object ImplicitMethodType extends MethodTypeCompanion("ImplicitMethodType")
-  class ErasedImplicitMethodType(erasedParams: List[Boolean]) extends ErasedMethodCompanion("ImplicitMethodType", erasedParams)
+  object ErasedImplicitMethodType extends ErasedMethodCompanion("ImplicitMethodType")
 
   /** A ternary extractor for MethodType */
   object MethodTpe {

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

@@ -137,14 +137,7 @@ class TastyPrinter(bytes: Array[Byte]) {
               printTree()
               while (currentAddr.index < end.index && !isModifierTag(nextByte)) { printTree(); printName(); }
               // read tags
-              until(end) {
-                val tag = readByte()
-                newLine()
-                sb.append(" ").append(astTagToString(tag))
-                if tag == ERASED then // ERASED comes with erased parameter flags
-                  val erasedParams = readBits().map(b => if b then "erased _" else "_")
-                  sb.append(s"(${erasedParams.mkString(", ")})")
-              }
+              printTrees()
             case PARAMtype =>
               printNat(); printNat()
             case _ =>

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

@@ -19,7 +19,6 @@ 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
@@ -304,10 +303,7 @@ class TreePickler(pickler: TastyPickler) {
       tpe.paramNames.lazyZip(tpe.paramInfos).foreach { (name, tpe) =>
         pickleType(tpe); pickleName(name)
       }
-      if (mods != EmptyFlags) pickleFlags(mods &~ Flags.Erased, tpe.isTermLambda)
-      if mods.is(Erased) then
-        writeByte(ERASED)
-        writeBits(tpe.erasedParams)
+      if (mods != EmptyFlags) pickleFlags(mods, tpe.isTermLambda)
     }
   }
 

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

@@ -233,24 +233,21 @@ class TreeUnpickler(reader: TastyReader,
 // ------ Reading types -----------------------------------------------------
 
     /** Read names in an interleaved sequence of types/bounds and (parameter) names,
-     *  possibly followed by a sequence of modifiers and a list of erased parameter flags.
+     *  possibly followed by a sequence of modifiers.
      */
-    def readParamNamesAndMods(end: Addr): (List[Name], FlagSet, List[Boolean]) =
+    def readParamNamesAndMods(end: Addr): (List[Name], FlagSet) =
       val names =
         collectWhile(currentAddr != end && !isModifierTag(nextByte)) {
           skipTree()
           readName()
         }
       var mods = EmptyFlags
-      var erasedParams: List[Boolean] = Nil
       while currentAddr != end do // avoid boxing the mods
         readByte() match
           case IMPLICIT => mods |= Implicit
-          case ERASED   =>
-            mods |= Erased
-            erasedParams = readBits()
+          case ERASED   => mods |= Erased
           case GIVEN    => mods |= Given
-      (names, mods, erasedParams)
+      (names, mods)
 
     /** Read `n` parameter types or bounds which are interleaved with names */
     def readParamTypes[T <: Type](n: Int)(using Context): List[T] =
@@ -326,13 +323,13 @@ class TreeUnpickler(reader: TastyReader,
         val end = readEnd()
 
         def readMethodic[N <: Name, PInfo <: Type, LT <: LambdaType]
-            (companionOp: (FlagSet, List[Boolean]) => 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, mods, erasedParams) = nameReader.readParamNamesAndMods(end)
-              companionOp(mods, erasedParams)(paramNames.map(nameMap))(
+              val (paramNames, mods) = nameReader.readParamNamesAndMods(end)
+              companionOp(mods)(paramNames.map(nameMap))(
                 pt => registeringType(pt, paramReader.readParamTypes[PInfo](paramNames.length)),
                 pt => readType())
             })
@@ -401,19 +398,19 @@ class TreeUnpickler(reader: TastyReader,
             case MATCHCASEtype =>
               defn.MatchCaseClass.typeRef.appliedTo(readType(), readType())
             case POLYtype =>
-              readMethodic((_, _) => PolyType, _.toTypeName)
+              readMethodic(_ => PolyType, _.toTypeName)
             case METHODtype =>
-              def methodTypeCompanion(mods: FlagSet, erasedParams: List[Boolean]): MethodTypeCompanion =
+              def methodTypeCompanion(mods: FlagSet): MethodTypeCompanion =
                 if mods.is(Erased) then
-                  if mods.is(Implicit) then ErasedImplicitMethodType(erasedParams)
-                  else if mods.is(Given) then ErasedContextualMethodType(erasedParams)
-                  else ErasedMethodType(erasedParams)
+                  if mods.is(Implicit) then ErasedImplicitMethodType
+                  else if mods.is(Given) then ErasedContextualMethodType
+                  else ErasedMethodType
                 else if mods.is(Implicit) then ImplicitMethodType
                 else if mods.is(Given) then ContextualMethodType
                 else MethodType
               readMethodic(methodTypeCompanion, _.toTermName)
             case TYPELAMBDAtype =>
-              readMethodic((_, _) => HKTypeLambda, _.toTypeName)
+              readMethodic(_ => HKTypeLambda, _.toTypeName)
             case PARAMtype =>
               readTypeRef() match {
                 case binder: LambdaType => binder.paramRefs(readNat())

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

@@ -74,7 +74,7 @@ object ContextFunctionResults:
         tp.derivedLambdaType(resType = integrateContextResults(tp.resType, crCount))
       case defn.ContextFunctionType(argTypes, resType, erasedParams) =>
         val methodType: MethodTypeCompanion =
-          if erasedParams.contains(true) then ErasedMethodType(erasedParams) else MethodType
+          if erasedParams.contains(true) then ErasedMethodType else MethodType
         methodType(argTypes, integrateContextResults(resType, crCount - 1))
 
   /** The total number of parameters of method `sym`, not counting

tasty/src/dotty/tools/tasty/TastyBuffer.scala

@@ -63,15 +63,6 @@ class TastyBuffer(initialSize: Int) {
     length += n
   }
 
-  /** Write a list of bits, packed into an array of bytes, prefixed by its length. */
-  def writeBits(data: List[Boolean]): Unit = {
-    val bytes = data.grouped(8)
-      .map(bits => bits.zipWithIndex.collect { case (true, i) => (1<<i).toByte }.sum)
-      .toArray
-    writeInt(data.length)
-    writeBytes(bytes, bytes.length)
-  }
-
   /** Write a natural number in big endian format, base 128.
    *  All but the last digits have bit 0x80 set.
    */

tasty/src/dotty/tools/tasty/TastyReader.scala

@@ -57,15 +57,6 @@ class TastyReader(val bytes: Array[Byte], start: Int, end: Int, val base: Int =
     result
   }
 
-  /** Read a list of packed booleans, prefixed by the length. */
-  def readBits(): List[Boolean] = {
-    val length = readInt()
-    val lengthBytes = (length + 7) / 8 // number of bytes followed, this is ceil(length / 8)
-    List.fill(lengthBytes) { readByte() }
-      .flatMap(byte => List.tabulate(8) { i => (byte & (1 << i)) > 0 })
-      .take(length) // we got lengthBytes * 8 bits here, with some extra bits, just cut them off.
-  }
-
   /** Read a natural number fitting in an Int in big endian format, base 128.
    *  All but the last digits have bit 0x80 set.
    */