Fix #4098: Check that refinements have good bounds

So far, we did the check only for member symbols. We have to do the same thing
for type refinements that do not refer to a member.

Author: odersky

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

@@ -30,8 +30,8 @@ object CheckRealizable {
   class NotFinal(sym: Symbol)(implicit ctx: Context)
   extends Realizability(i" refers to nonfinal $sym")
 
-  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}")
+  class HasProblemBounds(name: Name, info: Type)(implicit ctx: Context)
+  extends Realizability(i" has a member $name with possibly conflicting bounds ${info.bounds.lo} <: ... <: ${info.bounds.hi}")
 
   class HasProblemBaseArg(typ: Type, argBounds: TypeBounds)(implicit ctx: Context)
   extends Realizability(i" has a base type $typ with possibly conflicting parameter bounds ${argBounds.lo} <: ... <: ${argBounds.hi}")
@@ -96,6 +96,14 @@ class CheckRealizable(implicit ctx: Context) {
       else boundsRealizability(tp).andAlso(memberRealizability(tp))
   }
 
+  private def refinedNames(tp: Type): Set[Name] = tp.dealias match {
+    case tp: RefinedType => refinedNames(tp.parent) + tp.refinedName
+    case tp: AndType => refinedNames(tp.tp1) ++ refinedNames(tp.tp2)
+    case tp: OrType  => refinedNames(tp.tp1) ++ refinedNames(tp.tp2)
+    case tp: TypeProxy => refinedNames(tp.underlying)
+    case _ => Set.empty
+  }
+
   /** `Realizable` if `tp` has good bounds, a `HasProblem...` instance
    *  pointing to a bad bounds member otherwise. "Has good bounds" means:
    *
@@ -107,12 +115,21 @@ class CheckRealizable(implicit ctx: Context) {
    *       also lead to base types with bad bounds).
    */
   private def boundsRealizability(tp: Type) = {
-    val mbrProblems =
+
+    val memberProblems =
       for {
         mbr <- tp.nonClassTypeMembers
         if !(mbr.info.loBound <:< mbr.info.hiBound)
       }
-      yield new HasProblemBounds(mbr)
+      yield new HasProblemBounds(mbr.name, mbr.info)
+
+    val refinementProblems =
+      for {
+        name <- refinedNames(tp)
+        mbr <- tp.member(name).alternatives
+        if !(mbr.info.loBound <:< mbr.info.hiBound)
+      }
+      yield new HasProblemBounds(name, mbr.info)
 
     def baseTypeProblems(base: Type) = base match {
       case AndType(base1, base2) =>
@@ -126,12 +143,13 @@ class CheckRealizable(implicit ctx: Context) {
     val baseProblems =
       tp.baseClasses.map(_.baseTypeOf(tp)).flatMap(baseTypeProblems)
 
-    (((Realizable: Realizability)
-      /: mbrProblems)(_ andAlso _)
+    ((((Realizable: Realizability)
+      /: memberProblems)(_ andAlso _)
+      /: refinementProblems)(_ andAlso _)
       /: baseProblems)(_ andAlso _)
   }
 
-  /** `Realizable` if all of `tp`'s non-struct fields have realizable types,
+  /** `Realizable` if all of `tp`'s non-strict fields have realizable types,
    *  a `HasProblemField` instance pointing to a bad field otherwise.
    */
   private def memberRealizability(tp: Type) = {

tests/neg/i4098.scala

@@ -0,0 +1,16 @@
+object App {
+  import scala.reflect.Selectable.reflectiveSelectable
+
+  def coerce[U, V](u: U): V = {
+    type X = { type R >: U }
+    type Y = { type R = V }
+    type Z = X & Y
+    val u1: Z#R = u // error: not a legal path
+    u1
+  }
+
+  def main(args: Array[String]): Unit = {
+    val x: Int = coerce[String, Int]("a")
+    println(x + 1)
+  }
+}