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

@@ -301,13 +301,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 =>
-                  Checking.checkRealizable(arg.tpe, arg.srcPos, "erased argument")
+                  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,7 +351,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])
-
           fn match {
             case sel: Select =>
               val args1 = transform(args)
@@ -484,9 +484,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