Store opaque info in annotation

An opaque type becomes an abstract type, with the alias stored in an
OpaqueAlias annotation

Author: odersky

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

@@ -173,6 +173,18 @@ object Annotations {
         else None
     }
 
+    /** Extractor for opaque alias annotations */
+    object OpaqueAlias {
+      def apply(tp: Type)(implicit ctx: Context): Annotation =
+        Annotation(TypeTree(defn.OpaqueAliasAnnotType.appliedTo(tp)))
+      def unapply(ann: Annotation)(implicit ctx: Context) =
+        if (ann.symbol == defn.OpaqueAliasAnnot) {
+          val AppliedType(tycon, arg :: Nil) = ann.tree.tpe
+          Some(arg)
+        }
+        else None
+    }
+
     def makeSourceFile(path: String)(implicit ctx: Context) =
       apply(defn.SourceFileAnnot, Literal(Constant(path)))
   }

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

@@ -664,6 +664,8 @@ class Definitions {
   def BodyAnnot(implicit ctx: Context) = BodyAnnotType.symbol.asClass
   lazy val ChildAnnotType = ctx.requiredClassRef("scala.annotation.internal.Child")
   def ChildAnnot(implicit ctx: Context) = ChildAnnotType.symbol.asClass
+  lazy val OpaqueAliasAnnotType = ctx.requiredClassRef("scala.annotation.internal.OpaqueAlias")
+  def OpaqueAliasAnnot(implicit ctx: Context) = OpaqueAliasAnnotType.symbol.asClass
   lazy val CovariantBetweenAnnotType = ctx.requiredClassRef("scala.annotation.internal.CovariantBetween")
   def CovariantBetweenAnnot(implicit ctx: Context) = CovariantBetweenAnnotType.symbol.asClass
   lazy val ContravariantBetweenAnnotType = ctx.requiredClassRef("scala.annotation.internal.ContravariantBetween")

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

@@ -380,6 +380,14 @@ object SymDenotations {
       case _ => unforcedDecls.openForMutations
     }
 
+    final def normalizeOpaque()(implicit ctx: Context) = {
+      if (is(Opaque)) {
+        addAnnotation(Annotation.OpaqueAlias(info))
+        setFlag(Deferred)
+        info = TypeBounds.empty
+      }
+    }
+
     // ------ Names ----------------------------------------------
 
     /** The expanded name of this denotation. */

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

@@ -614,8 +614,8 @@ class TreePickler(pickler: TastyPickler) {
       // a different toplevel class, it is impossible to pickle a reference to it.
       // Such annotations will be reconstituted when unpickling the child class.
       // See tests/pickling/i3149.scala
-    case _ => ann.symbol == defn.BodyAnnot
-      // inline bodies are reconstituted automatically when unpickling
+    case _ => ann.symbol == defn.BodyAnnot || ann.symbol == defn.OpaqueAliasAnnot
+      // inline bodies and opaque aliases are reconstituted automatically when unpickling
   }
 
   def pickleAnnotation(owner: Symbol, ann: Annotation)(implicit ctx: Context) =

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

@@ -528,6 +528,7 @@ class TreeUnpickler(reader: TastyReader,
             // avoids space leaks by not capturing the current context
           forkAt(rhsStart).readTerm()
         })
+      sym.normalizeOpaque()
       goto(start)
       sym
     }

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

@@ -129,9 +129,7 @@ class SymUtils(val self: Symbol) extends AnyVal {
   def registerCompanionMethod(name: Name, target: Symbol)(implicit ctx: Context) = {
     if (!self.unforcedDecls.lookup(name).exists) {
       val companionMethod = ctx.synthesizeCompanionMethod(name, target, self)
-      if (companionMethod.exists) {
-        companionMethod.entered
-      }
+      if (companionMethod.exists) companionMethod.entered
     }
   }
 

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

@@ -378,6 +378,7 @@ object Checking {
     checkNoConflict(Lazy, Inline)
     if (sym.is(Inline)) checkApplicable(Inline, sym.isTerm && !sym.is(Mutable | Module))
     if (sym.is(Lazy)) checkApplicable(Lazy, !sym.is(Method | Mutable))
+    if (sym.is(Opaque)) checkApplicable(Opaque, sym.isAliasType)
     if (sym.isType && !sym.is(Deferred))
       for (cls <- sym.allOverriddenSymbols.filter(_.isClass)) {
         fail(CannotHaveSameNameAs(sym, cls, CannotHaveSameNameAs.CannotBeOverridden))

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

@@ -832,6 +832,7 @@ class Namer { typer: Typer =>
       addInlineInfo(denot)
       denot.info = typeSig(sym)
       Checking.checkWellFormed(sym)
+      denot.normalizeOpaque()
       denot.info = avoidPrivateLeaks(sym, sym.pos)
     }
   }

library/src/scala/annotation/internal/OpaqueAlias.scala

@@ -0,0 +1,11 @@
+package scala.annotation.internal
+
+import scala.annotation.Annotation
+
+/** An annotation to record the right-hand side of an opaque type. Given
+ *
+ *    opaque type T = U
+ *
+ *  the info of `T` is `Nothing..Any`, but `T` carries the annotation `OpaqueAlias[U]`
+ */
+class OpaqueAlias[T] extends Annotation