Use erasedParams instead of continuously unwrapping

Author: natsukagami

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

@@ -270,18 +270,14 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
           else makeSym(origInfo)
         end valueParam
 
-        val erasedParams = if tp.isErasedMethod
-                             then tp.companion.asInstanceOf[ErasedMethodCompanion].isErased
-                             else List.fill(tp.paramNames.size) { false }
-
         val (vparams: List[TermSymbol], remaining1) =
           if tp.paramNames.isEmpty then (Nil, remaining)
           else remaining match
             case vparams :: remaining1 =>
               assert(vparams.hasSameLengthAs(tp.paramNames) && vparams.head.isTerm)
               (vparams.asInstanceOf[List[TermSymbol]], remaining1)
             case nil =>
-              (tp.paramNames.lazyZip(tp.paramInfos).lazyZip(erasedParams).map(valueParam), Nil)
+              (tp.paramNames.lazyZip(tp.paramInfos).lazyZip(tp.erasedParams).map(valueParam), Nil)
         val (rtp, paramss) = recur(tp.instantiate(vparams.map(_.termRef)), remaining1)
         (rtp, vparams :: paramss)
       case _ =>

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

@@ -1826,8 +1826,7 @@ class Definitions {
 
   /* Returns a list of erased booleans marking whether parameters are erased, for a function type. */
   def erasedFunctionParameters(tp: Type)(using Context): List[Boolean] = tp.dealias match {
-    case RefinedType(parent, nme.apply, mt) if defn.isErasedFunctionType(parent) =>
-      mt.asInstanceOf[MethodType].companion.asInstanceOf[ErasedMethodCompanion].isErased
+    case RefinedType(parent, nme.apply, mt: MethodType) => mt.erasedParams
     case tp if isFunctionType(tp) => List.fill(functionArity(tp)) { false }
     case _ => List()
   }

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

@@ -2119,9 +2119,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
     }
     // Check if methods are erased, then the erased parameters match
     val erasedValid = if tp1.isErasedMethod && tp2.isErasedMethod then
-                        val comp1 = tp1.companion.asInstanceOf[ErasedMethodCompanion]
-                        val comp2 = tp2.companion.asInstanceOf[ErasedMethodCompanion]
-                        comp1.isErased == comp2.isErased
+                        tp1.erasedParams == tp2.erasedParams
                       else !tp1.isErasedMethod && !tp2.isErasedMethod
 
     erasedValid && loop(tp1.paramInfos, tp2.paramInfos)

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

