Simplify companion scheme

Use a field in ClassDenotation instead of an annotation

Author: odersky

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

@@ -173,21 +173,6 @@ object Annotations {
         else None
     }
 
-    /** A generic extractor for annotations carrying types */
-    class TypeHintExtractor(cls: Context => ClassSymbol) {
-      def apply(tp: Type)(implicit ctx: Context): Annotation =
-        Annotation(TypeTree(cls(ctx).typeRef.appliedTo(tp)))
-      def unapply(ann: Annotation)(implicit ctx: Context): Option[Type] =
-        if (ann.symbol == cls(ctx)) {
-          val AppliedType(tycon, arg :: Nil) = ann.tree.tpe
-          Some(arg)
-        }
-        else None
-    }
-
-    /** Extractor for linked type annotations */
-    object LinkedType extends TypeHintExtractor(implicit ctx => defn.LinkedTypeAnnot)
-
     def makeSourceFile(path: String)(implicit ctx: Context) =
       apply(defn.SourceFileAnnot, Literal(Constant(path)))
   }

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

@@ -530,7 +530,6 @@ class Definitions {
   lazy val EqualsPatternClass = enterSpecialPolyClass(tpnme.EQUALS_PATTERN, EmptyFlags, Seq(AnyType))
 
   lazy val RepeatedParamClass = enterSpecialPolyClass(tpnme.REPEATED_PARAM_CLASS, Covariant, Seq(ObjectType, SeqType))
-  lazy val LinkedTypeAnnot    = enterSpecialPolyClass(tpnme.LINKED_TYPE, EmptyFlags, Seq(AnyType))
   lazy val OpaqueAliasAnnot   = enterSpecialPolyClass(tpnme.OPAQUE_ALIAS, EmptyFlags, Seq(AnyType))
 
   // fundamental classes
@@ -1159,7 +1158,6 @@ class Definitions {
     AnyRefAlias,
     RepeatedParamClass,
     ByNameParamClass2x,
-    LinkedTypeAnnot,
     OpaqueAliasAnnot,
     AnyValClass,
     NullClass,

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

@@ -257,6 +257,8 @@ object Flags {
   /** An opqaue type */
   final val Opaque = typeFlag(12, "opaque")
 
+  final val MutableOrOpaque = Mutable.toCommonFlags
+
   /** Symbol is local to current class (i.e. private[this] or protected[this]
    *  pre: Private or Protected are also set
    */
@@ -460,7 +462,7 @@ object Flags {
   /** Flags guaranteed to be set upon symbol creation */
   final val FromStartFlags =
     Module | Package | Deferred | MethodOrHKCommon | Param | ParamAccessor.toCommonFlags |
-    Scala2ExistentialCommon | Mutable.toCommonFlags | Touched | JavaStatic |
+    Scala2ExistentialCommon | MutableOrOpaque | Touched | JavaStatic |
     CovariantOrOuter | ContravariantOrLabel | CaseAccessor.toCommonFlags |
     NonMember | Erroneous | ImplicitCommon | Permanent | Synthetic |
     SuperAccessorOrScala2x | Inline

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

@@ -960,11 +960,12 @@ object SymDenotations {
     final def enclosingPackageClass(implicit ctx: Context): Symbol =
       if (this is PackageClass) symbol else owner.enclosingPackageClass
 
-    /** Register target as a companion */
-    def registerCompanion(target: Symbol)(implicit ctx: Context) =
-      if (exists && target.exists && !unforcedIsAbsent && !target.unforcedIsAbsent &&
-          !myAnnotations.exists(_.symbol == defn.LinkedTypeAnnot))
-        addAnnotation(Annotation.LinkedType(target.typeRef))
+    /** 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.
@@ -982,20 +983,12 @@ object SymDenotations {
             }
           case None => NoSymbol
         }
-      else
-        getAnnotation(defn.LinkedTypeAnnot) match {
-          case Some(Annotation.LinkedType(linked: TypeRef)) =>
-            linked.symbol.sourceModule
-          case _ => NoSymbol
-        }
+      else registeredCompanion.sourceModule
 
     private def companionType(implicit ctx: Context): Symbol =
       if (is(Package)) NoSymbol
       else if (is(ModuleVal)) moduleClass.denot.companionType
-      else getAnnotation(defn.LinkedTypeAnnot) match {
-        case Some(Annotation.LinkedType(linked: TypeRef)) => linked.symbol
-        case _ => NoSymbol
-      }
+      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.
@@ -1287,6 +1280,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
     }
 
@@ -1853,6 +1847,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/tasty/TreePickler.scala

@@ -619,7 +619,7 @@ class TreePickler(pickler: TastyPickler) {
       // See tests/pickling/i3149.scala
     case _ =>
       val sym = ann.symbol
-      sym == defn.BodyAnnot || sym == defn.OpaqueAliasAnnot || sym == defn.LinkedTypeAnnot
+      sym == defn.BodyAnnot || sym == defn.OpaqueAliasAnnot
         // these are reconstituted automatically when unpickling
   }
 

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

@@ -742,7 +742,7 @@ class TreeUnpickler(reader: TastyReader,
             // be missing from the Tasty file. So we check explicitly for that.
             def isCodefined = roots.contains(companion.denot) == seenRoots.contains(companion)
 
-            if (companion.canHaveCompanion && isCodefined) sym.registerCompanion(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

@@ -121,14 +121,13 @@ object Scala2Unpickler {
 
     def registerCompanionPair(module: Symbol, claz: Symbol) = {
       module.registerCompanion(claz)
-      if (claz.isClass) claz.registerCompanion(module)
+      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/printing/RefinedPrinter.scala

@@ -694,11 +694,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     Text(annotations.map(annotText), " ") ~~ flagsText ~~ (Str(kw) provided !suppressKw)
   }
 
-  protected def filterModTextAnnots(annots: List[untpd.Tree]): List[untpd.Tree] =
-    annots filter {
-      case tpt: TypeTree[_] => tpt.typeOpt.typeSymbol != defn.LinkedTypeAnnot
-      case _ => true
-    }
+  protected def filterModTextAnnots(annots: List[untpd.Tree]): List[untpd.Tree] = annots
 
   def optText(name: Name)(encl: Text => Text): Text =
     if (name.isEmpty) "" else encl(toText(name))

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

@@ -620,11 +620,9 @@ 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 (modl.isClass && claz.canHaveCompanion) {
-        modl.registerCompanion(claz)
-        claz.registerCompanion(modl)
-      }
-    }
+      modl.registerCompanion(claz)
+      claz.registerCompanion(modl)
+   }
 
     def createCompanionLinks(implicit ctx: Context): Unit = {
       val classDef  = mutable.Map[TypeName, TypeDef]()