Establish companionship directly

Don't use synthetic companion methods to achieve this. The advantages of the direct
approach are:

 - it's overall simpler
 - it can be more easily extended to opaque types

Author: odersky

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

@@ -140,8 +140,6 @@ object StdNames {
     val WHILE_PREFIX: N               = "while$"
     val DEFAULT_EXCEPTION_NAME: N     = "ex$"
     val INITIALIZER_PREFIX: N         = "initial$"
-    val COMPANION_MODULE_METHOD: N    = "companion$module"
-    val COMPANION_CLASS_METHOD: N     = "companion$class"
     val BOUNDTYPE_ANNOT: N            = "$boundType$"
     val QUOTE: N                      = "'"
     val TYPE_QUOTE: N                = "type_'"
@@ -245,6 +243,7 @@ object StdNames {
 
     // Compiler-internal
     val ANYname: N                  = "<anyname>"
+    val COMPANION: N                = "<companion>"
     val CONSTRUCTOR: N              = "<init>"
     val STATIC_CONSTRUCTOR: N       = "<clinit>"
     val DEFAULT_CASE: N             = "defaultCase$"

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

@@ -471,15 +471,6 @@ object SymDenotations {
     final def isAnonymousModuleVal(implicit ctx: Context): Boolean =
       this.symbol.is(ModuleVal) && (initial.name startsWith str.ANON_CLASS)
 
-    /** Is this a companion class 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): Boolean =
-      name.toTermName == nme.COMPANION_CLASS_METHOD ||
-      name.toTermName == nme.COMPANION_MODULE_METHOD
-
     /** Is this a synthetic method that represents conversions between representations of a value class
       *  These methods are generated in ExtensionMethods
       *  and used in ElimErasedValueType.
@@ -526,6 +517,11 @@ object SymDenotations {
     /** Is this symbol an abstract type or type parameter? */
     final def isAbstractOrParamType(implicit ctx: Context): Boolean = this is DeferredOrTypeParam
 
+    /** Can this symbol have a companion module?
+     *  This is the case if it is a class or an opaque type alias.
+     */
+    final def canHaveCompanion(implicit ctx: Context) = isClass
+
     /** Is this the denotation of a self symbol of some class?
      *  This is the case if one of two conditions holds:
      *  1. It is the symbol referred to in the selfInfo part of the ClassInfo
@@ -597,12 +593,9 @@ object SymDenotations {
     /** Is this a "real" method? A real method is a method which is:
      *  - not an accessor
      *  - not an anonymous function
-     *  - not a companion method
      */
     final def isRealMethod(implicit ctx: Context): Boolean =
-      this.is(Method, butNot = Accessor) &&
-        !isAnonymousFunction &&
-        !isCompanionMethod
+      this.is(Method, butNot = Accessor) && !isAnonymousFunction
 
     /** Is this a getter? */
     final def isGetter(implicit ctx: Context): Boolean =
@@ -948,34 +941,32 @@ object SymDenotations {
     final def enclosingPackageClass(implicit ctx: Context): Symbol =
       if (this is PackageClass) symbol else owner.enclosingPackageClass
 
+    /** Register target as a companion; overridden in ClassDenotation */
+    def registerCompanion(target: Symbol)(implicit ctx: Context) = ()
+
+    /** The registered companion; overridden in ClassDenotation */
+    def registeredCompanion(implicit ctx: Context): Symbol = NoSymbol
+    def registeredCompanion_=(c: Symbol): Unit = ()
+
     /** The module object with the same (term-) name as this class or module class,
      *  and which is also defined in the same scope and compilation unit.
      *  NoSymbol if this module does not exist.
      */
-    final def companionModule(implicit ctx: Context): Symbol = {
-      if (this.flagsUNSAFE is Flags.Module) this.sourceModule
-      else {
-        val companionMethod = info.decls.denotsNamed(nme.COMPANION_MODULE_METHOD, selectPrivate).first
-        if (companionMethod.exists)
-          companionMethod.info.resultType.classSymbol.sourceModule
-        else
-          NoSymbol
-      }
-    }
+    final def companionModule(implicit ctx: Context): Symbol =
+      if (is(Module)) sourceModule
+      else registeredCompanion.sourceModule
+
+    private def companionType(implicit ctx: Context): Symbol =
+      if (is(Package)) NoSymbol
+      else if (is(ModuleVal)) moduleClass.denot.companionType
+      else registeredCompanion
 
     /** 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.
-      */
+     *  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 =
-      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
-      }
+      companionType.suchThat(_.isClass).symbol
 
     final def scalacLinkedClass(implicit ctx: Context): Symbol =
       if (this is ModuleClass) companionNamed(effectiveName.toTypeName)
@@ -1238,6 +1229,7 @@ object SymDenotations {
       val annotations1 = if (annotations != null) annotations else this.annotations
       val d = ctx.SymDenotation(symbol, owner, name, initFlags1, info1, privateWithin1)
       d.annotations = annotations1
+      d.registeredCompanion = registeredCompanion
       d
     }
 
@@ -1831,6 +1823,16 @@ object SymDenotations {
             .copyCaches(this, phase.next)
             .installAfter(phase)
       }
+
+    private[this] var myCompanion: Symbol = NoSymbol
+
+    /** Register companion class */
+    override def registerCompanion(companion: Symbol)(implicit ctx: Context) =
+      if (companion.canHaveCompanion && !unforcedIsAbsent && !companion.unforcedIsAbsent)
+        myCompanion = companion
+
+    override def registeredCompanion(implicit ctx: Context) = { ensureCompleted(); myCompanion }
+    override def registeredCompanion_=(c: Symbol) = { myCompanion = c }
   }
 
   /** The denotation of a package class.

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

@@ -186,15 +186,6 @@ trait Symbols { this: Context =>
 
   val companionMethodFlags: FlagSet = Flags.Synthetic | Flags.Private | Flags.Method
 
-  def synthesizeCompanionMethod(name: Name, target: SymDenotation, owner: SymDenotation)(implicit ctx: Context): Symbol =
-    if (owner.exists && target.exists && !owner.unforcedIsAbsent && !target.unforcedIsAbsent) {
-      val existing = owner.unforcedDecls.lookup(name)
-
-      existing.orElse{
-        ctx.newSymbol(owner.symbol, name, companionMethodFlags , ExprType(target.typeRef))
-      }
-    } else NoSymbol
-
   /** Create a package symbol with associated package class
    *  from its non-info fields and a lazy type for loading the package's members.
    */

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

@@ -161,17 +161,14 @@ object TypeErasure {
    *   - For $asInstanceOf           : [T]T
    *   - For $isInstanceOf           : [T]Boolean
    *   - For all abstract types      : = ?
-   *   - For companion methods       : the erasure of their type with semiEraseVCs = false.
-   *                                   The signature of these methods are used to keep a
-   *                                   link between companions and should not be semi-erased.
    *   - For Java-defined symbols:   : the erasure of their type with isJava = true,
    *                                   semiEraseVCs = false. Semi-erasure never happens in Java.
    *   - For all other symbols       : the semi-erasure of their types, with
    *                                   isJava, isConstructor set according to symbol.
    */
   def transformInfo(sym: Symbol, tp: Type)(implicit ctx: Context): Type = {
     val isJava = sym is JavaDefined
-    val semiEraseVCs = !isJava && !sym.isCompanionMethod
+    val semiEraseVCs = !isJava
     val erase = erasureFn(isJava, semiEraseVCs, sym.isConstructor, wildcardOK = false)
 
     def eraseParamBounds(tp: PolyType): Type =

compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala

@@ -168,10 +168,8 @@ class ClassfileParser(
       classInfo = parseAttributes(classRoot.symbol, classInfo)
       if (isAnnotation) addAnnotationConstructor(classInfo)
 
-      val companionClassMethod = ctx.synthesizeCompanionMethod(nme.COMPANION_CLASS_METHOD, classRoot, moduleRoot)
-      if (companionClassMethod.exists) companionClassMethod.entered
-      val companionModuleMethod = ctx.synthesizeCompanionMethod(nme.COMPANION_MODULE_METHOD, moduleRoot, classRoot)
-      if (companionModuleMethod.exists) companionModuleMethod.entered
+      classRoot.registerCompanion(moduleRoot.symbol)
+      moduleRoot.registerCompanion(classRoot.symbol)
 
       setClassInfo(classRoot, classInfo)
       setClassInfo(moduleRoot, staticInfo)

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

@@ -796,12 +796,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 (sym is Flags.ModuleClass) sym.registerCompanionMethod(nme.COMPANION_CLASS_METHOD, companion)
-              else sym.registerCompanionMethod(nme.COMPANION_MODULE_METHOD, companion)
-            }
+            def isCodefined = roots.contains(companion.denot) == seenRoots.contains(companion)
+
+            if (companion.exists && 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/core/unpickleScala2/Scala2Unpickler.scala

@@ -119,18 +119,14 @@ object Scala2Unpickler {
     val scalacCompanion = denot.classSymbol.scalacLinkedClass
 
     def registerCompanionPair(module: Symbol, claz: Symbol) = {
-      import transform.SymUtils._
-      module.registerCompanionMethod(nme.COMPANION_CLASS_METHOD, claz)
-      if (claz.isClass) {
-        claz.registerCompanionMethod(nme.COMPANION_MODULE_METHOD, module)
-      }
+      module.registerCompanion(claz)
+      claz.registerCompanion(module)
     }
 
-    if (denot.flagsUNSAFE is Module) {
+    if (denot.flagsUNSAFE is Module)
       registerCompanionPair(denot.classSymbol, scalacCompanion)
-    } else {
+    else
       registerCompanionPair(scalacCompanion, denot.classSymbol)
-    }
 
     tempInfo.finalize(denot, normalizedParents) // install final info, except possibly for typeparams ordering
     denot.ensureTypeParamsInCorrectOrder()

compiler/src/dotty/tools/dotc/sbt/ExtractAPI.scala

@@ -262,8 +262,7 @@ private class ExtractAPICollector(implicit val ctx: Context) extends ThunkHolder
 
     // Synthetic methods that are always present do not affect the API
     // and can therefore be ignored.
-    def alwaysPresent(s: Symbol) =
-      s.isCompanionMethod || (csym.is(ModuleClass) && s.isConstructor)
+    def alwaysPresent(s: Symbol) = csym.is(ModuleClass) && s.isConstructor
     val decls = cinfo.decls.filter(!alwaysPresent(_))
     val apiDecls = apiDefinitions(decls)
 

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

@@ -41,18 +41,6 @@ class RestoreScopes extends MiniPhase with IdentityDenotTransformer { thisPhase
       val cls = tree.symbol.asClass
       val pkg = cls.owner.asClass
 
-      // Bring back companion links
-      val companionClass = cls.info.decls.lookup(nme.COMPANION_CLASS_METHOD)
-      val companionModule = cls.info.decls.lookup(nme.COMPANION_MODULE_METHOD)
-
-      if (companionClass.exists) {
-        restoredDecls.enter(companionClass)
-      }
-
-      if (companionModule.exists) {
-        restoredDecls.enter(companionModule)
-      }
-
       pkg.enter(cls)
       val cinfo = cls.classInfo
       tree.symbol.copySymDenotation(

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

@@ -121,15 +121,6 @@ class SymUtils(val self: Symbol) extends AnyVal {
     self
   }
 
-  def registerCompanionMethod(name: Name, target: Symbol)(implicit ctx: Context): Any = {
-    if (!self.unforcedDecls.lookup(name).exists) {
-      val companionMethod = ctx.synthesizeCompanionMethod(name, target, self)
-      if (companionMethod.exists) {
-        companionMethod.entered
-      }
-    }
-  }
-
   /** If this symbol is an enum value or a named class, register it as a child
    *  in all direct parent classes which are sealed.
    *   @param  @late  If true, register only inaccessible children (all others are already

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

@@ -370,7 +370,6 @@ class TreeChecker extends Phase with SymTransformer {
 
       def isNonMagicalMethod(x: Symbol) =
         x.is(Method) &&
-          !x.isCompanionMethod &&
           !x.isValueClassConvertMethod &&
           !(x.is(Macro) && ctx.phase.refChecked) &&
           !x.name.is(DocArtifactName)

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

@@ -609,10 +609,8 @@ 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
-      }
+      modl.registerCompanion(claz)
+      claz.registerCompanion(modl)
     }
 
     def createCompanionLinks(implicit ctx: Context): Unit = {