@@ -539,9 +539,8 @@ object TypeErasure {
 
   def eraseErasedFunctionApply(applyInfo: Type)(using Context): Type =
     val erasedFn = applyInfo.asInstanceOf[MethodType]
-    val companion = erasedFn.companion.asInstanceOf[ErasedMethodCompanion]
     val fnType = defn.FunctionType(
-      n = companion.isErased.count(_ == false),
+      n = erasedFn.erasedParams.count(_ == false),
       isErased = false,
       isContextual = erasedFn.isContextualMethod,
     )
@@ -653,7 +652,7 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
       val (names, formals0) = if (tp.isErasedMethod)
         tp.paramNames
           .zip(tp.paramInfos)
-          .zip(tp.companion.asInstanceOf[ErasedMethodCompanion].isErased)
+          .zip(tp.erasedParams)
           .flatMap((p, e) => if e then None else Some(p))
           .unzip
       else (tp.paramNames, tp.paramInfos)

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

@@ -1842,7 +1842,7 @@ object Types {
         val isContextual = mt.isContextualMethod && !ctx.erasedTypes
         val isErased =
           (if mt.isErasedMethod && !ctx.erasedTypes then
-            mt.companion.asInstanceOf[ErasedMethodCompanion].isErased
+            mt.erasedParams
           else List.fill(mt.paramInfos.size) { false }) dropRight dropLast
         val result1 = mt.nonDependentResultApprox match {
           case res: MethodType => res.toFunctionType(isJava)
@@ -3621,6 +3621,8 @@ object Types {
 
     def companion: LambdaTypeCompanion[ThisName, PInfo, This]
 
+    def erasedParams = 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
      *
@@ -3700,7 +3702,7 @@ object Types {
           case tp: MethodType =>
             val params = if (isErasedMethod)
               tp.paramInfos
-                .zip(tp.companion.asInstanceOf[ErasedMethodCompanion].isErased)
+                .zip(tp.erasedParams)
                 .flatMap((p, e) => if e then None else Some(p))
             else tp.paramInfos
             resultSignature.prependTermParams(params, sourceLanguage)
@@ -3918,9 +3920,9 @@ object Types {
       companion.eq(ContextualMethodType) ||
       companion.isInstanceOf[ErasedContextualMethodType]
 
-    def erasedParams: List[Boolean] = companion match
+    override def erasedParams: List[Boolean] = companion match
       case c: ErasedMethodCompanion => c.isErased
-      case _ => paramInfos.map(_ => false)
+      case _ => super.erasedParams
 
     def withoutErased(using Context): MethodType =
       val newCompanion = companion match {

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

@@ -301,9 +301,7 @@ class TreePickler(pickler: TastyPickler) {
     writeByte(tag)
     if tag == ERASEDMETHODtype then
       withLength {
-        tpe.companion.asInstanceOf[ErasedMethodCompanion]
-          .isErased
-          .foreach { isErased => writeByte(if isErased then 1 else 0) }
+        tpe.erasedParams.foreach { isErased => writeByte(if isErased then 1 else 0) }
       }
     withLength {
       pickleType(tpe.resultType, richTypes = true)

compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -296,10 +296,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
     "(" ~ toTextRef(tp) ~ " : " ~ toTextGlobal(tp.underlying) ~ ")"
 
   protected def paramsText(lam: LambdaType): Text = {
-    val companion = lam.companion
-    val isErased = if companion.isInstanceOf[ErasedMethodCompanion] then
-        companion.asInstanceOf[ErasedMethodCompanion].isErased
-      else List.fill(lam.paramNames.length)(false)
+    val isErased = lam.erasedParams
     def paramText(name: Name, tp: Type, erased: Boolean) =
       keywordText("erased ").provided(erased) ~ toText(name) ~ lambdaHash(lam) ~ toTextRHS(tp, isParameter = true)
     Text(lam.paramNames.lazyZip(lam.paramInfos).lazyZip(isErased).map(paramText), ", ")

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

@@ -93,7 +93,7 @@ object ContextFunctionResults:
       case mt @ MethodType(pnames) =>
         val rest = normalParamCount(mt.resType)
         if mt.isErasedMethod then
-          mt.companion.asInstanceOf[ErasedMethodCompanion].isErased.count(_ == false) + rest
+          mt.erasedParams.count(_ == false) + rest
         else pnames.length + rest
       case _ => contextParamCount(tp, contextResultCount(sym))
 

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

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

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

@@ -312,7 +312,7 @@ object GenericSignatures {
           // 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 =>
-              t.paramInfos.zip(t.companion.asInstanceOf[ErasedMethodCompanion].isErased)
+              t.paramInfos.zip(t.erasedParams)
                 .flatMap((i, e) => if e then None else Some(i))
                 :: effectiveParamInfoss(t.resType)
             case t: MethodType => t.paramInfos :: effectiveParamInfoss(t.resType)

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

@@ -299,7 +299,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
             if (methType.isErasedMethod)
               tpd.cpy.Apply(tree)(
                 tree.fun,
-                tree.args.zip(methType.companion.asInstanceOf[ErasedMethodCompanion].isErased).map((arg, isErased) =>
+                tree.args.zip(methType.erasedParams).map((arg, isErased) =>
                   if !isErased then arg
                   else
                     if methType.isResultDependent then

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

@@ -42,8 +42,8 @@ class PruneErasedDefs extends MiniPhase with SymTransformer { thisTransform =>
   override def transformApply(tree: Apply)(using Context): Tree =
     if !tree.fun.tpe.widen.isErasedMethod then tree
     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))
+      val erasedParams = tree.fun.tpe.widen.asInstanceOf[MethodType].erasedParams
+      cpy.Apply(tree)(tree.fun, tree.args.zip(erasedParams).map((a, e) => if e then trivialErasedTree(a) else a))
 
   override def transformValDef(tree: ValDef)(using Context): Tree =
     checkErasedInExperimental(tree.symbol)

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -1219,7 +1219,6 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     }
 
     val pt1 = pt.strippedDealias.normalized
-    // println(s"\tpt = ${pt1.show}\n\tdropped refinement = ${pt1.dropDependentRefinement.dealias.show}\n\tarity = $defaultArity")
     if (pt1 ne pt1.dropDependentRefinement)
        && defn.isContextFunctionType(pt1.nonPrivateMember(nme.apply).info.finalResultType)
        && pt1.nonPrivateMember(nme.apply).info.asInstanceOf[MethodType].isResultDependent
@@ -3031,10 +3030,8 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       else formals.map(untpd.TypeTree)
     }
 
-    val erasedParams = pt match {
-      case RefinedType(parent, nme.apply, mt) if defn.isErasedFunctionType(parent) =>
-        val companion = mt.asInstanceOf[MethodType].companion.asInstanceOf[ErasedMethodCompanion]
-        companion.isErased
+    val erasedParams = pt.dealias match {
+      case RefinedType(parent, nme.apply, mt: MethodType) => mt.erasedParams
       case _ => paramTypes.map(_ => false)
     }