Create classes for erased method companions

Extends the original idea of having `Erased...MethodCompanion` as objects,
we now have `Erased...MethodCompanion` classes, with each instance holding
a bool array of erased/non-erased marker for its parameters.

Some functions now take a `List[Boolean]` for `isErased` parameter,
but this is largely WIP and only for making the compiler compiles. :P

Those with obviously temporary patches are marked `// TODO @natsukagami`,
mostly related to erased function types.

Author: natsukagami

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

@@ -146,7 +146,7 @@ extension (tp: Type)
       defn.FunctionType(
         fname.functionArity,
         isContextual = fname.isContextFunction,
-        isErased = fname.isErasedFunction,
+        isErased = fname.isErasedFunction, // TODO @natsukagami fix this
         isImpure = true).appliedTo(args)
     case _ =>
       tp

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

@@ -612,7 +612,8 @@ class CheckCaptures extends Recheck, SymTransformer:
       super.checkConformsExpr(actual1, expected1, tree)
 
     private def toDepFun(args: List[Type], resultType: Type, isContextual: Boolean, isErased: Boolean)(using Context): Type =
-      MethodType.companion(isContextual = isContextual, isErased = isErased)(args, resultType)
+      val erasedParams = args.map(_ => isErased) // TODO @natsukagami fix
+      MethodType.companion(isContextual = isContextual, isErased = erasedParams)(args, resultType)
         .toFunctionType(isJava = false, alwaysDependent = true)
 
     /** Turn `expected` into a dependent function when `actual` is dependent. */

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

@@ -150,7 +150,7 @@ class Definitions {
           val methodType = MethodType.companion(
             isContextual = name.isContextFunction,
             isImplicit = false,
-            isErased = name.isErasedFunction)
+            isErased = List(name.isErasedFunction)) // TODO @natsukagami fix this
           decls.enter(newMethod(cls, nme.apply, methodType(argParamRefs, resParamRef), Deferred))
           denot.info =
             ClassInfo(ScalaPackageClass.thisType, cls, ObjectType :: Nil, decls)
