Change how erased classes are treated as erased arguments

Parameters that are erased classes are now marked `erased` at Typer phase (with an annotation),
and in later phases, they are not taken into account when considering erasedness.

Author: natsukagami

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

@@ -12,6 +12,7 @@ import transform.Recheck.*
 import CaptureSet.IdentityCaptRefMap
 import Synthetics.isExcluded
 import util.Property
+import dotty.tools.dotc.core.Annotations.Annotation
 
 /** A tree traverser that prepares a compilation unit to be capture checked.
  *  It does the following:
@@ -259,7 +260,11 @@ 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)
+      defn.FunctionOf(
+        AnnotatedType(defn.CanThrowClass.typeRef.appliedTo(exc), Annotation(defn.ErasedParamAnnot, defn.CanThrowClass.span)) :: Nil,
+        res,
+        isContextual = true
+      )
     case _ => tp
 
   private def expandThrowsAliases(using Context) = new TypeMap:

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

@@ -3920,7 +3920,7 @@ object Types {
       companion.eq(ContextualMethodType)
 
     override def erasedParams(using Context): List[Boolean] =
-      paramInfos.map(p => p.hasAnnotation(defn.ErasedParamAnnot) || p.isErasedClass)
+      paramInfos.map(p => p.hasAnnotation(defn.ErasedParamAnnot))
 
     protected def prefixString: String = companion.prefixString
   }

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

@@ -1349,6 +1349,12 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       val mt = appDef.symbol.info.asInstanceOf[MethodType]
       if (mt.isParamDependent)
         report.error(em"$mt is an illegal function type because it has inter-parameter dependencies", tree.srcPos)
+      // Restart typechecking if there are erased classes that we want to mark erased
+      if mt.erasedParams.zip(mt.paramInfos.map(_.isErasedClass)).exists((paramErased, classErased) => classErased && !paramErased) then
+        val newParams = params3.zipWithConserve(mt.paramInfos.map(_.isErasedClass)) { (arg, isErasedClass) =>
+          if isErasedClass then arg.withAddedFlags(Erased) else arg
+        }
+        return typedDependent(newParams)
       val resTpt = TypeTree(mt.nonDependentResultApprox).withSpan(body.span)
       val typeArgs = appDef.termParamss.head.map(_.tpt) :+ resTpt
       val core =

tests/pos-custom-args/erased/erased-class-as-args.scala

@@ -0,0 +1,22 @@
+erased class A
+
+erased class B(val x: Int) extends A
+
+type T = (x: A, y: Int) => Int
+
+type TSub[-T <: A] = (erased x: T, y: Int) => Int
+
+def useT(f: T) = f(new A, 5)
+
+def useTSub(f: TSub[B]) = f(new B(5), 5)
+
+@main def Test() =
+  val tInfer = (x: A, y: Int) => y + 1
+  val tExpl: T = (x, y) => y + 1
+  assert(useT((erased x, y) => y + 1) == 6)
+  assert(useT(tInfer) == 6)
+  assert(useT(tExpl) == 6)
+
+  val tSub: TSub[A] = (x, y) => y + 1
+  assert(useT(tSub) == 6)
+  assert(useTSub(tSub) == 6)