Handle paths of length > 1 for realizability checking

Author: odersky

src/dotty/tools/dotc/core/TypeOps.scala

@@ -301,10 +301,31 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
     }
   }
 
+  /** Is this type a path with some part that is initialized on use? */
+  def isLateInitialized(tp: Type): Boolean = tp.dealias match {
+    case tp: TermRef =>
+      tp.symbol.isLateInitialized || isLateInitialized(tp.prefix)
+    case _: SingletonType | NoPrefix =>
+      false
+    case tp: TypeRef =>
+      true
+    case tp: TypeProxy =>
+      isLateInitialized(tp.underlying)
+    case tp: AndOrType =>
+      isLateInitialized(tp.tp1) || isLateInitialized(tp.tp2)
+    case _ =>
+      true
+  }
+
   /** The realizability status of given type `tp`*/
   def realizability(tp: Type): Realizability = tp.dealias match {
     case tp: TermRef =>
-      if (tp.symbol.isRealizable) Realizable
+      if (tp.symbol.isRealizable)
+        if (tp.symbol.isLateInitialized || // we already checked realizability of info in that case
+            !isLateInitialized(tp.prefix)) // symbol was definitely constructed in that case
+          Realizable
+        else
+          realizability(tp.info)
       else if (!tp.symbol.isStable) NotStable
       else if (!tp.symbol.isEffectivelyFinal) new NotFinal(tp.symbol)
       else new ProblemInUnderlying(tp.info, realizability(tp.info))
@@ -335,6 +356,18 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
     }
   }
 
+  /* Might need at some point in the future
+  def memberRealizability(tp: Type)(implicit ctx: Context) = {
+    println(i"check member rel of $tp")
+    def isUnrealizable(fld: SingleDenotation) =
+      !fld.symbol.is(Lazy) && realizability(fld.info) != Realizable
+    tp.fields.find(isUnrealizable) match {
+      case Some(fld) => new HasProblemField(fld)
+      case _ => Realizable
+    }
+  }
+  */
+
   private def enterArgBinding(formal: Symbol, info: Type, cls: ClassSymbol, decls: Scope) = {
     val lazyInfo = new LazyType { // needed so we do not force `formal`.
       def complete(denot: SymDenotation)(implicit ctx: Context): Unit = {
@@ -567,9 +600,14 @@ object TypeOps {
   class NotFinal(sym: Symbol)(implicit ctx: Context)
   extends Realizability(i" refers to nonfinal $sym")
 
-  class HasProblemBounds(mbr: SingleDenotation)(implicit ctx: Context)
-  extends Realizability(i" has a member $mbr with possibly conflicting bounds ${mbr.info.bounds.lo} <: ... <: ${mbr.info.bounds.hi}")
+  class HasProblemBounds(typ: SingleDenotation)(implicit ctx: Context)
+  extends Realizability(i" has a member $typ with possibly conflicting bounds ${typ.info.bounds.lo} <: ... <: ${typ.info.bounds.hi}")
 
+  /* Might need at some point in the future
+  class HasProblemField(fld: SingleDenotation)(implicit ctx: Context)
+  extends Realizability(i" has a member $fld which is uneligible as a path since ${fld.symbol.name}${ctx.realizability(fld.info)}")
+  */
+  
   class ProblemInUnderlying(tp: Type, problem: Realizability)(implicit ctx: Context)
   extends Realizability(i"s underlying type ${tp}${problem.msg}")
 }

test/dotc/tests.scala

@@ -156,7 +156,7 @@ class tests extends CompilerTest {
   @Test def neg_i705 = compileFile(negDir, "i705-inner-value-class", xerrors = 7)
   @Test def neg_i866 = compileFile(negDir, "i866", xerrors = 2)
   @Test def neg_i974 = compileFile(negDir, "i974", xerrors = 2)
-  @Test def neg_i1050 = compileFile(negDir, "i1050", xerrors = 11)
+  @Test def neg_i1050 = compileFile(negDir, "i1050", xerrors = 14)
   @Test def neg_i1050a = compileFile(negDir, "i1050a", xerrors = 2)
   @Test def neg_moduleSubtyping = compileFile(negDir, "moduleSubtyping", xerrors = 4)
   @Test def neg_escapingRefs = compileFile(negDir, "escapingRefs", xerrors = 2)

tests/neg/i1050.scala

@@ -109,3 +109,30 @@ object Import {
 object V { // error: cannot be instantiated
   type Y >: Any <: Nothing  // error: only classes can have declared but undefined members
 }
+object Tiark5 {
+    trait A { type L <: Nothing }
+    trait B { type L >: Any }
+    def f(x: => A & B)(y: Any):Nothing = (y:x.L) // error: underlying conflicting bounds
+    f(???)("boom!")
+}
+object Tiark5Inherited {
+    trait A { type L <: Nothing }
+    trait B { type L >: Any }
+    trait A2 extends A
+    trait B2 extends B
+    def f(x: => A2 & B2)(y: Any):Nothing = (y:x.L) // error: underlying conflicting bounds
+    f(???)("boom!")
+}
+object Tiark6 {
+    trait B { type L >: Any }
+    trait A { type L <: Nothing }
+    trait U {
+      trait X {
+        val q: A & B = ???
+      }
+      final lazy val p: X = ???
+      def brand(x: Any): p.q.L = x // error: conflicting bounds
+    }
+    val v = new U {}
+    v.brand("boom!"): Nothing
+}