WIP handle erased classes

Author: natsukagami

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

@@ -1909,18 +1909,22 @@ object desugar {
   }
 
   /** Make erased function definitions use only ValDefs */
-  def makeErasedFunctionValDefs(tree: FunctionWithMods, pt: Type)(using Context): Function = {
-    val isErased = tree.isErased
+  def makeErasedFunctionValDefs(tree: Function, pt: Type)(using Context): Function = {
     val Function(args, result) = tree
+    val flags = tree match
+      case tree: FunctionWithMods => tree.mods.flags
+      case _ => EmptyFlags
     args match {
       case (_ : ValDef) :: _ => tree // ValDef case can be easily handled
-      case _ if !isErased.contains(true) => tree // not erased
       case _ if !ctx.mode.is(Mode.Type) => tree
       case _ =>
         val applyVParams = args.zipWithIndex.map {
-          case (p, n) => makeSyntheticParameter(n + 1, p).withAddedFlags(tree.mods.flags)
+          case (p, n) => makeSyntheticParameter(n + 1, p).withAddedFlags(flags)
         }
-        untpd.FunctionWithMods(applyVParams, tree.body, tree.mods, isErased)
+        tree match
+          case tree: FunctionWithMods =>
+            untpd.FunctionWithMods(applyVParams, tree.body, tree.mods, tree.isErased)
+          case _ => untpd.Function(applyVParams, result)
     }
   }
 

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

@@ -1097,7 +1097,7 @@ class Definitions {
       val fnType =
         FunctionType(args.length, isContextual, isErased = isErasedFn).appliedTo(args ::: resultType :: Nil)
       if isErasedFn then
-        val mt = MethodType.companion(isContextual, false, isErased)(args, resultType)
+        val mt = MethodType.companion(isContextual, false, erasedParams)(args, resultType)
         RefinedType(fnType, nme.apply, mt)
       else fnType
     def unapply(ft: Type)(using Context): Option[(List[Type], Type, Boolean, List[Boolean])] = {

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

@@ -24,6 +24,8 @@ import util.common._
 import typer.ProtoTypes.NoViewsAllowed
 import collection.mutable.ListBuffer
 
+import reporting._
+
 /** Denotations represent the meaning of symbols and named types.
  *  The following diagram shows how the principal types of denotations
  *  and their denoting entities relate to each other. Lines ending in
@@ -542,11 +544,7 @@ object Denotations {
         tp2 match
           case tp2: MethodType
           if TypeComparer.matchingMethodParams(tp1, tp2)
-             && tp1.isImplicitMethod == tp2.isImplicitMethod
-             && tp1.isErasedMethod == tp2.isErasedMethod
-             && (!tp1.isErasedMethod || ( // same set of erased parameters
-              tp1.companion.asInstanceOf[ErasedMethodCompanion].isErased ==
-              tp2.companion.asInstanceOf[ErasedMethodCompanion].isErased)) =>
+             && tp1.isImplicitMethod == tp2.isImplicitMethod =>
             val resType = infoMeet(tp1.resType, tp2.resType.subst(tp2, tp1), safeIntersection)
             if resType.exists then
               tp1.derivedLambdaType(mergeParamNames(tp1, tp2), tp1.paramInfos, resType)

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

@@ -43,6 +43,7 @@ import scala.annotation.internal.sharable
 import scala.annotation.threadUnsafe
 
 import dotty.tools.dotc.transform.SymUtils._
+import dotty.tools.dotc.transform.TypeUtils.isErasedClass
 
 object Types {
 
@@ -3926,6 +3927,26 @@ object Types {
       }
       newCompanion(paramNames)(paramInfosExp, resultTypeExp)
 
+    // 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 isErased = c.isErased.zipWithConserve(isErasedClass) { (a, b) => a || b }
+          if isErased == c.isErased then this
+          else MethodType.companion(
+              isContextual = isContextualMethod,
+              isImplicit = isImplicitMethod,
+              isErased = isErased
+            )(paramNames)(paramInfosExp, resultTypeExp)
+        case _ =>
+          MethodType.companion(
+              isContextual = isContextualMethod,
+              isImplicit = isImplicitMethod,
+              isErased = isErasedClass
+            )(paramNames)(paramInfosExp, resultTypeExp)
+      else this
+
     protected def prefixString: String = companion.prefixString
   }
 
@@ -4047,7 +4068,7 @@ object Types {
   }
   private def erasedMt(t: String, isErased: List[Boolean]) =
     s"Erased${t}(${isErased.map(if _ then "erased _" else "_").mkString(", ")})"
-  class ErasedMethodCompanion(prefixString: String, val isErased: List[Boolean])
+  sealed abstract class ErasedMethodCompanion(prefixString: String, val isErased: List[Boolean])
     extends MethodTypeCompanion(erasedMt(prefixString, isErased))
 
   class ErasedMethodType(isErased: List[Boolean]) extends ErasedMethodCompanion("MethodType", isErased)

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

@@ -1301,7 +1301,6 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     val numArgs = args.length
     val isContextual = funFlags.is(Given)
     val isImpure = funFlags.is(Impure)
-    val funSym = defn.FunctionSymbol(numArgs, isContextual, isErased.contains(true), isImpure)
 
     /** Typechecks dependent function type with given parameters `params` */
     def typedDependent(params: List[untpd.ValDef])(using Context): Tree =
@@ -1322,9 +1321,10 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       val appDef0 = untpd.DefDef(nme.apply, List(params3), body, EmptyTree).withSpan(tree.span)
       index(appDef0 :: Nil)
       val appDef = typed(appDef0).asInstanceOf[DefDef]
-      val mt = appDef.symbol.info.asInstanceOf[MethodType]
+      val mt = appDef.symbol.info.asInstanceOf[MethodType].markErasedClasses
       if (mt.isParamDependent)
         report.error(em"$mt is an illegal function type because it has inter-parameter dependencies", tree.srcPos)
+      val funSym = defn.FunctionSymbol(numArgs, isContextual, mt.isErasedMethod, isImpure)
       val resTpt = TypeTree(mt.nonDependentResultApprox).withSpan(body.span)
       val typeArgs = appDef.termParamss.head.map(_.tpt) :+ resTpt
       val tycon = TypeTree(funSym.typeRef)
@@ -1338,12 +1338,15 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           using ctx.fresh.setOwner(newRefinedClassSymbol(tree.span)).setNewScope)
       case _ =>
         if isErased.contains(true) then
-          typedFunctionType(
-            desugar.makeErasedFunctionValDefs(tree.asInstanceOf[untpd.FunctionWithMods], pt),
-            pt
-          )
+          typedFunctionType(desugar.makeErasedFunctionValDefs(tree, pt), pt)
         else
-          typed(cpy.AppliedTypeTree(tree)(untpd.TypeTree(funSym.typeRef), args :+ body), pt)
+          val funSym = defn.FunctionSymbol(numArgs, isContextual, false, isImpure)
+          val result = typed(cpy.AppliedTypeTree(tree)(untpd.TypeTree(funSym.typeRef), args :+ body), pt)
+          // if there are any erased classes, we need to re-do the typecheck.
+          result match
+            case r: AppliedTypeTree if r.args.exists(_.tpe.isErasedClass) =>
+              typedFunctionType(desugar.makeErasedFunctionValDefs(tree, pt), pt)
+            case _ => result
     }
   }