Check realizability of parameters of an erased function

... instead of checking every instantiated instance of erasedValue[T].
I think this is the better solution, since erasedValue have uses outside
of erasedDefinitions (i.e. in inlining) which has their own realizability checks
as well. We don't have to be pessimistic in those cases.

Author: natsukagami

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

@@ -307,6 +307,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
               tpd.cpy.Apply(tree)(
                 tree.fun,
                 tree.args.mapConserve(arg =>
+                  Checking.checkRealizable(arg.tpe, arg.srcPos, "erased argument")
                   if (methType.isImplicitMethod && arg.span.isSynthetic)
                     arg match
                       case _: RefTree | _: Apply | _: TypeApply if arg.symbol.is(Erased) =>
@@ -349,10 +350,6 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
           if (fn.symbol != defn.ChildAnnot.primaryConstructor)
             // Make an exception for ChildAnnot, which should really have AnyKind bounds
             Checking.checkBounds(args, fn.tpe.widen.asInstanceOf[PolyType])
-          if fn.symbol eq defn.Compiletime_erasedValue then
-            // Check the instantiated type of erasedValue for realizibility
-            for arg <- args do
-                Checking.checkRealizable(arg.tpe, arg.srcPos, "type application of erasedValue")
 
           fn match {
             case sel: Select =>

tests/neg-custom-args/erased/i4060.scala

@@ -7,7 +7,7 @@ object App {
   def upcast(erased a: A)(x: Any): a.L = x
   //lazy val p: A { type L <: Nothing } = p
   erased val p: A { type L <: Nothing } = p // error
-  def coerce(x: Any): Int = upcast(p)(x)
+  def coerce(x: Any): Int = upcast(p)(x) // error
 
   def coerceInline(x: Any): Int = upcast(compiletime.erasedValue[A {type L <: Nothing}])(x) // error