Normalize opaque types

Treat as abstract types until FirstTransform, as aliases afterwards

Author: odersky

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

@@ -365,6 +365,29 @@ object SymDenotations {
       case _ => unforcedDecls.openForMutations
     }
 
+    /** If this is an opaque type alias, mark it as Deferred with empty bounds
+     *  while storing the former right-hand side in an OpaqueAlias annotation.
+     */
+    final def normalizeOpaque()(implicit ctx: Context) = {
+      def abstractRHS(tp: Type): Type = tp match {
+        case tp: HKTypeLambda => tp.derivedLambdaType(resType = abstractRHS(tp.resType))
+        case _ => defn.AnyType
+      }
+      if (is(Opaque)) {
+        info match {
+          case TypeAlias(alias) =>
+            val companion = companionNamed(name.moduleClassName).sourceModule
+            val arg =
+              if (companion.exists) RefinedType(alias, nme.COMPANION, companion.termRef)
+              else alias
+            addAnnotation(Annotation(tpd.TypeTree(defn.OpaqueAliasAnnot.typeRef.appliedTo(arg)).withPos(symbol.pos)))
+            info = TypeBounds(defn.NothingType, abstractRHS(alias))
+            setFlag(Deferred)
+          case _ =>
+        }
+      }
+    }
+
     // ------ Names ----------------------------------------------
 
     /** The expanded name of this denotation. */
@@ -1019,6 +1042,21 @@ object SymDenotations {
     final def enclosingSubClass(implicit ctx: Context): Symbol =
       ctx.owner.ownersIterator.findSymbol(_.isSubClass(symbol))
 
+    /** The alias of an opaque type */
+    def opaqueAlias(implicit ctx: Context): Type = {
+      if (is(Opaque))
+        getAnnotation(defn.OpaqueAliasAnnot) match {
+          case Some(ann) =>
+            val AppliedType(_, arg :: Nil) = ann.tree.tpe
+            arg match {
+              case RefinedType(tp, nme.COMPANION, _) => tp
+              case tp => tp
+            }
+          case None => NoType
+        }
+      else NoType
+    }
+
     /** The non-private symbol whose name and type matches the type of this symbol
      *  in the given class.
      *  @param inClass   The class containing the result symbol's definition

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -807,6 +807,7 @@ class TreeUnpickler(reader: TastyReader,
               case _ => rhs.tpe.toBounds
             }
             sym.resetFlag(Provisional)
+            sym.normalizeOpaque()
             TypeDef(rhs)
           }
         case PARAM =>
@@ -1072,8 +1073,9 @@ class TreeUnpickler(reader: TastyReader,
                 case _ => readTerm()
               }
               val call = ifBefore(end)(maybeCall, EmptyTree)
-              val bindings = readStats(ctx.owner, end).asInstanceOf[List[ValOrDefDef]]
-              val expansion = exprReader.readTerm() // need bindings in scope, so needs to be read before
+              val inlineCtx = tpd.inlineContext(call)
+              val bindings = readStats(ctx.owner, end)(inlineCtx).asInstanceOf[List[ValOrDefDef]]
+              val expansion = exprReader.readTerm()(inlineCtx) // need bindings in scope, so needs to be read before
               Inlined(call, bindings, expansion)
             case IF =>
               If(readTerm(), readTerm(), readTerm())

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

@@ -12,6 +12,10 @@ 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._
@@ -25,29 +29,38 @@ object 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
+ *   - rewrites opaque type aliases to normal alias types
  *   - collapses all type trees to trees of class TypeTree
  *   - converts idempotent expressions with constant types
  *   - drops branches of ifs using the rules
  *          if (true) A else B    ==> A
  *          if (false) A else B   ==> B
  */
-class FirstTransform extends MiniPhase with InfoTransformer { thisPhase =>
+class FirstTransform extends MiniPhase with SymTransformer { thisPhase =>
   import ast.tpd._
 
   override def phaseName: String = FirstTransform.name
 
-  /** eliminate self symbol in ClassInfo */
-  override def transformInfo(tp: Type, sym: Symbol)(implicit ctx: Context): Type = tp match {
+  /** Two transforms:
+   *   1. eliminate self symbol in ClassInfo
+   *   2. Rewrite opaque type aliases to normal alias types
+   */
+  def transformSym(sym: SymDenotation)(implicit ctx: Context): SymDenotation = sym.info match {
     case tp @ ClassInfo(_, _, _, _, self: Symbol) =>
-      tp.derivedClassInfo(selfInfo = self.info)
+      sym.copySymDenotation(info = tp.derivedClassInfo(selfInfo = self.info))
+        .copyCaches(sym, ctx.phase.next)
     case _ =>
-      tp
+      if (sym.is(Opaque)) {
+        val result = sym.copySymDenotation(info = TypeAlias(sym.opaqueAlias))
+        result.removeAnnotation(defn.OpaqueAliasAnnot)
+        result.resetFlag(Opaque | Deferred)
+        result
+      }
+      else sym
   }
 
-  override protected def mayChange(sym: Symbol)(implicit ctx: Context): Boolean = sym.isClass
-
   override def checkPostCondition(tree: Tree)(implicit ctx: Context): Unit = {
     tree match {
       case Select(qual, name) if !name.is(OuterSelectName) && tree.symbol.exists =>

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

@@ -99,12 +99,12 @@ trait NamerContextOps { this: Context =>
 
   /** A new context for the interior of a class */
   def inClassContext(selfInfo: AnyRef /* Should be Type | Symbol*/): Context = {
-    val localCtx: Context = ctx.fresh.setNewScope
+    val localCtx: FreshContext = ctx.fresh.setNewScope
     selfInfo match {
       case sym: Symbol if sym.exists && sym.name != nme.WILDCARD => localCtx.scope.openForMutations.enter(sym)
       case _ =>
     }
-    localCtx
+    localCtx.maybeInOpaqueCompanionContext(ctx.owner)
   }
 
   def packageContext(tree: untpd.PackageDef, pkg: Symbol): Context =
@@ -502,7 +502,6 @@ class Namer { typer: Typer =>
     case _ =>
   }
 
-
   def setDocstring(sym: Symbol, tree: Tree)(implicit ctx: Context): Unit = tree match {
     case t: MemberDef if t.rawComment.isDefined =>
       ctx.docCtx.foreach(_.addDocstring(sym, t.rawComment))
@@ -617,12 +616,11 @@ class Namer { typer: Typer =>
       val classDef  = mutable.Map[TypeName, TypeDef]()
       val moduleDef = mutable.Map[TypeName, TypeDef]()
 
-      def updateCache(cdef: TypeDef): Unit = {
-        if (!cdef.isClassDef || cdef.mods.is(Package)) return
-
-        if (cdef.mods.is(ModuleClass)) moduleDef(cdef.name) = cdef
-        else classDef(cdef.name) = cdef
-      }
+      def updateCache(cdef: TypeDef): Unit =
+        if (cdef.isClassDef && !cdef.mods.is(Package) || cdef.mods.is(Opaque)) {
+          if (cdef.mods.is(ModuleClass)) moduleDef(cdef.name) = cdef
+          else classDef(cdef.name) = cdef
+        }
 
       for (stat <- stats)
         expanded(stat) match {
@@ -1236,6 +1234,7 @@ class Namer { typer: Typer =>
         tref.recomputeDenot()
       case _ =>
     }
+    sym.normalizeOpaque()
     ensureUpToDate(sym.typeRef, dummyInfo)
     ensureUpToDate(sym.typeRef.appliedTo(tparamSyms.map(_.typeRef)), TypeBounds.empty)
     sym.info