Eliminate opaque types

This is done after RefChecks, so that we can check for proper overriding
of opaque types.

Author: odersky

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -64,7 +64,8 @@ class Compiler {
          new HoistSuperArgs,         // Hoist complex arguments of supercalls to enclosing scope
          new ClassOf,                // Expand `Predef.classOf` calls.
          new RefChecks) ::           // Various checks mostly related to abstract members and overriding
-    List(new TryCatchPatterns,       // Compile cases in try/catch
+    List(new ElimOpaque,             // Turn opaque into normal aliases
+         new TryCatchPatterns,       // Compile cases in try/catch
          new PatternMatcher,         // Compile pattern matches
          new ExplicitOuter,          // Add accessors to outer classes from nested ones.
          new ExplicitSelf,           // Make references to non-trivial self types explicit as casts

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

@@ -43,8 +43,8 @@ abstract class Periods { self: Context =>
     val period = this.period
     period == p ||
     period.runId == p.runId &&
-      this.phases(period.phaseId).sameParentsStartId ==
-      this.phases(p.phaseId).sameParentsStartId
+      this.phases(period.phaseId).sameBaseTypesStartId ==
+      this.phases(p.phaseId).sameBaseTypesStartId
   }
 }
 

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

@@ -320,6 +320,9 @@ object Phases {
     /** Can this transform change the parents of a class? */
     def changesParents: Boolean = false
 
+    /** Can this transform change the base types of a type? */
+    def changesBaseTypes: Boolean = changesParents
+
     def exists: Boolean = true
 
     def initContext(ctx: FreshContext): Unit = ()
@@ -332,6 +335,7 @@ object Phases {
 
     private[this] var mySameMembersStartId = NoPhaseId
     private[this] var mySameParentsStartId = NoPhaseId
+    private[this] var mySameBaseTypesStartId = NoPhaseId
 
     /** The sequence position of this phase in the given context where 0
      * is reserved for NoPhase and the first real phase is at position 1.
@@ -351,6 +355,8 @@ object Phases {
       // id of first phase where all symbols are guaranteed to have the same members as in this phase
     final def sameParentsStartId: Int = mySameParentsStartId
       // id of first phase where all symbols are guaranteed to have the same parents as in this phase
+    final def sameBaseTypesStartId: Int = mySameBaseTypesStartId
+      // id of first phase where all symbols are guaranteed to have the same base tpyes as in this phase
 
     protected[Phases] def init(base: ContextBase, start: Int, end: Int): Unit = {
       if (start >= FirstPhaseId)
@@ -363,6 +369,7 @@ object Phases {
       myRefChecked   = prev.getClass == classOf[RefChecks]    || prev.refChecked
       mySameMembersStartId = if (changesMembers) id else prev.sameMembersStartId
       mySameParentsStartId = if (changesParents) id else prev.sameParentsStartId
+      mySameBaseTypesStartId = if (changesBaseTypes) id else prev.sameBaseTypesStartId
     }
 
     protected[Phases] def init(base: ContextBase, id: Int): Unit = init(base, id, id)

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

@@ -0,0 +1,47 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import Names._
+import dotty.tools.dotc.transform.MegaPhase._
+import ast.Trees._
+import ast.untpd
+import Flags._
+import Types._
+import Constants.Constant
+import Contexts.Context
+import Symbols._
+import Decorators._
+import Annotations._
+import Annotations.ConcreteAnnotation
+import Denotations.SingleDenotation
+import SymDenotations.SymDenotation
+import scala.collection.mutable
+import DenotTransformers._
+import NameOps._
+import NameKinds.OuterSelectName
+import StdNames._
+
+object ElimOpaque {
+  val name: String = "elimOpaque"
+}
+
+/** Rewrites opaque type aliases to normal alias types */
+class ElimOpaque extends MiniPhase with SymTransformer {
+
+  override def phaseName: String = ElimOpaque.name
+
+  // Override checks need to take place before treating opaque types as aliases
+  override def runsAfterGroupsOf: Set[String] = Set(typer.RefChecks.name)
+
+  // base types of opaque aliases change
+  override def changesBaseTypes = true
+
+  def transformSym(sym: SymDenotation)(implicit ctx: Context): SymDenotation =
+    if (sym.isOpaqueHelper) {
+      sym.copySymDenotation(
+        info = TypeAlias(sym.opaqueAlias),
+        initFlags = sym.flags &~ (Opaque | Deferred))
+    }
+    else sym
+}

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

@@ -22,10 +22,9 @@ object FirstTransform {
   val name: String = "firstTransform"
 }
 
-
 /** The first tree transform
  *   - eliminates some kinds of trees: Imports, NamedArgs
- *   - stubs out native and typelevel methods
+ *   - stubs out native methods
  *   - eliminates self tree in Template and self symbol in ClassInfo
  *   - collapses all type trees to trees of class TypeTree
  *   - converts idempotent expressions with constant types