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.

- Only check for realizability for erased parameters of result-dependent functions.
  Per talk with @odersky, it seems that it is enough to check for
  realizability of parameters of a dependent function in order to avoid
  unsoundness.

Note that the following actions have already been checked for,
with erased parameters:
- Using them as a dependent path in casting / variable definitions
- Using them as the input to an `inline match`

The check previously performed on `val`/`def` definitions are also
removed, so we are as liberal as possible, to avoid too much restriction.

I think with this, we can also remove the special case for `compiletime.erasedValue`.

Author: natsukagami

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

@@ -302,12 +302,14 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
             checkNoConstructorProxy(tree)
             transformSelect(tree, Nil)
         case tree: Apply =>
-          val methType = tree.fun.tpe.widen
+          val methType = tree.fun.tpe.widen.asInstanceOf[MethodType]
           val app =
             if (methType.isErasedMethod)
               tpd.cpy.Apply(tree)(
                 tree.fun,
                 tree.args.mapConserve(arg =>
+                  if methType.isResultDependent then
+                    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) =>
@@ -350,11 +352,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 =>
               val args1 = transform(args)
@@ -489,9 +486,6 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
     private def checkErasedDef(tree: ValOrDefDef)(using Context): Unit =
       if tree.symbol.is(Erased, butNot = Macro) then
         val tpe = tree.rhs.tpe
-        if !tree.symbol.isOneOf(TermParamOrAccessor) && !tree.symbol.eq(defn.Compiletime_erasedValue) then // Only need to check non-parameters, since parameters have their own path checks.
-            // We want all erased definitions to have a realizable type
-            Checking.checkRealizable(tree.tpt.tpe, tree.srcPos, "erased type")
         if tpe.derivesFrom(defn.NothingClass) then
           report.error("`erased` definition cannot be implemented with en expression of type Nothing", tree.srcPos)
         else if tpe.derivesFrom(defn.NullClass) then

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