Strengthen the bounds of opaque helper types

... to make them aliases of the original opaque types.

Author: odersky

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

@@ -1065,7 +1065,13 @@ object SymDenotations {
     def opaqueAlias(implicit ctx: Context): Type = {
       if (isOpaqueHelper) {
         owner.asClass.classInfo.selfType match {
-          case RefinedType(_, _, TypeAlias(rinfo)) => rinfo
+          case RefinedType(_, _, TypeBounds(lo, _)) =>
+            def extractAlias(tp: Type): Type = tp match {
+              case OrType(alias, _) => alias
+              case HKTypeLambda(tparams, tp) =>
+                HKTypeLambda(tparams.map(_.paramInfo), extractAlias(tp))
+            }
+            extractAlias(lo)
         }
       }
       else NoType

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

@@ -582,11 +582,12 @@ 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 = {
-    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 =
+    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)
+    }
 
  /**  Check that `tp` is a class type.
   *   Also, if `traitReq` is true, check that `tp` is a trait.

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

@@ -947,7 +947,10 @@ class Namer { typer: Typer =>
               // companion object, since that's where the rhs was defined.
               val aliasCtx = ctx.outer.fresh.setOwner(symbolOfTree(td))
               val alias = typedAheadType(rhs)(aliasCtx).tpe
-              RefinedType(mt, localName, TypeAlias(alias))
+              val original = cls.companionOpaqueType.typeRef
+              val cmp = ctx.typeComparer
+              val bounds = TypeBounds(cmp.orType(alias, original), cmp.andType(alias, original))
+              RefinedType(mt, localName, bounds)
             case _ :: stats1 =>
               refineOpaqueCompanionSelfType(mt, stats1)
           }