Streamline some hot compuations

Make it cheaper to compute whether a Period is Nowhere, and also make the
symbol and denot computations on NamedType as small as possible.

Author: odersky

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

@@ -118,7 +118,12 @@ object Periods {
       apply(rid, 0, PhaseMask)
   }
 
-  final val Nowhere: Period = new Period(0)
+  inline val NowhereCode = 0
+
+  final val Nowhere: Period = new Period(NowhereCode)
+
+  extension (p: Period)
+    inline def exists: Boolean = p.code != NowhereCode
 
   final val InitialPeriod: Period = Period(InitialRunId, FirstPhaseId)
 

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

@@ -2263,15 +2263,17 @@ object Types {
     final def symbol(using Context): Symbol =
       // We can rely on checkedPeriod (unlike in the definition of `denot` below)
       // because SymDenotation#installAfter never changes the symbol
-      if (checkedPeriod == ctx.period) lastSymbol.nn else computeSymbol
+      if (checkedPeriod == ctx.period) lastSymbol.asInstanceOf[Symbol]
+      else computeSymbol
 
     private def computeSymbol(using Context): Symbol =
-      designator match {
+      val result = designator match
         case sym: Symbol =>
           if (sym.isValidInCurrentRun) sym else denot.symbol
         case name =>
-          (if (denotationIsCurrent) lastDenotation.nn else denot).symbol
-      }
+          (if (denotationIsCurrent) lastDenotation.asInstanceOf[Denotation] else denot).symbol
+      if checkedPeriod.exists then checkedPeriod = ctx.period
+      result
 
     /** There is a denotation computed which is valid (somewhere in) the
      *  current run.
@@ -2303,18 +2305,16 @@ object Types {
 
     def info(using Context): Type = denot.info
 
-    /** The denotation currently denoted by this type */
-    final def denot(using Context): Denotation = {
+    /** The denotation currently denoted by this type. Extremely hot. Carefully optimized
+     *  to be as small as possible.
+     */
+    final def denot(using Context): Denotation =
       util.Stats.record("NamedType.denot")
-      val now = ctx.period
+      val lastd = lastDenotation.asInstanceOf[Denotation]
       // Even if checkedPeriod == now we still need to recheck lastDenotation.validFor
       // as it may have been mutated by SymDenotation#installAfter
-      if (checkedPeriod != Nowhere && lastDenotation.nn.validFor.contains(now)) {
-        checkedPeriod = now
-        lastDenotation.nn
-      }
+      if checkedPeriod.code != NowhereCode && lastd.validFor.contains(ctx.period) then lastd
       else computeDenot
-    }
 
     private def computeDenot(using Context): Denotation = {
       util.Stats.record("NamedType.computeDenot")
@@ -2350,11 +2350,11 @@ object Types {
       lastDenotation match {
         case lastd0: SingleDenotation =>
           val lastd = lastd0.skipRemoved
-          if lastd.validFor.runId == ctx.runId && checkedPeriod != Nowhere then
+          if lastd.validFor.runId == ctx.runId && checkedPeriod.exists then
             finish(lastd.current)
           else lastd match {
             case lastd: SymDenotation =>
-              if (stillValid(lastd) && (checkedPeriod != Nowhere)) finish(lastd.current)
+              if stillValid(lastd) && checkedPeriod.exists then finish(lastd.current)
               else finish(memberDenot(lastd.initial.name, allowPrivate = false))
             case _ =>
               fromDesignator