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/ast/tpd.scala

@@ -1134,10 +1134,10 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
     def etaExpandCFT(using Context): Tree =
       def expand(target: Tree, tp: Type)(using Context): Tree = tp match
-        case defn.ContextFunctionType(argTypes, resType, erasedParams) =>
+        case defn.ContextFunctionType(argTypes, resType, _) =>
           val anonFun = newAnonFun(
             ctx.owner,
-            MethodType.companion(isContextual = true, erasedParams = erasedParams)(argTypes, resType),
+            MethodType.companion(isContextual = true)(argTypes, resType),
             coord = ctx.owner.coord)
           def lambdaBody(refss: List[List[Tree]]) =
             expand(target.select(nme.apply).appliedToArgss(refss), resType)(

compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala

@@ -336,8 +336,8 @@ class CheckCaptures extends Recheck, SymTransformer:
         mapArgUsing(_.forceBoxStatus(false))
       else if meth == defn.Caps_unsafeBoxFunArg then
         mapArgUsing {
-          case defn.FunctionOf(paramtpe :: Nil, restpe, isContectual, erasedParams) =>
-            defn.FunctionOf(paramtpe.forceBoxStatus(true) :: Nil, restpe, isContectual, erasedParams)
+          case defn.FunctionOf(paramtpe :: Nil, restpe, isContectual) =>
+            defn.FunctionOf(paramtpe.forceBoxStatus(true) :: Nil, restpe, isContectual)
         }
       else
         super.recheckApply(tree, pt) match
@@ -430,7 +430,7 @@ class CheckCaptures extends Recheck, SymTransformer:
       block match
         case closureDef(mdef) =>
           pt.dealias match
-            case defn.FunctionOf(ptformals, _, _, _)
+            case defn.FunctionOf(ptformals, _, _)
             if ptformals.nonEmpty && ptformals.forall(_.captureSet.isAlwaysEmpty) =>
               // Redo setup of the anonymous function so that formal parameters don't
               // get capture sets. This is important to avoid false widenings to `*`
@@ -598,18 +598,18 @@ class CheckCaptures extends Recheck, SymTransformer:
       //println(i"check conforms $actual1 <<< $expected1")
       super.checkConformsExpr(actual1, expected1, tree)
 
-    private def toDepFun(args: List[Type], resultType: Type, isContextual: Boolean, erasedParams: List[Boolean])(using Context): Type =
-      MethodType.companion(isContextual = isContextual, erasedParams = erasedParams)(args, resultType)
+    private def toDepFun(args: List[Type], resultType: Type, isContextual: Boolean)(using Context): Type =
+      MethodType.companion(isContextual = isContextual)(args, resultType)
         .toFunctionType(isJava = false, alwaysDependent = true)
 
     /** Turn `expected` into a dependent function when `actual` is dependent. */
     private def alignDependentFunction(expected: Type, actual: Type)(using Context): Type =
       def recur(expected: Type): Type = expected.dealias match
         case expected @ CapturingType(eparent, refs) =>
           CapturingType(recur(eparent), refs, boxed = expected.isBoxed)
-        case expected @ defn.FunctionOf(args, resultType, isContextual, erasedParams)
+        case expected @ defn.FunctionOf(args, resultType, isContextual)
           if defn.isNonRefinedFunction(expected) && defn.isFunctionType(actual) && !defn.isNonRefinedFunction(actual) =>
-          val expected1 = toDepFun(args, resultType, isContextual, erasedParams)
+          val expected1 = toDepFun(args, resultType, isContextual)
           expected1
         case _ =>
           expected
@@ -675,7 +675,7 @@ class CheckCaptures extends Recheck, SymTransformer:
 
         try
           val (eargs, eres) = expected.dealias.stripCapturing match
-            case defn.FunctionOf(eargs, eres, _, _) => (eargs, eres)
+            case defn.FunctionOf(eargs, eres, _) => (eargs, eres)
             case expected: MethodType => (expected.paramInfos, expected.resType)
             case expected @ RefinedType(_, _, rinfo: MethodType) if defn.isFunctionType(expected) => (rinfo.paramInfos, rinfo.resType)
             case _ => (aargs.map(_ => WildcardType), WildcardType)

compiler/src/dotty/tools/dotc/cc/Setup.scala

@@ -38,7 +38,6 @@ extends tpd.TreeTraverser:
   private def depFun(tycon: Type, argTypes: List[Type], resType: Type)(using Context): Type =
     MethodType.companion(
         isContextual = defn.isContextFunctionClass(tycon.classSymbol),
-        erasedParams = defn.erasedFunctionParameters(tycon)
       )(argTypes, resType)
       .toFunctionType(isJava = false, alwaysDependent = true)
 
@@ -260,7 +259,7 @@ extends tpd.TreeTraverser:
   private def expandThrowsAlias(tp: Type)(using Context) = tp match
     case AppliedType(tycon, res :: exc :: Nil) if tycon.typeSymbol == defn.throwsAlias =>
       // hard-coded expansion since $throws aliases in stdlib are defined with `?=>` rather than `?->`
-      defn.FunctionOf(defn.CanThrowClass.typeRef.appliedTo(exc) :: Nil, res, isContextual = true, erasedParams = List(true))
+      defn.FunctionOf(defn.CanThrowClass.typeRef.appliedTo(exc) :: Nil, res, isContextual = true)
     case _ => tp
 
   private def expandThrowsAliases(using Context) = new TypeMap:

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

@@ -134,8 +134,7 @@ class Definitions {
           val resParamRef = enterTypeParam(cls, paramNamePrefix ++ "R", Covariant, decls).typeRef
           val methodType = MethodType.companion(
             isContextual = name.isContextFunction,
-            isImplicit = false,
-            erasedParams = List())
+            isImplicit = false)
           decls.enter(newMethod(cls, nme.apply, methodType(argParamRefs, resParamRef), Deferred))
           denot.info =
             ClassInfo(ScalaPackageClass.thisType, cls, ObjectType :: Nil, decls)
@@ -1086,23 +1085,22 @@ class Definitions {
     sym.owner.linkedClass.typeRef
 
   object FunctionOf {
-    def apply(args: List[Type], resultType: Type, isContextual: Boolean = false, erasedParams: List[Boolean] = List())(using Context): Type =
-      assert(erasedParams.size == 0 || args.size == erasedParams.size)
-      if erasedParams.contains(true) then
-        val mt = MethodType.companion(isContextual, false, erasedParams.padTo(args.size, false))(args, resultType)
+    def apply(args: List[Type], resultType: Type, isContextual: Boolean = false)(using Context): Type =
+      val mt = MethodType.companion(isContextual, false)(args, resultType)
+      if mt.hasErasedParams then
         RefinedType(ErasedFunctionClass.typeRef, nme.apply, mt)
       else
         FunctionType(args.length, isContextual).appliedTo(args ::: resultType :: Nil)
-    def unapply(ft: Type)(using Context): Option[(List[Type], Type, Boolean, List[Boolean])] = {
+    def unapply(ft: Type)(using Context): Option[(List[Type], Type, Boolean)] = {
       ft.dealias match
         case RefinedType(parent, nme.apply, mt: MethodType) if isErasedFunctionType(parent) =>
-          Some(mt.paramInfos, mt.resType, mt.isContextualMethod, mt.erasedParams)
+          Some(mt.paramInfos, mt.resType, mt.isContextualMethod)
         case _ =>
           val tsym = ft.dealias.typeSymbol
           if isFunctionSymbol(tsym) && ft.isRef(tsym) then
             val targs = ft.dealias.argInfos
             if (targs.isEmpty) None
-            else Some(targs.init, targs.last, tsym.name.isContextFunction, List.fill(targs.init.size) { false })
+            else Some(targs.init, targs.last, tsym.name.isContextFunction)
           else None
     }
   }

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

@@ -42,10 +42,10 @@ object NamerOps:
       case Nil =>
         resultType
       case TermSymbols(params) :: paramss1 =>
-        val (isContextual, isImplicit, erasedParams) =
-          if params.isEmpty then (false, false, List())
-          else (params.head.is(Given), params.head.is(Implicit), params.map(_.is(Erased)))
-        val make = MethodType.companion(isContextual = isContextual, isImplicit = isImplicit, erasedParams = erasedParams)
+        val (isContextual, isImplicit) =
+          if params.isEmpty then (false, false)
+          else (params.head.is(Given), params.head.is(Implicit))
+        val make = MethodType.companion(isContextual = isContextual, isImplicit = isImplicit)
         if isJava then
           for param <- params do
             if param.info.isDirectRef(defn.ObjectClass) then param.info = defn.AnyType

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

@@ -427,7 +427,7 @@ object Types {
     def isContextualMethod: Boolean = false
 
     /** Is this a MethodType for which the parameters will not be used? */
-    def hasErasedParams: Boolean = false
+    def hasErasedParams(using Context): Boolean = false
 
     /** Is this a match type or a higher-kinded abstraction of one?
      */
@@ -1182,7 +1182,8 @@ object Types {
 
     /** Remove all AnnotatedTypes wrapping this type.
      */
-    def stripAnnots(using Context): Type = this
+    def stripAnnots(keep: Annotation => Context ?=> Boolean)(using Context): Type = this
+    final def stripAnnots(using Context): Type = stripAnnots(_ => false)
 
     /** Strip TypeVars and Annotation and CapturingType wrappers */
     def stripped(using Context): Type = this
@@ -1843,14 +1844,13 @@ 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 erasedParams = (if !ctx.erasedTypes then mt.erasedParams else List.fill(mt.paramInfos.size) { false }).dropRight(dropLast)
         val result1 = mt.nonDependentResultApprox match {
           case res: MethodType => res.toFunctionType(isJava)
           case res => res
         }
         val funType = defn.FunctionOf(
           formals1 mapConserve (_.translateFromRepeated(toArray = isJava)),
-          result1, isContextual, erasedParams)
+          result1, isContextual)
         if alwaysDependent || mt.isResultDependent then RefinedType(funType, nme.apply, mt)
         else funType
     }
@@ -3623,7 +3623,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
@@ -3913,38 +3913,14 @@ object Types {
     def companion: MethodTypeCompanion
 
     final override def isImplicitMethod: Boolean =
-      companion.eq(ImplicitMethodType) ||
-      companion.isInstanceOf[ErasedImplicitMethodType] ||
-      isContextualMethod
-    final override def hasErasedParams: Boolean =
-      companion.isInstanceOf[ErasedMethodCompanion]
+      companion.eq(ImplicitMethodType) || isContextualMethod
+    final override def hasErasedParams(using Context): Boolean =
+      erasedParams.contains(true)
     final override def isContextualMethod: Boolean =
-      companion.eq(ContextualMethodType) ||
-      companion.isInstanceOf[ErasedContextualMethodType]
-
-    override def erasedParams: List[Boolean] = companion match
-      case c: ErasedMethodCompanion => c.erasedParams
-      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
-          else MethodType.companion(
-              isContextual = isContextualMethod,
-              isImplicit = isImplicitMethod,
-              erasedParams = erasedParams
-            )(paramNames)(paramInfosExp, resultTypeExp)
-        case _ =>
-          MethodType.companion(
-              isContextual = isContextualMethod,
-              isImplicit = isImplicitMethod,
-              erasedParams = isErasedClass
-            )(paramNames)(paramInfosExp, resultTypeExp)
-      else this
+      companion.eq(ContextualMethodType)
+
+    override def erasedParams(using Context): List[Boolean] =
+      paramInfos.map(p => p.hasAnnotation(defn.ErasedParamAnnot) || p.isErasedClass)
 
     protected def prefixString: String = companion.prefixString
   }
@@ -4041,7 +4017,7 @@ object Types {
          tl => tl.integrate(params, resultType))
     end fromSymbols
 
-    final def apply(paramNames: List[TermName])(paramInfosExp: MethodType => List[Type], resultTypeExp: MethodType => Type)(using Context): MethodType =
+    def apply(paramNames: List[TermName])(paramInfosExp: MethodType => List[Type], resultTypeExp: MethodType => Type)(using Context): MethodType =
       checkValid(unique(new CachedMethodType(paramNames)(paramInfosExp, resultTypeExp, self)))
 
     def checkValid(mt: MethodType)(using Context): mt.type = {
@@ -4056,25 +4032,14 @@ object Types {
   }
 
   object MethodType extends MethodTypeCompanion("MethodType") {
-    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
-      else if (isImplicit)
-        if (hasErased) ErasedImplicitMethodType(erasedParams) else ImplicitMethodType
-      else
-        if (hasErased) ErasedMethodType(erasedParams) else MethodType
+    def companion(isContextual: Boolean = false, isImplicit: Boolean = false): MethodTypeCompanion =
+      if (isContextual) ContextualMethodType
+      else if (isImplicit) ImplicitMethodType
+      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))
 
-  class ErasedMethodType(erasedParams: List[Boolean]) extends ErasedMethodCompanion("MethodType", erasedParams)
   object ContextualMethodType extends MethodTypeCompanion("ContextualMethodType")
-  class ErasedContextualMethodType(erasedParams: List[Boolean]) extends ErasedMethodCompanion("ContextualMethodType", erasedParams)
   object ImplicitMethodType extends MethodTypeCompanion("ImplicitMethodType")
-  class ErasedImplicitMethodType(erasedParams: List[Boolean]) extends ErasedMethodCompanion("ImplicitMethodType", erasedParams)
 
   /** A ternary extractor for MethodType */
   object MethodTpe {
@@ -5289,7 +5254,10 @@ object Types {
     override def stripTypeVar(using Context): Type =
       derivedAnnotatedType(parent.stripTypeVar, annot)
 
-    override def stripAnnots(using Context): Type = parent.stripAnnots
+    override def stripAnnots(keep: Annotation => (Context) ?=> Boolean)(using Context): Type =
+      val p = parent.stripAnnots(keep)
+      if keep(annot) then derivedAnnotatedType(p, annot)
+      else p
 
     override def stripped(using Context): Type = parent.stripped
 

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
@@ -288,7 +287,6 @@ class TreePickler(pickler: TastyPickler) {
       var mods = EmptyFlags
       if tpe.isContextualMethod then mods |= Given
       else if tpe.isImplicitMethod then mods |= Implicit
-      if tpe.hasErasedParams then mods |= Erased
       pickleMethodic(METHODtype, tpe, mods)
     case tpe: ParamRef =>
       assert(pickleParamRef(tpe), s"orphan parameter reference: $tpe")
@@ -303,10 +301,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)
     }
   }