Use SymbolImpl in all Denotation class parameters

Use SymbolImpl instead of Symbol in all Denotation class parameters.
This is necessary to avoid cyclic references when Symbols are made
subclasses of SymDenotations.

Author: odersky

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

@@ -176,9 +176,11 @@ object Denotations {
    *
    *  @param symbol  The referencing symbol, or NoSymbol is none exists
    */
-  abstract class Denotation(val symbol: Symbol, protected var myInfo: Type) extends PreDenotation with printing.Showable {
+  abstract class Denotation(_symbol: SymbolImpl, protected var myInfo: Type) extends PreDenotation with printing.Showable {
     type AsSeenFromResult <: Denotation
 
+    val symbol: Symbol = _symbol.fromSymbolImpl
+
     /** The type info.
      *  The info is an instance of TypeType iff this is a type denotation
      *  Uncompleted denotations set myInfo to a LazyType.
@@ -477,7 +479,7 @@ object Denotations {
             val jointInfo = infoMeet(info1, info2, safeIntersection)
             if jointInfo.exists then
               val sym = if symScore >= 0 then sym1 else sym2
-              JointRefDenotation(sym, jointInfo, denot1.validFor & denot2.validFor, pre)
+              JointRefDenotation(sym.toSymbolImpl, jointInfo, denot1.validFor & denot2.validFor, pre)
             else if symScore == 2 then denot1
             else if symScore == -2 then denot2
             else
@@ -568,7 +570,7 @@ object Denotations {
   end infoMeet
 
   /** A non-overloaded denotation */
-  abstract class SingleDenotation(symbol: Symbol, initInfo: Type) extends Denotation(symbol, initInfo) {
+  abstract class SingleDenotation(_symbol: SymbolImpl, initInfo: Type) extends Denotation(_symbol, initInfo) {
     protected def newLikeThis(symbol: Symbol, info: Type, pre: Type): SingleDenotation
 
     final def name(using Context): Name = symbol.name
@@ -1077,34 +1079,34 @@ object Denotations {
     }
   }
 
-  abstract class NonSymSingleDenotation(symbol: Symbol, initInfo: Type, override val prefix: Type) extends SingleDenotation(symbol, initInfo) {
+  abstract class NonSymSingleDenotation(_symbol: SymbolImpl, initInfo: Type, override val prefix: Type) extends SingleDenotation(_symbol, initInfo) {
     def infoOrCompleter: Type = initInfo
     def isType: Boolean = infoOrCompleter.isInstanceOf[TypeType]
   }
 
   class UniqueRefDenotation(
-    symbol: Symbol,
+    _symbol: SymbolImpl,
     initInfo: Type,
     initValidFor: Period,
-    prefix: Type) extends NonSymSingleDenotation(symbol, initInfo, prefix) {
+    prefix: Type) extends NonSymSingleDenotation(_symbol, initInfo, prefix) {
     validFor = initValidFor
     override def hasUniqueSym: Boolean = true
     protected def newLikeThis(s: Symbol, i: Type, pre: Type): SingleDenotation =
-      new UniqueRefDenotation(s, i, validFor, pre)
+      new UniqueRefDenotation(s.toSymbolImpl, i, validFor, pre)
   }
 
   class JointRefDenotation(
-    symbol: Symbol,
+    _symbol: SymbolImpl,
     initInfo: Type,
     initValidFor: Period,
-    prefix: Type) extends NonSymSingleDenotation(symbol, initInfo, prefix) {
+    prefix: Type) extends NonSymSingleDenotation(_symbol, initInfo, prefix) {
     validFor = initValidFor
     override def hasUniqueSym: Boolean = false
     protected def newLikeThis(s: Symbol, i: Type, pre: Type): SingleDenotation =
-      new JointRefDenotation(s, i, validFor, pre)
+      new JointRefDenotation(s.toSymbolImpl, i, validFor, pre)
   }
 
-  class ErrorDenotation(using Context) extends NonSymSingleDenotation(NoSymbol, NoType, NoType) {
+  class ErrorDenotation(using Context) extends NonSymSingleDenotation(NoSymbol.toSymbolImpl, NoType, NoType) {
     override def exists: Boolean = false
     override def hasUniqueSym: Boolean = false
     validFor = Period.allInRun(ctx.runId)
@@ -1171,7 +1173,7 @@ object Denotations {
 
   /** An overloaded denotation consisting of the alternatives of both given denotations.
    */
-  case class MultiDenotation(denot1: Denotation, denot2: Denotation) extends Denotation(NoSymbol, NoType) with MultiPreDenotation {
+  case class MultiDenotation(denot1: Denotation, denot2: Denotation) extends Denotation(NoSymbol.toSymbolImpl, NoType) with MultiPreDenotation {
     final def infoOrCompleter: Type = multiHasNot("info")
     final def validFor: Period = denot1.validFor & denot2.validFor
     final def isType: Boolean = false

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

@@ -33,15 +33,17 @@ object SymDenotations {
    *  during a period.
    */
   class SymDenotation private[SymDenotations] (
-    symbol: Symbol,
-    final val maybeOwner: Symbol,
+    _symbol: SymbolImpl,
+    final val _maybeOwner: SymbolImpl,
     final val name: Name,
     initFlags: FlagSet,
     initInfo: Type,
-    initPrivateWithin: Symbol = NoSymbol) extends SingleDenotation(symbol, initInfo) {
+    initPrivateWithin: SymbolImpl = NoSymbol.toSymbolImpl) extends SingleDenotation(_symbol, initInfo) {
 
     //assert(symbol.id != 4940, name)
 
+    final val maybeOwner: Symbol = _maybeOwner.fromSymbolImpl
+
     override def hasUniqueSym: Boolean = exists
 
     /** Debug only
@@ -54,7 +56,7 @@ object SymDenotations {
     // ------ Getting and setting fields -----------------------------
 
     private var myFlags: FlagSet = adaptFlags(initFlags)
-    private var myPrivateWithin: Symbol = initPrivateWithin
+    private var myPrivateWithin: Symbol = initPrivateWithin.fromSymbolImpl
     private var myAnnotations: List[Annotation] = Nil
     private var myParamss: List[List[Symbol]] = Nil
 
@@ -1498,7 +1500,7 @@ object SymDenotations {
     // ----- copies and transforms  ----------------------------------------
 
     protected def newLikeThis(s: Symbol, i: Type, pre: Type): SingleDenotation =
-      new UniqueRefDenotation(s, i, validFor, pre)
+      new UniqueRefDenotation(s.toSymbolImpl, i, validFor, pre)
 
     /** Copy this denotation, overriding selective fields */
     final def copySymDenotation(
@@ -2208,13 +2210,13 @@ object SymDenotations {
   /** The contents of a class definition during a period
    */
   class ClassDenotationImpl private[SymDenotations] (
-    symbol: Symbol,
-    maybeOwner: Symbol,
+    _symbol: SymbolImpl,
+    _maybeOwner: SymbolImpl,
     name: Name,
     initFlags: FlagSet,
     initInfo: Type,
-    initPrivateWithin: Symbol)
-    extends SymDenotation(symbol, maybeOwner, name, initFlags, initInfo, initPrivateWithin),
+    initPrivateWithin: SymbolImpl)
+    extends SymDenotation(_symbol, _maybeOwner, name, initFlags, initInfo, initPrivateWithin),
       ClassDenotation
 
   /** The denotation of a package class.
@@ -2381,18 +2383,18 @@ object SymDenotations {
   end PackageClassDenotation
 
   class PackageClassDenotationImpl private[SymDenotations] (
-    symbol: Symbol,
-    ownerIfExists: Symbol,
+    _symbol: SymbolImpl,
+    _maybeOwner: SymbolImpl,
     name: Name,
     initFlags: FlagSet,
     initInfo: Type,
-    initPrivateWithin: Symbol)
+    initPrivateWithin: SymbolImpl)
     extends
-      ClassDenotationImpl(symbol, ownerIfExists, name, initFlags, initInfo, initPrivateWithin),
+      ClassDenotationImpl(_symbol, _maybeOwner, name, initFlags, initInfo, initPrivateWithin),
       PackageClassDenotation
 
   @sharable object NoDenotation
-  extends SymDenotation(NoSymbol, NoSymbol, "<none>".toTermName, Permanent, NoType) {
+  extends SymDenotation(NoSymbol.toSymbolImpl, NoSymbol.toSymbolImpl, "<none>".toTermName, Permanent, NoType) {
     override def isType: Boolean = false
     override def isTerm: Boolean = false
     override def exists: Boolean = false
@@ -2434,9 +2436,9 @@ object SymDenotations {
     initPrivateWithin: Symbol = NoSymbol)(using Context): SymDenotation = {
     val result =
       if (symbol.isClass)
-        if (initFlags.is(Package)) new PackageClassDenotationImpl(symbol, owner, name, initFlags, initInfo, initPrivateWithin)
-        else new ClassDenotationImpl(symbol, owner, name, initFlags, initInfo, initPrivateWithin)
-      else new SymDenotation(symbol, owner, name, initFlags, initInfo, initPrivateWithin)
+        if (initFlags.is(Package)) new PackageClassDenotationImpl(symbol.toSymbolImpl, owner.toSymbolImpl, name, initFlags, initInfo, initPrivateWithin.toSymbolImpl)
+        else new ClassDenotationImpl(symbol.toSymbolImpl, owner.toSymbolImpl, name, initFlags, initInfo, initPrivateWithin.toSymbolImpl)
+      else new SymDenotation(symbol.toSymbolImpl, owner.toSymbolImpl, name, initFlags, initInfo, initPrivateWithin.toSymbolImpl)
     result.validFor = currentStablePeriod
     result
   }

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

@@ -45,6 +45,9 @@ object Symbols {
   type TermSymbol = Symbol { type ThisName = TermName }
   type TypeSymbol = Symbol { type ThisName = TypeName }
 
+  extension (sym: Symbol) def toSymbolImpl: SymbolImpl = sym
+  extension (sym: SymbolImpl) def fromSymbolImpl: Symbol = sym
+
   implicit def eqSymbol: CanEqual[Symbol, Symbol] = CanEqual.derived
 
   /** Tree attachment containing the identifiers in a tree as a sorted array */

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

@@ -757,7 +757,7 @@ object Types {
         }
         else
           val joint = pdenot.meet(
-            new JointRefDenotation(NoSymbol, rinfo, Period.allInRun(ctx.runId), pre),
+            new JointRefDenotation(NoSymbol.toSymbolImpl, rinfo, Period.allInRun(ctx.runId), pre),
             pre,
             safeIntersection = ctx.base.pendingMemberSearches.contains(name))
           joint match
@@ -814,7 +814,7 @@ object Types {
       def goSuper(tp: SuperType) = go(tp.underlying) match {
         case d: JointRefDenotation =>
           typr.println(i"redirecting super.$name from $tp to ${d.symbol.showLocated}")
-          new UniqueRefDenotation(d.symbol, tp.memberInfo(d.symbol), d.validFor, pre)
+          new UniqueRefDenotation(d.symbol.toSymbolImpl, tp.memberInfo(d.symbol), d.validFor, pre)
         case d => d
       }
 
@@ -4681,7 +4681,7 @@ object Types {
         // also other information about the named type (e.g. bounds).
         contains(
           TypeRef(tp.prefix, cls)
-            .withDenot(new UniqueRefDenotation(cls, tp, cls.validFor, tp.prefix)))
+            .withDenot(new UniqueRefDenotation(cls.toSymbolImpl, tp, cls.validFor, tp.prefix)))
       case _ =>
         lo <:< tp && tp <:< hi
     }

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

@@ -112,7 +112,7 @@ class Erasure extends Phase with DenotTransformer {
       }
     case ref: JointRefDenotation =>
       new UniqueRefDenotation(
-        ref.symbol, transformInfo(ref.symbol, ref.symbol.info), ref.validFor, ref.prefix)
+        ref.symbol.toSymbolImpl, transformInfo(ref.symbol, ref.symbol.info), ref.validFor, ref.prefix)
     case _ =>
       ref.derivedSingleDenotation(ref.symbol, transformInfo(ref.symbol, ref.symbol.info))
   }