Fix realizability checking and test

Author: odersky

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

@@ -105,7 +105,8 @@ class CheckRealizable(implicit ctx: Context) {
   /** `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 type members have good bounds (except for opaque helpers)
+   *    - all refinements of the underlying type have good bounds (except for opaque companions)
    *    - all base types are class types, and if their arguments are wildcards
    *      they have good bounds.
    *    - base types do not appear in multiple instances with different arguments.
@@ -114,10 +115,15 @@ class CheckRealizable(implicit ctx: Context) {
    */
   private def boundsRealizability(tp: Type) = {
 
+    def isOpaqueCompanionThis = tp match {
+      case tp: ThisType => tp.cls.isOpaqueCompanion
+      case _ => false
+    }
+
     val memberProblems =
       for {
         mbr <- tp.nonClassTypeMembers
-        if !(mbr.info.loBound <:< mbr.info.hiBound)
+        if !(mbr.info.loBound <:< mbr.info.hiBound) && !mbr.symbol.isOpaqueHelper
       }
       yield new HasProblemBounds(mbr.name, mbr.info)
 
@@ -126,7 +132,7 @@ class CheckRealizable(implicit ctx: Context) {
         name <- refinedNames(tp)
         if (name.isTypeName)
         mbr <- tp.member(name).alternatives
-        if !(mbr.info.loBound <:< mbr.info.hiBound)
+        if !(mbr.info.loBound <:< mbr.info.hiBound) && !isOpaqueCompanionThis
       }
       yield new HasProblemBounds(name, mbr.info)
 

compiler/src/dotty/tools/dotc/transform/ElimOpaque.scala

@@ -35,7 +35,7 @@ class ElimOpaque extends MiniPhase with SymTransformer {
   override def runsAfterGroupsOf: Set[String] = Set(typer.RefChecks.name)
 
   // base types of opaque aliases change
-  def changesBaseTypes = true
+  override def changesBaseTypes = true
 
   def transformSym(sym: SymDenotation)(implicit ctx: Context): SymDenotation =
     if (sym.isOpaqueHelper) {

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

@@ -582,12 +582,11 @@ 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(cls: Symbol, pos: Position)(implicit ctx: Context): Unit =
-    if (!cls.is(Module)) { // module's have system generated self types, which are assumed to be good
-      val rstatus = boundsRealizability(cls.thisType)
-      if (rstatus ne Realizable)
-        ctx.error(ex"$cls cannot be instantiated since it${rstatus.msg}", pos)
-    }
+  def checkRealizableBounds(cls: Symbol, pos: Position)(implicit ctx: Context): Unit = {
+    val rstatus = boundsRealizability(cls.thisType)
+    if (rstatus ne Realizable)
+      ctx.error(ex"$cls cannot be instantiated since it${rstatus.msg}", pos)
+  }
 
  /**  Check that `tp` is a class type.
   *   Also, if `traitReq` is true, check that `tp` is a trait.

tests/neg/aliasing-subtypes.scala

@@ -4,7 +4,7 @@ object Test {
     type A
   }
 
-  class C extends T { this: m.type =>
+  class C extends T { this: m.type => // error: cannot instantiate
     type A >: Int | Test.A <: Int & Test.A
 
     def reveal(x: A): Int = x