Fix #6286: Fix ElimOpaque transformation

SymTransformers used to transform only SymDenotations. But that does not work for
ElimOpaque, where we also have to transform SingleDenotations that refer to opaque
helpers.

Author: odersky

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -407,7 +407,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       ref(defn.DottyArraysModule).select(defn.newArrayMethod).withSpan(span)
 
     if (!ctx.erasedTypes) {
-      assert(!TypeErasure.isGeneric(elemTpe)) //needs to be done during typer. See Applications.convertNewGenericArray
+      assert(!TypeErasure.isGeneric(elemTpe), elemTpe) //needs to be done during typer. See Applications.convertNewGenericArray
       newArr.appliedToTypeTrees(TypeTree(returnTpe) :: Nil).appliedToArgs(clsOf(elemTpe) :: clsOf(returnTpe) :: dims :: Nil).withSpan(span)
     } else  // after erasure
       newArr.appliedToArgs(clsOf(elemTpe) :: clsOf(returnTpe) :: dims :: Nil).withSpan(span)

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

@@ -60,11 +60,14 @@ object DenotTransformers {
   /** A transformer that only transforms SymDenotations */
   trait SymTransformer extends DenotTransformer {
 
+  	/** Tramsform the info of a denotation that is not a Symdenotation */
+    def transformInfo(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
+      case _ => ref.derivedSingleDenotation(ref.symbol, transformInfo(ref.info, ref.symbol))
     }
   }
 

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

@@ -19,6 +19,7 @@ import reporting.diagnostic.Message
 import reporting.diagnostic.messages.BadSymbolicReference
 import reporting.trace
 import collection.mutable
+import transform.TypeUtils._
 
 import scala.annotation.internal.sharable
 
@@ -1082,16 +1083,10 @@ object SymDenotations {
      *  containing object.
      */
     def opaqueAlias(implicit ctx: Context): Type = {
-      if (isOpaqueHelper) {
+      if (isOpaqueHelper)
         owner.asClass.classInfo.selfType match {
-          case RefinedType(_, _, TypeBounds(lo, _)) =>
-            def extractAlias(tp: Type): Type = tp match {
-              case OrType(alias, _) => alias
-              case tp: HKTypeLambda => tp.derivedLambdaType(resType = extractAlias(tp.resType))
-            }
-            extractAlias(lo)
+          case RefinedType(_, _, bounds) => bounds.extractOpaqueAlias
         }
-      }
       else NoType
     }
 

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

@@ -2,25 +2,15 @@ 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._
+import TypeUtils._
 
 object ElimOpaque {
   val name: String = "elimOpaque"
@@ -37,6 +27,9 @@ class ElimOpaque extends MiniPhase with SymTransformer {
   // base types of opaque aliases change
   override def changesBaseTypes = true
 
+  override def transformInfo(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(

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

@@ -51,5 +51,17 @@ object TypeUtils {
     /** The `*:` equivalent of an instance of a Tuple class */
     def toNestedPairs(implicit ctx: Context): Type =
       TypeOps.nestedPairs(tupleElementTypes)
+
+    /** Extract opaque alias from TypeBounds type that combines it with the reference
+     *  to the opaque type itself
+     */
+    def extractOpaqueAlias(implicit ctx: Context): Type = self match {
+      case TypeBounds(lo, _) =>
+        def extractAlias(tp: Type): Type = tp match {
+          case OrType(alias, _) => alias
+          case self: HKTypeLambda => self.derivedLambdaType(resType = extractAlias(self.resType))
+        }
+        extractAlias(lo)
+    }
   }
 }

tests/pos/i6286.scala

@@ -0,0 +1,6 @@
+object A {
+  opaque type T33 = Int
+  object T33 {
+    val a = new Array[T33](3)
+  }
+}