@@ -1506,7 +1506,7 @@ class Definitions {
    *   - ErasedFunctionN for N > 0
    *   - ErasedContextFunctionN for N > 0
    */
-  def isErasedFunctionClass(cls: Symbol): Boolean = scalaClassName(cls).isErasedFunction
+  def isErasedFunctionClass(cls: Symbol): List[Boolean] = List(scalaClassName(cls).isErasedFunction) // TODO @natsukagami fix this
 
   /** Is either FunctionXXL or  a class that will be erased to FunctionXXL
    *   - FunctionXXL
@@ -1799,18 +1799,19 @@ class Definitions {
    *  types `As`, the result type `B` and a whether the type is an erased context function.
    */
   object ContextFunctionType:
-    def unapply(tp: Type)(using Context): Option[(List[Type], Type, Boolean)] =
+    def unapply(tp: Type)(using Context): Option[(List[Type], Type, List[Boolean])] =
       if ctx.erasedTypes then
         atPhase(erasurePhase)(unapply(tp))
       else
         val tp1 = asContextFunctionType(tp)
         if tp1.exists then
           val args = tp1.dropDependentRefinement.argInfos
-          Some((args.init, args.last, tp1.typeSymbol.name.isErasedFunction))
+          Some((args.init, args.last, List(tp1.typeSymbol.name.isErasedFunction))) // TODO @natsukagami fix this
         else None
 
   def isErasedFunctionType(tp: Type)(using Context): Boolean =
-    tp.dealias.typeSymbol.name.isErasedFunction && isFunctionType(tp)
+    false // TODO @natsukagami fix this
+    // tp.dealias.typeSymbol.name.isErasedFunction && isFunctionType(tp)
 
   /** A whitelist of Scala-2 classes that are known to be pure */
   def isAssuredNoInits(sym: Symbol): Boolean =

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

@@ -208,7 +208,15 @@ object NameOps {
             if str == mustHave then found = true
             idx + str.length
           else idx
-        skip(skip(skip(0, "Impure"), "Erased"), "Context") == suffixStart
+        def skipErased(idx: Int) =
+          val erased = "Erased"
+          if first.startsWith(erased, idx) then
+            var ptr = idx + erased.length
+            while first(ptr) != 'X' do { ptr += 1 }
+            ptr + 1
+          else idx
+        
+        skip(skipErased(skip(0, "Impure")), "Context") == suffixStart
         && found
       }
 
@@ -235,7 +243,7 @@ object NameOps {
       isFunctionPrefix(suffixStart, mustHave) && funArity(suffixStart) >= 0
 
     def isContextFunction(using Context): Boolean = isSpecificFunction("Context")
-    def isErasedFunction(using Context): Boolean = isSpecificFunction("Erased")
+    def isErasedFunction(using Context): Boolean = isSpecificFunction("Erased") // TODO @natsukagami change this
     def isImpureFunction(using Context): Boolean = isSpecificFunction("Impure")
 
     /** Is a synthetic function name, i.e. one of

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

@@ -43,8 +43,8 @@ object NamerOps:
         resultType
       case TermSymbols(params) :: paramss1 =>
         val (isContextual, isImplicit, isErased) =
-          if params.isEmpty then (false, false, false)
-          else (params.head.is(Given), params.head.is(Implicit), params.head.is(Erased))
+          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, isErased = isErased)
         if isJava then
           for param <- params do

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

@@ -3899,15 +3899,15 @@ object Types {
 
     final override def isImplicitMethod: Boolean =
       companion.eq(ImplicitMethodType) ||
-      companion.eq(ErasedImplicitMethodType) ||
+      companion.isInstanceOf[ErasedImplicitMethodType] ||
       isContextualMethod
     final override def isErasedMethod: Boolean =
-      companion.eq(ErasedMethodType) ||
-      companion.eq(ErasedImplicitMethodType) ||
-      companion.eq(ErasedContextualMethodType)
+      companion.isInstanceOf[ErasedMethodType] ||
+      companion.isInstanceOf[ErasedImplicitMethodType] ||
+      companion.isInstanceOf[ErasedContextualMethodType]
     final override def isContextualMethod: Boolean =
       companion.eq(ContextualMethodType) ||
-      companion.eq(ErasedContextualMethodType)
+      companion.isInstanceOf[ErasedContextualMethodType]
 
     protected def prefixString: String = companion.prefixString
   }
@@ -4019,19 +4019,22 @@ object Types {
   }
 
   object MethodType extends MethodTypeCompanion("MethodType") {
-    def companion(isContextual: Boolean = false, isImplicit: Boolean = false, isErased: Boolean = false): MethodTypeCompanion =
+    def companion(isContextual: Boolean = false, isImplicit: Boolean = false, isErased: List[Boolean] = List()): MethodTypeCompanion =
+      val hasErased = isErased.exists(_ == true)
       if (isContextual)
-        if (isErased) ErasedContextualMethodType else ContextualMethodType
+        if (hasErased) ErasedContextualMethodType(isErased) else ContextualMethodType
       else if (isImplicit)
-        if (isErased) ErasedImplicitMethodType else ImplicitMethodType
+        if (hasErased) ErasedImplicitMethodType(isErased) else ImplicitMethodType
       else
-        if (isErased) ErasedMethodType else MethodType
+        if (hasErased) ErasedMethodType(isErased) else MethodType
   }
-  object ErasedMethodType extends MethodTypeCompanion("ErasedMethodType")
+  private def erasedMt(t: String, isErased: List[Boolean]) =
+    s"Erased${t}(${isErased.map(if _ then "erased _" else "_").mkString(", ")})"
+  class ErasedMethodType(val isErased: List[Boolean]) extends MethodTypeCompanion(erasedMt("MethodType", isErased))
   object ContextualMethodType extends MethodTypeCompanion("ContextualMethodType")
-  object ErasedContextualMethodType extends MethodTypeCompanion("ErasedContextualMethodType")
+  class ErasedContextualMethodType(val isErased: List[Boolean]) extends MethodTypeCompanion(erasedMt("ContextualMethodType", isErased))
   object ImplicitMethodType extends MethodTypeCompanion("ImplicitMethodType")
-  object ErasedImplicitMethodType extends MethodTypeCompanion("ErasedImplicitMethodType")
+  class ErasedImplicitMethodType(val isErased: List[Boolean]) extends MethodTypeCompanion(erasedMt("ImplicitMethodType", isErased))
 
   /** A ternary extractor for MethodType */
   object MethodTpe {

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

@@ -402,9 +402,9 @@ class TreeUnpickler(reader: TastyReader,
             case METHODtype =>
               def methodTypeCompanion(mods: FlagSet): MethodTypeCompanion =
                 if mods.is(Implicit) then ImplicitMethodType
-                else if mods.isAllOf(Erased | Given) then ErasedContextualMethodType
+                // 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
+                // else if mods.is(Erased) then ErasedMethodType // TODO @natsukagami handle this
                 else MethodType
               readMethodic(methodTypeCompanion, _.toTermName)
             case TYPELAMBDAtype =>

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

@@ -120,16 +120,17 @@ class PlainPrinter(_ctx: Context) extends Printer {
     }
     (keyword ~ refinementNameString(rt) ~ toTextRHS(rt.refinedInfo)).close
 
-  protected def argText(arg: Type): Text = homogenizeArg(arg) match {
+  protected def argText(arg: Type, isErased: Boolean = false): Text = keywordText("erased ").provided(isErased) ~ (homogenizeArg(arg) match {
     case arg: TypeBounds => "?" ~ toText(arg)
     case arg => toText(arg)
-  }
+  })
 
   /** Pretty-print comma-separated type arguments for a constructor to be inserted among parentheses or brackets
     * (hence with `GlobalPrec` precedence).
     */
-  protected def argsText(args: List[Type]): Text =
-    atPrec(GlobalPrec) { Text(args.map(arg => argText(arg) ), ", ") }
+  protected def argsText(args: List[Type], _erased: List[Boolean] = List()): Text =
+    val erased = _erased.padTo(args.length, false)
+    atPrec(GlobalPrec) { Text(args.zip(erased).map((arg, erased) => argText(arg, erased)), ", ") }
 
   /** The longest sequence of refinement types, starting at given type
    *  and following parents.

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

@@ -147,20 +147,19 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     def toTextTuple(args: List[Type]): Text =
       "(" ~ argsText(args) ~ ")"
 
-    def toTextFunction(args: List[Type], isGiven: Boolean, isErased: Boolean, isPure: Boolean): Text =
+    def toTextFunction(args: List[Type], isGiven: Boolean, isErased: List[Boolean], isPure: Boolean): Text =
       changePrec(GlobalPrec) {
         val argStr: Text =
           if args.length == 2
              && !defn.isTupleNType(args.head)
-             && !isGiven && !isErased
+             && !isGiven
           then
-            atPrec(InfixPrec) { argText(args.head) }
+            atPrec(InfixPrec) { argText(args.head, isErased.headOption.getOrElse(false)) }
           else
             "("
-            ~ keywordText("erased ").provided(isErased)
-            ~ argsText(args.init)
+            ~ argsText(args.init, isErased)
             ~ ")"
-        argStr ~ " " ~ arrow(isGiven, isPure) ~ " " ~ argText(args.last)
+        argStr ~ " " ~ arrow(isGiven, isPure) ~ " " ~ argText(args.last, false)
       }
 
     def toTextMethodAsFunction(info: Type, isPure: Boolean): Text = info match
@@ -225,7 +224,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
             if tycon.isRepeatedParam then toTextLocal(args.head) ~ "*"
             else if tp.isConvertibleParam then "into " ~ toText(args.head)
             else if defn.isFunctionSymbol(tsym) then
-              toTextFunction(args, tsym.name.isContextFunction, tsym.name.isErasedFunction,
+              toTextFunction(args, tsym.name.isContextFunction, List(tsym.name.isErasedFunction) /* TODO @natsukagami fix this */,
                 isPure = Feature.pureFunsEnabled && !tsym.name.isImpureFunction)
             else if isInfixType(tp) then
               val l :: r :: Nil = args: @unchecked

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

@@ -131,7 +131,10 @@ class Bridges(root: ClassSymbol, thisPhase: DenotTransformer)(using Context) {
         else
           val defn.ContextFunctionType(argTypes, resType, isErased) = tp: @unchecked
           val anonFun = newAnonFun(ctx.owner,
-            MethodType(if isErased then Nil else argTypes, resType),
+            MethodType(
+              argTypes.zip(isErased.padTo(argTypes.length, false))
+                      .flatMap((t, e) => if e then List(t) else List()),
+              resType),
             coord = ctx.owner.coord)
           anonFun.info = transformInfo(anonFun, anonFun.info)
 

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

@@ -58,7 +58,7 @@ object ContextFunctionResults:
    */
   def contextResultsAreErased(sym: Symbol)(using Context): Boolean =
     def allErased(tp: Type): Boolean = tp.dealias match
-      case defn.ContextFunctionType(_, resTpe, isErased) => isErased && allErased(resTpe)
+      case defn.ContextFunctionType(_, resTpe, isErased) => isErased.forall(_ == true) && allErased(resTpe)
       case _ => true
     contextResultCount(sym) > 0 && allErased(sym.info.finalResultType)
 
@@ -74,7 +74,7 @@ object ContextFunctionResults:
         tp.derivedLambdaType(resType = integrateContextResults(tp.resType, crCount))
       case defn.ContextFunctionType(argTypes, resType, isErased) =>
         val methodType: MethodTypeCompanion =
-          if isErased then ErasedMethodType else MethodType
+          if isErased.exists(_ == true) then ErasedMethodType(isErased) else MethodType
         methodType(argTypes, integrateContextResults(resType, crCount - 1))
 
   /** The total number of parameters of method `sym`, not counting
@@ -87,7 +87,7 @@ object ContextFunctionResults:
       else
         val defn.ContextFunctionType(params, resTpe, isErased) = tp: @unchecked
         val rest = contextParamCount(resTpe, crCount - 1)
-        if isErased then rest else params.length + rest
+        if isErased.exists(_ == true) then isErased.count(_ == false) + rest else params.length + rest
 
     def normalParamCount(tp: Type): Int = tp.widenExpr.stripPoly match
       case mt @ MethodType(pnames) =>
@@ -133,4 +133,4 @@ object ContextFunctionResults:
       case _ =>
         false
 
-end ContextFunctionResults
+end ContextFunctionResults