By-name parameters are not stable values.

Author: odersky

Diff for: src/dotty/tools/dotc/core/CheckRealizable.scala

@@ -58,10 +58,12 @@ class CheckRealizable(implicit ctx: Context) {
    */
   private val checkedFields: mutable.Set[Symbol] = mutable.LinkedHashSet[Symbol]()
 
-  /** Is this type a path with some part that is initialized on use? */
+  /** Is this type a path with some part that is initialized on use?
+   *  (note we exclude modules here, because their realizability is ensured separately).
+   */
   private def isLateInitialized(tp: Type): Boolean = tp.dealias match {
     case tp: TermRef =>
-      tp.symbol.isLateInitialized || isLateInitialized(tp.prefix)
+      tp.symbol.is(Lazy, butNot = Module) || isLateInitialized(tp.prefix)
     case _: SingletonType | NoPrefix =>
       false
     case tp: TypeRef =>
@@ -130,8 +132,8 @@ class CheckRealizable(implicit ctx: Context) {
       }
     if (ctx.settings.strict.value)
       // check fields only under strict mode for now.
-      // Reason: We do track nulls, so an embedded field could well be nullable
-      // which means it is not a path and need not be checked; but we cannot recognize
+      // Reason: An embedded field could well be nullable, which means it
+      // should not be part of a path and need not be checked; but we cannot recognize
       // this situation until we have a typesystem that tracks nullability.
       ((Realizable: Realizability) /: tp.fields)(checkField)
     else

Diff for: src/dotty/tools/dotc/core/SymDenotations.scala

@@ -521,13 +521,7 @@ object SymDenotations {
 
     /** Is this a denotation of a stable term (or an arbitrary type)? */
     final def isStable(implicit ctx: Context) =
-      isType || !is(UnstableValue, butNot = Stable)
-
-    /** Field is initialized on use, not on definition;
-     *  we do not count modules as fields here.
-     */
-    final def isLateInitialized(implicit ctx: Context) =
-      is(Lazy, butNot = Module) || is(Param) && info.isInstanceOf[ExprType]
+      isType || is(Stable) || !(is(UnstableValue) || info.isInstanceOf[ExprType])
 
     /** Is this a "real" method? A real method is a method which is:
      *  - not an accessor

Diff for: test/dotc/tests.scala

@@ -162,9 +162,9 @@ class tests extends CompilerTest {
   @Test def neg_i803 = compileFile(negDir, "i803", xerrors = 2)
   @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", List("-strict"), xerrors = 13)
+  @Test def neg_i1050 = compileFile(negDir, "i1050", List("-strict"), xerrors = 11)
   @Test def neg_i1050a = compileFile(negDir, "i1050a", xerrors = 2)
-  @Test def neg_i1050c = compileFile(negDir, "i1050c", xerrors = 4)
+  @Test def neg_i1050c = compileFile(negDir, "i1050c", xerrors = 8)
   @Test def neg_moduleSubtyping = compileFile(negDir, "moduleSubtyping", xerrors = 4)
   @Test def neg_escapingRefs = compileFile(negDir, "escapingRefs", xerrors = 2)
   @Test def neg_instantiateAbstract = compileFile(negDir, "instantiateAbstract", xerrors = 8)

Diff for: tests/neg/i1050.scala

@@ -80,20 +80,6 @@ object Tiark3 {
     val v = new V {}
     v.brand("boom!"): Nothing
 }
-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 }

Diff for: tests/neg/i1050c.scala

@@ -29,3 +29,24 @@ object Tiark4 {
 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 Tiark7 {
+    trait A { type L <: Nothing }
+    trait B { type L >: Any }
+    def f(x: => B)(y: Any):x.L = y // error: x is not stable
+    def f1(x: => A & B)(y: Any):Nothing = f(x)(y) // error: type mismatch
+    f1(???)("boom!"): Nothing
+}