Don't treat erased as late initialized

Since we will force erased expressions to be pure values, they are always
initialized.

Author: odersky

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

@@ -48,8 +48,6 @@ object CheckRealizable {
 
   def boundsRealizability(tp: Type)(using Context): Realizability =
     new CheckRealizable().boundsRealizability(tp)
-
-  private val LateInitializedFlags = Lazy | Erased
 }
 
 /** Compute realizability status.
@@ -72,7 +70,7 @@ class CheckRealizable(using Context) {
   /** Is symbol's definitition a lazy or erased val?
    *  (note we exclude modules here, because their realizability is ensured separately)
    */
-  private def isLateInitialized(sym: Symbol) = sym.isOneOf(LateInitializedFlags, butNot = Module)
+  private def isLateInitialized(sym: Symbol) = sym.is(Lazy, butNot = Module)
 
   /** The realizability status of given type `tp`*/
   def realizability(tp: Type): Realizability = tp.dealias match {
@@ -184,7 +182,7 @@ class CheckRealizable(using Context) {
   private def memberRealizability(tp: Type) = {
     def checkField(sofar: Realizability, fld: SingleDenotation): Realizability =
       sofar andAlso {
-        if (checkedFields.contains(fld.symbol) || fld.symbol.isOneOf(Private | Mutable | LateInitializedFlags))
+        if (checkedFields.contains(fld.symbol) || fld.symbol.isOneOf(Private | Mutable | Lazy))
           // if field is private it cannot be part of a visible path
           // if field is mutable it cannot be part of a path
           // if field is lazy or erased it does not need to be initialized when the owning object is

tests/neg/erased-path.scala

@@ -6,6 +6,6 @@ trait Obj {
   erased val s: Sys
   lazy val t: Sys
 
-  type S = s.X  // error: not a legal path, since nonfinal
+  type S = s.X  // now OK, was error: not a legal path, since nonfinal
   type T = t.X  // error: not a legal path, since nonfinal
 }

tests/neg/i4060.scala

@@ -6,15 +6,15 @@ object App {
   trait A { type L >: Any}
   def upcast(erased a: A)(x: Any): a.L = x
   erased val p: A { type L <: Nothing } = p
-  def coerce(x: Any): Int = upcast(p)(x) // error
+  def coerce(x: Any): Int = upcast(p)(x) // ok?
 
   def coerceInline(x: Any): Int = upcast(compiletime.erasedValue[A {type L <: Nothing}])(x) // error
 
   trait B { type L <: Nothing }
   def upcast_dep_parameter(erased a: B)(x: a.L) : Int = x
   erased val q : B { type L >: Any } = compiletime.erasedValue
 
-  def coerceInlineWithB(x: Any): Int = upcast_dep_parameter(q)(x) // error
+  def coerceInlineWithB(x: Any): Int = upcast_dep_parameter(q)(x) // ok?
 
   def main(args: Array[String]): Unit = {
     println(coerce("Uh oh!"))

tests/neg/erased-24.scala renamed to tests/pos/erased-24.scala

@@ -12,8 +12,8 @@ object Test {
     null.asInstanceOf[foo.X] // ok
   }
 
-  def fun2(erased foo: Foo)(erased bar: foo.B): bar.X = { // error
-    null.asInstanceOf[bar.X] // error
+  def fun2(erased foo: Foo)(erased bar: foo.B): bar.X = { // was error
+    null.asInstanceOf[bar.X] // was error
   }
 }
 

tests/neg/erased-pathdep-1.scala renamed to tests/pos/erased-pathdep-1.scala

@@ -1,16 +1,14 @@
 //> using options -language:experimental.erasedDefinitions
 
-// Could become a neg test if we had totality checking for erased arguments
-
 object Test {
 
   fun1(new Bar)
   val _ = fun2(new Bar)
   val _ = fun3(new Bar)
 
-  def fun1[F >: Bar <: Foo](erased f: F): f.X = null.asInstanceOf[f.X] // error // error
-  def fun2[F >: Bar <: Foo](erased f: F)(erased bar: f.B): f.B = null.asInstanceOf[f.B] // error // error // error
-  def fun3[F >: Bar <: Foo](erased f: F)(erased b: f.B): b.X = null.asInstanceOf[b.X] // error // error // error
+  def fun1[F >: Bar <: Foo](erased f: F): f.X = null.asInstanceOf[f.X]
+  def fun2[F >: Bar <: Foo](erased f: F)(erased bar: f.B): f.B = null.asInstanceOf[f.B]
+  def fun3[F >: Bar <: Foo](erased f: F)(erased b: f.B): b.X = null.asInstanceOf[b.X]
 }
 
 class Foo {

tests/neg/erased-pathdep-2.scala renamed to tests/pos/erased-pathdep-2.scala

@@ -7,8 +7,8 @@ object Test {
   type F >: Bar <: Foo
 
   class A(erased val f: F) {
-    type F1 <: f.X // error
-    type F2[Z <: f.X] // error
+    type F1 <: f.X // was error
+    type F2[Z <: f.X] // was error
   }
 
 }

tests/neg/erased-singleton.scala renamed to tests/pos/erased-singleton.scala

@@ -5,5 +5,5 @@ trait Sys
 trait Obj {
   erased val s: Sys
 
-  type S = s.type  // error: non final
+  type S = s.type  // now OK, was error: non final
 }