Make Symbol and ClassSymbol opaque type aliases

Author: odersky

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

@@ -235,11 +235,8 @@ object Denotations {
     private var myValidFor: Period = Nowhere
 
     final def validFor: Period = myValidFor
-    final def validFor_=(p: Period): Unit = {
+    final def validFor_=(p: Period): Unit =
       myValidFor = p
-      if symbol.initialDenot ne null then
-        symbol.initialDenot.checkedPeriod = Nowhere
-    }
 
     /** Is this denotation different from NoDenotation or an ErrorDenotation? */
     def exists: Boolean = true

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

@@ -63,7 +63,7 @@ object Periods {
       //
       // Let's compute:
       //
-      //  lastDiff = X * 2^5 + (l1 - l2) mod 2^5
+      //  lastDiff = X * 2^7 + (l1 - l2) mod 2^7
       //             where X >= 0, X == 0 iff r1 == r2 & l1 - l2 >= 0
       //  result = lastDiff + d2 <= d1
       //  We have:
@@ -103,6 +103,13 @@ object Periods {
     def !=(that: Period): Boolean = this.code != that.code
   }
 
+  /** Same as new Period(p1).contains(new Period(p2)), assuming that p2 is the
+   *  code of a single-phase period.
+   */
+  extension (p1: Int)
+    transparent inline def containsSinglePhasePeriod(p2: Int): Boolean =
+      ((p1 - p2) >>> PhaseWidth) <= (p1 & PhaseMask)
+
   object Period {
 
     /** The single-phase period consisting of given run id and phase id */

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

@@ -80,7 +80,7 @@ object SymDenotations {
     initPrivateWithin: Symbol = NoSymbol)
   extends SingleDenotation(symbolHint, initInfo, name.isTypeName), ParamInfo, SrcPos, Named {
 
-    //assert(symbol.id != 4940, name)
+    //assert(common.id != 9141, name)
 
     override def hasUniqueSym: Boolean = exists
 
@@ -1810,7 +1810,6 @@ object SymDenotations {
 
     /** The last denotation of this symbol */
     var lastDenot: SymDenotation = _
-    var checkedPeriod: Period = Nowhere
 
     /** Overridden in NoSymbol */
     //private[SymDenotations]
@@ -2699,7 +2698,6 @@ object SymDenotations {
     override def filterWithFlags(required: FlagSet, excluded: FlagSet)(using Context): SingleDenotation = this
     override def associatedFile(using Context): AbstractFile | Null = NoSource.file
 
-    NoSymbol.initialDenot = this
     NoSymbol.denot_=(this)
     validFor = Period.allInRun(NoRunId)
   }

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

@@ -37,34 +37,32 @@ import scala.reflect.TypeTest
 
 object Symbols {
 
-  implicit def eqSymbol: CanEqual[Symbol, Symbol] = CanEqual.derived
-
   /** Tree attachment containing the identifiers in a tree as a sorted array */
   val Ids: Property.Key[Array[String]] = new Property.Key
 
-  opaque type Symbl <: ParamInfo & SrcPos & Named & printing.Showable
+  opaque type Symbol <: ParamInfo & SrcPos & Named & printing.Showable
     = SymDenotation
-
-  opaque type ClassSymbl <: Symbl
+  opaque type ClassSymbol <: TypeSymbol
     = ClassDenotation
 
   object TypeTests:
 
-    given SymTest: TypeTest[AnyRef, Symbol] with
-      def unapply(x: AnyRef): Option[x.type & Symbol] = x match
-        case sd: SymDenotation => Some(sd.asInstanceOf)
+    given SymTest: TypeTest[Any, Symbol] with
+      def unapply(x: Any): Option[x.type & Symbol] = x match
+        case sd: SymDenotation => Some(sd.asInstanceOf[x.type & Symbol])
         case _ => None
 
-    given ClsTest: TypeTest[AnyRef, ClassSymbol] with
-      def unapply(x: AnyRef): Option[x.type & ClassSymbol] = x match
-        case cd: ClassDenotation => Some(cd.asInstanceOf)
+    given ClsTest: TypeTest[Any, ClassSymbol] with
+      def unapply(x: Any): Option[x.type & ClassSymbol] = x match
+        case cd: ClassDenotation => Some(cd.asInstanceOf[x.type & ClassSymbol])
         case _ => None
   end TypeTests
 
+  implicit def eqSymbol: CanEqual[Symbol, Symbol] = CanEqual.derived
+
   /** A Symbol represents a Scala definition/declaration or a package.
    *  @param coord  The coordinates of the symbol (a position or an index)
    *  @param id     A unique identifier of the symbol (unique per ContextBase)
-   */
   class Symbol private[Symbols] ()
     extends ParamInfo, SrcPos, Named, printing.Showable {
 
@@ -95,6 +93,7 @@ object Symbols {
 
     override def hashCode(): Int = Symbols.id(this) // for debugging.
   }
+   */
 
   type TermSymbol = Symbol { type ThisName = TermName }
   type TypeSymbol = Symbol { type ThisName = TypeName }
@@ -104,7 +103,7 @@ object Symbols {
     inline def asSymbol: Symbol = x.asInstanceOf[Symbol]
 
   extension (_self: Symbol)
-    def self = _self.initialDenot
+    def self: SymDenotation = _self
 
     private def lastDenot: SymDenotation = self.lastDenot
     private def lastDenot_=(d: SymDenotation): Unit = self.lastDenot = d
@@ -154,20 +153,14 @@ object Symbols {
     private[core] def denot_=(d: SymDenotation): Unit =
       util.Stats.record("Symbol.denot_=")
       lastDenot = d
-      self.checkedPeriod = Nowhere
 
     /** The current denotation of this symbol */
     def denot(using Context): SymDenotation =
       util.Stats.record("Symbol.denot")
       val lastd = lastDenot
-      if self.checkedPeriod.code == ctx.period.code then lastd
-      else computeDenot(lastd)
-
-    def computeDenot(lastd: SymDenotation)(using Context): SymDenotation =
-      util.Stats.record("Symbol.computeDenot")
-      val now = ctx.period
-      self.checkedPeriod = now
-      if lastd.validFor contains now then lastd else recomputeDenot(lastd)
+      if lastd.validFor.code.containsSinglePhasePeriod(ctx.period.code)
+      then lastd
+      else recomputeDenot(lastd)
 
     private def recomputeDenot(lastd: SymDenotation)(using Context): SymDenotation =
       util.Stats.record("Symbol.recomputeDenot")
@@ -454,16 +447,16 @@ object Symbols {
   end extension
 
   type TreeOrProvider = TreeProvider | Tree
-
+/*
   class ClassSymbol private[Symbols] extends Symbol {
 
     util.Stats.record("ClassSymbol")
 
     type ThisName = TypeName
   }
-
+*/
   extension (_self: ClassSymbol)
-    def self = _self.initialDenot
+    def self: ClassDenotation = _self
 
     /** If this is a top-level class and `-Yretain-trees` (or `-from-tasty`) is set.
       * Returns the TypeDef tree (possibly wrapped inside PackageDefs) for this class, otherwise EmptyTree.
@@ -535,16 +528,7 @@ object Symbols {
 
   end extension
 
-  @sharable object NoSymbol extends Symbol {
-    //override def coord = NoCoord
-    //override def id = 0
-    //override def nestingLevel = 0
-    //override def defTree = tpd.EmptyTree
-    //override def associatedFile(using Context): AbstractFile | Null = NoSource.file
-    //override def recomputeDenot(lastd: SymDenotation)(using Context): SymDenotation = NoDenotation
-  }
-
-  NoDenotation // force it in order to set `denot` field of NoSymbol
+  def NoSymbol: Symbol = NoDenotation
 
   /** Makes all denotation operations available on symbols */
   implicit def toDenot(sym: Symbol)(using Context): SymDenotation = sym.denot
@@ -579,11 +563,9 @@ object Symbols {
       privateWithin: Symbol = NoSymbol,
       coord: Coord = NoCoord,
       nestingLevel: Int = ctx.nestingLevel): Symbol { type ThisName = N } = {
-    val sym = new Symbol().asInstanceOf[Symbol { type ThisName = N }]
-    val denot = SymDenotation(sym, SymCommon(coord, ctx.base.nextSymId, nestingLevel), owner, name, flags, info, privateWithin)
-    sym.initialDenot = denot
-    sym.denot_=(denot)
-    sym
+    val sym = SymDenotation(null, SymCommon(coord, ctx.base.nextSymId, nestingLevel), owner, name, flags, info, privateWithin)
+    sym.denot_=(sym)
+    sym.asInstanceOf[Symbol { type ThisName = N }]
   }
 
   /** Create a class symbol from its non-info fields and a function
@@ -598,11 +580,9 @@ object Symbols {
       coord: Coord = NoCoord,
       assocFile: AbstractFile | Null = null)(using Context): ClassSymbol
   = {
-    val cls = new ClassSymbol()
-    val denot = SymDenotation(cls, ClassCommon(coord, ctx.base.nextSymId, ctx.nestingLevel, assocFile), owner, name, flags, NoType, privateWithin)
-    cls.initialDenot = denot
-    cls.denot_=(denot)
-    denot.info = infoFn(cls)
+    val cls = SymDenotation(null, ClassCommon(coord, ctx.base.nextSymId, ctx.nestingLevel, assocFile), owner, name, flags, NoType, privateWithin).asClass
+    cls.denot_=(cls)
+    cls.info = infoFn(cls)
     cls
   }
 

scaladoc/src/dotty/tools/scaladoc/snippets/SnippetCompilerDataCollector.scala

@@ -5,6 +5,7 @@ import scala.quoted._
 import dotty.tools.scaladoc.tasty.SymOps._
 import dotty.tools.dotc.core._
 import dotty.tools.dotc.util.{ SourceFile => CSourceFile, NoSource }
+import Symbols.TypeTests.given
 
 class SnippetCompilerDataCollector[Q <: Quotes](val qctx: Q):
   import qctx.reflect._