Update "good bounds" checks

These need to be special-cased for base types now, since
conflicting base types do not need any longer to public
type members with conflicting bounds. A Test case where this
shows up is points.scala. Another is Iter3.scala which
got moved from pos to neg.

These test cases passed in the old scheme, probably because comflicting
aliases were not coalesced into bad type bounds. points.scala failed at
ElimErasedValueTypes because it reported a double definition, but
I think that one was not correct either and came from the same root
cause of conflicting aliases.

Author: odersky

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

@@ -33,6 +33,12 @@ object CheckRealizable {
   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 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}")
+
+  class HasProblemBase(base1: Type, base2: Type)(implicit ctx: Context)
+  extends Realizability(i" has conflicting base types $base1 and $base2")
+
   class HasProblemField(fld: SingleDenotation, problem: Realizability)(implicit ctx: Context)
   extends Realizability(i" has a member $fld which is not a legal path\n since ${fld.symbol.name}: ${fld.info}${problem.msg}")
 
@@ -89,18 +95,36 @@ class CheckRealizable(implicit ctx: Context) {
       else boundsRealizability(tp).andAlso(memberRealizability(tp))
   }
 
-  /** `Realizable` if `tp` has good bounds, a `HasProblemBounds` instance
-   *  pointing to a bad bounds member otherwise.
+  /** `Realizable` if `tp` has good bounds, a `HasProblem...` instance
+   *  pointing to a bad bounds member otherwise. "Has good bounds" means:
+   *
+   *    - all type members have good bounds
+   *    - all base types are class types, and if their arguments are wildcards
+   *      they have good bounds.
    */
   private def boundsRealizability(tp: Type) = {
-    def hasBadBounds(mbr: SingleDenotation) = {
-      val bounds = mbr.info.bounds
-      !(bounds.lo <:< bounds.hi)
-    }
-    tp.nonClassTypeMembers.find(hasBadBounds) match {
-      case Some(mbr) => new HasProblemBounds(mbr)
-      case _ => Realizable
+    val mbrProblems =
+      for {
+        mbr <- tp.nonClassTypeMembers
+        if !(mbr.info.loBound <:< mbr.info.hiBound)
+      }
+      yield new HasProblemBounds(mbr)
+      
+    def baseTypeProblems(base: Type) = base match {
+      case AndType(base1, base2) =>
+        new HasProblemBase(base1, base2) :: Nil
+      case base =>
+        base.argInfos.collect {
+          case bounds @ TypeBounds(lo, hi) if !(lo <:< hi) =>
+            new HasProblemBaseArg(base, bounds)
+        }
     }
+    val baseProblems =
+      tp.baseClasses.map(_.baseTypeOf(tp)).flatMap(baseTypeProblems)
+      
+    (((Realizable: Realizability)
+      /: mbrProblems)(_ andAlso _)
+      /: baseProblems)(_ andAlso _)
   }
 
   /** `Realizable` if all of `tp`'s non-struct fields have realizable types,

compiler/src/dotty/tools/dotc/typer/Checking.scala

@@ -547,10 +547,10 @@ trait Checking {
     if (!tp.isStable) ctx.error(ex"$tp is not stable", pos)
 
   /** Check that all type members of `tp` have realizable bounds */
-  def checkRealizableBounds(tp: Type, pos: Position)(implicit ctx: Context): Unit = {
-    val rstatus = boundsRealizability(tp)
+  def checkRealizableBounds(cls: Symbol, pos: Position)(implicit ctx: Context): Unit = {
+    val rstatus = boundsRealizability(cls.thisType)
     if (rstatus ne Realizable)
-      ctx.error(ex"$tp cannot be instantiated since it${rstatus.msg}", pos)
+      ctx.error(ex"$cls cannot be instantiated since it${rstatus.msg}", pos)
   }
 
  /**  Check that `tp` is a class type.

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -1413,7 +1413,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
         .withType(dummy.nonMemberTermRef)
       checkVariance(impl1)
       if (!cls.is(AbstractOrTrait) && !ctx.isAfterTyper)
-        checkRealizableBounds(cls.thisType, cdef.namePos) // !@@@ adapt
+        checkRealizableBounds(cls, cdef.namePos) // !@@@ adapt
       val cdef1 = assignType(cpy.TypeDef(cdef)(name, impl1), cls)
       if (ctx.phase.isTyper && cdef1.tpe.derivesFrom(defn.DynamicClass) && !ctx.dynamicsEnabled) {
         val isRequired = parents1.exists(_.tpe.isRef(defn.DynamicClass))

tests/pos/Iter3.scala renamed to tests/neg/Iter3.scala

@@ -59,19 +59,19 @@ object Iter2 {
       if (isEmpty) 0 else 1 + tail.length
   }
 
-  case class Cons[A](x: A, xs: List[A]) extends List[A] {
+  case class Cons[A](x: A, xs: List[A]) extends List[A] { // error: cannot be instantiated
     def isEmpty = false
     def head = x
     def tail = xs
   }
 
-  case object Nil extends List[Nothing] {
+  case object Nil extends List[Nothing] { // error: cannot be instantiated
     def isEmpty = true
     def head = ???
     def tail = ???
   }
 
-  class ArrayBuffer[A] private (initElems: Array[AnyRef], initLen: Int) extends Seq[A] with FromIterator[ArrayBuffer] {
+  class ArrayBuffer[A] private (initElems: Array[AnyRef], initLen: Int) extends Seq[A] with FromIterator[ArrayBuffer] { // error: cannot be instantiated
     def this() = this(new Array[AnyRef](16), 0)
     def this(it: ArrayIterator[A]) = this(it.elems, it.len)
     private var elems: Array[AnyRef] = initElems

tests/neg/points.scala

@@ -1,8 +1,18 @@
+trait Comparable[T] {
+  def compareTo(other: T): Int
+}
+
 class Point extends Comparable[Point] {
-  override def compareTo(other: Point): Int = ???
+  override def compareTo(other: Point): Int = 1
 }
 
-class ColoredPoint extends Point with Comparable[ColoredPoint] {
-  override def compareTo(other: ColoredPoint): Int = ??? // error: overridden method has different signature
+class ColoredPoint extends Point with Comparable[ColoredPoint] { // error: cannot be instantiated
+  override def compareTo(other: ColoredPoint): Int = -1
 }
 
+object Test extends App {
+  val c: Point = new ColoredPoint
+  def cmp[T <: Comparable[T]](p1: Comparable[T], p2: T) =
+    p1.compareTo(p2)
+  println(cmp(c, c))
+}