Make ElimOpaque a DenotTransformer

Author: odersky

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

@@ -57,17 +57,18 @@ object DenotTransformers {
     protected def mayChange(sym: Symbol)(implicit ctx: Context): Boolean = true
   }
 
-  /** A transformer that only transforms SymDenotations */
+  /** A transformer that only transforms SymDenotations.
+   *  Note: Infos of non-sym denotations are left as is. So the transformer should
+   *  be used before erasure only if this is not a problem. After erasure, all
+   *  denotations are SymDenotations, so SymTransformers can be used freely.
+   */
   trait SymTransformer extends DenotTransformer {
 
-  	/** Tramsform the info of a denotation that is not a Symdenotation */
-    def transformNonSymInfo(tp: Type, sym: Symbol)(implicit ctx: Context): Type = tp
-
     def transformSym(sym: SymDenotation)(implicit ctx: Context): SymDenotation
 
     def transform(ref: SingleDenotation)(implicit ctx: Context): SingleDenotation = ref match {
       case ref: SymDenotation => transformSym(ref)
-      case _ => ref.derivedSingleDenotation(ref.symbol, transformNonSymInfo(ref.info, ref.symbol))
+      case _ => ref
     }
   }
 

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

@@ -8,6 +8,7 @@ import Types._
 import Contexts.Context
 import Symbols._
 import Decorators._
+import Denotations.SingleDenotation
 import SymDenotations.SymDenotation
 import DenotTransformers._
 import TypeUtils._
@@ -17,7 +18,7 @@ object ElimOpaque {
 }
 
 /** Rewrites opaque type aliases to normal alias types */
-class ElimOpaque extends MiniPhase with SymTransformer {
+class ElimOpaque extends MiniPhase with DenotTransformer {
 
   override def phaseName: String = ElimOpaque.name
 
@@ -27,14 +28,15 @@ class ElimOpaque extends MiniPhase with SymTransformer {
   // base types of opaque aliases change
   override def changesBaseTypes = true
 
-  override def transformNonSymInfo(tp: Type, sym: Symbol)(implicit ctx: Context): Type =
-    if (sym.isOpaqueHelper) TypeAlias(tp.extractOpaqueAlias) else tp
-
-  def transformSym(sym: SymDenotation)(implicit ctx: Context): SymDenotation =
-    if (sym.isOpaqueHelper) {
-      sym.copySymDenotation(
-        info = TypeAlias(sym.opaqueAlias),
-        initFlags = sym.flags &~ (Opaque | Deferred))
+  def transform(ref: SingleDenotation)(implicit ctx: Context): SingleDenotation =
+    if (ref.symbol.isOpaqueHelper)
+      ref match {
+        case sym: SymDenotation =>
+          sym.copySymDenotation(
+            info = TypeAlias(sym.opaqueAlias),
+            initFlags = sym.flags &~ (Opaque | Deferred))
+        case _ =>
+          ref.derivedSingleDenotation(ref.symbol, TypeAlias(ref.info.extractOpaqueAlias))
     }
-    else sym
+    else ref
 }

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

@@ -65,6 +65,10 @@ class Getters extends MiniPhase with SymTransformer {
         d.copySymDenotation(
           initFlags = d.flags | maybeStable | AccessorCreationFlags,
           info = ExprType(d.info))
+            // Note: This change will only affect the SymDenotation itself, not
+            // SingleDenotations referring to a getter. In this case it does not
+            // seem to be a problem since references to a getter don't care whether
+            // it's a `T` or a `=> T`
       }
       else d