Keep track of opaque companion links

maintain the link from a module class to its opaque type companion,
using the same technique as for companion classes.

Author: odersky

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

@@ -143,6 +143,7 @@ object StdNames {
     val INITIALIZER_PREFIX: N         = "initial$"
     val COMPANION_MODULE_METHOD: N    = "companion$module"
     val COMPANION_CLASS_METHOD: N     = "companion$class"
+    val COMPANION_TYPE_METHOD: N      = "companion$type"
     val BOUNDTYPE_ANNOT: N            = "$boundType$"
     val QUOTE: N                      = "'"
     val TYPE_QUOTE: N                = "type_'"

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

@@ -382,7 +382,7 @@ object SymDenotations {
 
     final def normalizeOpaque()(implicit ctx: Context) = {
       if (is(Opaque)) {
-        addAnnotation(Annotation.OpaqueAlias(info))
+        addAnnotation(Annotation.OpaqueAlias(info.bounds.lo))
         setFlag(Deferred)
         info = TypeBounds.empty
       }
@@ -494,14 +494,15 @@ object SymDenotations {
     final def isAnonymousModuleVal(implicit ctx: Context) =
       this.symbol.is(ModuleVal) && (initial.name startsWith str.ANON_CLASS)
 
-    /** Is this a companion class method or companion object method?
+    /** Is this a companion class or type method or companion object method?
      *  These methods are generated by Symbols#synthesizeCompanionMethod
      *  and used in SymDenotations#companionClass and
      *  SymDenotations#companionModule .
      */
     final def isCompanionMethod(implicit ctx: Context) =
       name.toTermName == nme.COMPANION_CLASS_METHOD ||
-      name.toTermName == nme.COMPANION_MODULE_METHOD
+      name.toTermName == nme.COMPANION_MODULE_METHOD ||
+      name.toTermName == nme.COMPANION_TYPE_METHOD
 
     /** Is this a synthetic method that represents conversions between representations of a value class
       *  These methods are generated in ExtensionMethods
@@ -967,20 +968,28 @@ object SymDenotations {
       }
     }
 
-    /** The class with the same (type-) name as this module or module class,
-      *  and which is also defined in the same scope and compilation unit.
-      *  NoSymbol if this class does not exist.
-      */
-    final def companionClass(implicit ctx: Context): Symbol =
+    private def companionType(name: TermName)(implicit ctx: Context): Symbol =
       if (is(Package)) NoSymbol
       else {
-        val companionMethod = info.decls.denotsNamed(nme.COMPANION_CLASS_METHOD, selectPrivate).first
-        if (companionMethod.exists)
-          companionMethod.info.resultType.classSymbol
-        else
-          NoSymbol
+        val companionMethod = info.decls.denotsNamed(name, selectPrivate).first
+        if (companionMethod.exists) companionMethod.info.resultType.typeSymbol
+        else NoSymbol
       }
 
+    /** The class with the same (type-) name as this module or module class,
+     *  and which is also defined in the same scope and compilation unit.
+     *  NoSymbol if this class does not exist.
+     */
+    final def companionClass(implicit ctx: Context): Symbol =
+      companionType(nme.COMPANION_CLASS_METHOD).suchThat(_.isClass).symbol
+
+    /** The opaque type with the same (type-) name as this module or module class,
+     *  and which is also defined in the same scope and compilation unit.
+     *  NoSymbol if this type does not exist.
+     */
+	final def companionOpaqueType(implicit ctx: Context): Symbol =
+      companionType(nme.COMPANION_TYPE_METHOD).suchThat(_.is(Opaque)).symbol
+
     final def scalacLinkedClass(implicit ctx: Context): Symbol =
       if (this is ModuleClass) companionNamed(effectiveName.toTypeName)
       else if (this.isClass) companionNamed(effectiveName.moduleClassName).sourceModule.moduleClass

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

@@ -743,8 +743,14 @@ class TreeUnpickler(reader: TastyReader,
             def isCodefined =
               roots.contains(companion.denot) == seenRoots.contains(companion)
             if (companion.exists && isCodefined) {
-              if (sym is Flags.ModuleClass) sym.registerCompanionMethod(nme.COMPANION_CLASS_METHOD, companion)
-              else sym.registerCompanionMethod(nme.COMPANION_MODULE_METHOD, companion)
+              if (sym is Module) {
+                if (companion.isClass)
+                  sym.registerCompanionMethod(nme.COMPANION_CLASS_METHOD, companion)
+                else if (companion.is(Opaque))
+                  sym.registerCompanionMethod(nme.COMPANION_TYPE_METHOD, companion)
+              }
+              else
+                sym.registerCompanionMethod(nme.COMPANION_MODULE_METHOD, companion)
             }
             TypeDef(readTemplate(localCtx))
           } else {

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

@@ -603,22 +603,24 @@ class Namer { typer: Typer =>
     def createLinks(classTree: TypeDef, moduleTree: TypeDef)(implicit ctx: Context) = {
       val claz = ctx.effectiveScope.lookup(classTree.name)
       val modl = ctx.effectiveScope.lookup(moduleTree.name)
-      if (claz.isClass && modl.isClass) {
-        ctx.synthesizeCompanionMethod(nme.COMPANION_CLASS_METHOD, claz, modl).entered
-        ctx.synthesizeCompanionMethod(nme.COMPANION_MODULE_METHOD, modl, claz).entered
-      }
+      if (modl.isClass)
+        if (claz.isClass) {
+          ctx.synthesizeCompanionMethod(nme.COMPANION_CLASS_METHOD, claz, modl).entered
+          ctx.synthesizeCompanionMethod(nme.COMPANION_MODULE_METHOD, modl, claz).entered
+        }
+        else if (claz.is(Opaque))
+          ctx.synthesizeCompanionMethod(nme.COMPANION_TYPE_METHOD, claz, modl).entered
     }
 
     def createCompanionLinks(implicit ctx: Context): Unit = {
       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 {