Treat companions of opaque types specially

Make them part of the OpaqueAlias annotation. This is has two benefits

 - opaque types stop being companions after FirstTransform. Previously,
   the LinkedType annotations would persist even though the Opaque flag
   was reset.

 - we gain the freedom to implement companions between classes differently.

Author: odersky

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

@@ -186,9 +186,23 @@ object Annotations {
     }
 
     /** Extractor for opaque alias annotations */
-    object OpaqueAlias extends TypeHintExtractor(implicit ctx => defn.OpaqueAliasAnnot)
+    object OpaqueAlias {
+      def apply(tp: Type, companion: Symbol)(implicit ctx: Context): Annotation = {
+        val arg = if (companion.exists) RefinedType(tp, nme.companion, companion.termRef) else tp
+        Annotation(TypeTree(defn.OpaqueAliasAnnot.typeRef.appliedTo(arg)))
+      }
+      def unapply(ann: Annotation)(implicit ctx: Context): Option[(Type, Symbol)] =
+        if (ann.symbol == defn.OpaqueAliasAnnot) {
+          ann.tree.tpe match {
+            case AppliedType(_, RefinedType(tp, nme.companion, ref) :: Nil) => Some((tp, ref.termSymbol))
+            case AppliedType(_, tp :: Nil) => Some((tp, NoSymbol))
+            case _ => None
+          }
+        }
+        else None
+    }
 
-    /** Extractpr for linked type annotations */
+    /** Extractor for linked type annotations */
     object LinkedType extends TypeHintExtractor(implicit ctx => defn.LinkedTypeAnnot)
 
     def makeSourceFile(path: String)(implicit ctx: Context) =

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

@@ -394,6 +394,7 @@ object StdNames {
     val classOf: N              = "classOf"
     val clone_ : N              = "clone"
  //   val conforms : N             = "conforms" // Dotty deviation: no special treatment of conforms, so the occurrence of the name here would cause to unintended implicit shadowing. Should find a less common name for it in Predef.
+    val companion: N            = "companion"
     val copy: N                 = "copy"
     val currentMirror: N        = "currentMirror"
     val create: N               = "create"

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

@@ -391,7 +391,8 @@ object SymDenotations {
       if (is(Opaque)) {
         info match {
           case tp @ TypeAlias(alias) =>
-            addAnnotation(Annotation.OpaqueAlias(alias))
+            val companion = companionNamed(name.moduleClassName).sourceModule
+            addAnnotation(Annotation.OpaqueAlias(alias, companion))
             info = TypeBounds(defn.NothingType, abstractRHS(alias))
             setFlag(Deferred)
           case _ =>
@@ -968,10 +969,17 @@ object SymDenotations {
      */
     final def companionModule(implicit ctx: Context): Symbol =
       if (is(Module)) sourceModule
-      else getAnnotation(defn.LinkedTypeAnnot) match {
-        case Some(Annotation.LinkedType(linked: TypeRef)) => linked.symbol.sourceModule
-        case _ => NoSymbol
-      }
+      else if (is(Opaque))
+        getAnnotation(defn.OpaqueAliasAnnot) match {
+          case Some(Annotation.OpaqueAlias(_, ref)) => ref
+          case _ => NoSymbol
+        }
+      else
+        getAnnotation(defn.LinkedTypeAnnot) match {
+          case Some(Annotation.LinkedType(linked: TypeRef)) =>
+            linked.symbol.sourceModule
+          case _ => NoSymbol
+        }
 
     private def companionType(implicit ctx: Context): Symbol =
       if (is(Package)) NoSymbol

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

@@ -740,16 +740,9 @@ class TreeUnpickler(reader: TastyReader,
             // The only case to check here is if `sym` is a root. In this case
             // `companion` might have been entered by the environment but it might
             // be missing from the Tasty file. So we check explicitly for that.
-            def isCodefined =
-              roots.contains(companion.denot) == seenRoots.contains(companion)
-            if (companion.exists && isCodefined) {
-              if (companion.isClass)
-                sym.registerCompanion(companion)
-              else if (sym.is(Module) && companion.is(Opaque)) {
-                sym.registerCompanion(companion)
-                companion.registerCompanion(sym)
-              }
-            }
+            def isCodefined = roots.contains(companion.denot) == seenRoots.contains(companion)
+
+            if (companion.canHaveCompanion && isCodefined) sym.registerCompanion(companion)
             TypeDef(readTemplate(localCtx))
           } else {
             sym.info = TypeBounds.empty // needed to avoid cyclic references when unpicklin rhs, see i3816.scala

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

@@ -66,7 +66,7 @@ class FirstTransform extends MiniPhase with SymTransformer { thisPhase =>
     case _ =>
       if (sym.is(Opaque))
         sym.getAnnotation(defn.OpaqueAliasAnnot) match {
-          case Some(Annotation.OpaqueAlias(rhs)) =>
+          case Some(Annotation.OpaqueAlias(rhs, _)) =>
             val result = sym.copySymDenotation(info = TypeAlias(rhs))
             result.removeAnnotation(defn.OpaqueAliasAnnot)
             result.resetFlag(Opaque)

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

@@ -111,7 +111,7 @@ trait NamerContextOps { this: Context =>
     if (ctx.owner.is(Module)) {
       val opaq = ctx.owner.companionOpaqueType
       opaq.getAnnotation(defn.OpaqueAliasAnnot) match {
-        case Some(Annotation.OpaqueAlias(rhs)) =>
+        case Some(Annotation.OpaqueAlias(rhs, _)) =>
           localCtx = localCtx.setFreshGADTBounds
           localCtx.gadt.setBounds(opaq, TypeAlias(rhs))
         case _ =>