Collect checks to run in CrossVersionChecks

Check for deprecation when inlining or constant folding,
but avoid cyclic errors by deferring the exclusion check,
which walks the owner chain, until CrossVersionChecks,
where the check normally happens.

Author: som-snytt

Diff for: compiler/src/dotty/tools/dotc/core/Constants.scala

@@ -2,12 +2,13 @@ package dotty.tools
 package dotc
 package core
 
-import Types._, Symbols._, Contexts._
+import Types.*, Symbols.*, Contexts.*
 import printing.Printer
 import printing.Texts.Text
 
-object Constants {
+object Constants:
 
+  type Tag              = Int
   inline val NoTag      = 0
   inline val UnitTag    = 1
   inline val BooleanTag = 2
@@ -22,7 +23,7 @@ object Constants {
   inline val NullTag    = 11
   inline val ClazzTag   = 12
 
-  class Constant(val value: Any, val tag: Int) extends printing.Showable with Product1[Any] {
+  class Constant(val value: Any, val tag: Tag) extends printing.Showable with Product1[Any]:
     import java.lang.Double.doubleToRawLongBits
     import java.lang.Float.floatToRawIntBits
 
@@ -223,9 +224,8 @@ object Constants {
     def get: Any                  = value
     def isEmpty: Boolean          = false
     def _1: Any                   = value
-  }
 
-  object Constant {
+  object Constant:
     def apply(x: Null): Constant         = new Constant(x, NullTag)
     def apply(x: Unit): Constant         = new Constant(x, UnitTag)
     def apply(x: Boolean): Constant      = new Constant(x, BooleanTag)
@@ -257,5 +257,5 @@ object Constants {
       )
 
     def unapply(c: Constant): Constant = c
-  }
-}
+
+  end Constant

Diff for: compiler/src/dotty/tools/dotc/core/Contexts.scala

@@ -23,7 +23,7 @@ import config.Config
 import reporting._
 import io.{AbstractFile, NoAbstractFile, PlainFile, Path}
 import scala.io.Codec
-import collection.mutable
+import collection.mutable, mutable.ArrayBuffer
 import printing._
 import config.{JavaPlatform, SJSPlatform, Platform, ScalaSettings}
 import classfile.ReusableDataReader
@@ -52,8 +52,10 @@ object Contexts {
   private val (notNullInfosLoc,     store8) = store7.newLocation[List[NotNullInfo]]()
   private val (importInfoLoc,       store9) = store8.newLocation[ImportInfo | Null]()
   private val (typeAssignerLoc,    store10) = store9.newLocation[TypeAssigner](TypeAssigner)
+  private val (usagesLoc,          store11) = store10.newLocation[Any]()          // unusages feature
+  private val (deferredChecksLoc,  store12) = store11.newLocation[DeferredChecks]()
 
-  private val initialStore = store10
+  private val initialStore = store12
 
   /** The current context */
   inline def ctx(using ctx: Context): Context = ctx
@@ -93,6 +95,9 @@ object Contexts {
   inline def atPhaseNoEarlier[T](limit: Phase)(inline op: Context ?=> T)(using Context): T =
     op(using if !limit.exists || limit <= ctx.phase then ctx else ctx.withPhase(limit))
 
+  inline def deferredCheck(phase: String)(inline op: Context ?=> Unit)(using Context): Unit =
+    ctx.deferredChecks.add(phase)(op)
+
   inline def inMode[T](mode: Mode)(inline op: Context ?=> T)(using ctx: Context): T =
     op(using if mode != ctx.mode then ctx.fresh.setMode(mode) else ctx)
 
@@ -239,6 +244,8 @@ object Contexts {
     /** The current type assigner or typer */
     def typeAssigner: TypeAssigner = store(typeAssignerLoc)
 
+    def deferredChecks: DeferredChecks = store(deferredChecksLoc)
+
     /** The new implicit references that are introduced by this scope */
     protected var implicitsCache: ContextualImplicits | Null = null
     def implicits: ContextualImplicits = {
@@ -812,6 +819,7 @@ object Contexts {
     store = initialStore
       .updated(settingsStateLoc, settingsGroup.defaultState)
       .updated(notNullInfosLoc, Nil)
+      .updated(deferredChecksLoc, DeferredChecks())
       .updated(compilationUnitLoc, NoCompilationUnit)
     searchHistory = new SearchRoot
     gadt = EmptyGadtConstraint
@@ -954,13 +962,13 @@ object Contexts {
 
     protected[dotc] val indentTab: String = "  "
 
-    private[Contexts] val exploreContexts = new mutable.ArrayBuffer[FreshContext]
+    private[Contexts] val exploreContexts = ArrayBuffer.empty[FreshContext]
     private[Contexts] var exploresInUse: Int = 0
 
-    private[Contexts] val changeOwnerContexts = new mutable.ArrayBuffer[FreshContext]
+    private[Contexts] val changeOwnerContexts = ArrayBuffer.empty[FreshContext]
     private[Contexts] var changeOwnersInUse: Int = 0
 
-    private[Contexts] val comparers = new mutable.ArrayBuffer[TypeComparer]
+    private[Contexts] val comparers = ArrayBuffer.empty[TypeComparer]
     private[Contexts] var comparersInUse: Int = 0
 
     private var charArray = new Array[Char](256)
@@ -996,4 +1004,15 @@ object Contexts {
       if (thread == null) thread = Thread.currentThread()
       else assert(thread == Thread.currentThread(), "illegal multithreaded access to ContextBase")
   }
+
+  class DeferredChecks:
+    private val checks = mutable.Map[String, ArrayBuffer[Context ?=> Unit]]()
+
+    def add(phase: String)(item: Context ?=> Unit): Unit = checks.getOrElseUpdate(phase, ArrayBuffer.empty).addOne(item)
+
+    def run(phase: String)(using Context): Unit =
+      for items <- checks.remove(phase) do
+        for item <- items do
+          item
+  end DeferredChecks
 }

Diff for: compiler/src/dotty/tools/dotc/core/Phases.scala

@@ -57,10 +57,10 @@ object Phases {
     final def phasePlan: List[List[Phase]] = this.phasesPlan
     final def setPhasePlan(phasess: List[List[Phase]]): Unit = this.phasesPlan = phasess
 
-    /** Squash TreeTransform's beloning to same sublist to a single TreeTransformer
-      * Each TreeTransform gets own period,
-      * whereas a combined TreeTransformer gets period equal to union of periods of it's TreeTransforms
-      */
+    /** Squash TreeTransforms that belong to same sublist to a single TreeTransformer.
+     *  Each TreeTransform gets own period,
+     *  whereas a combined TreeTransformer gets period equal to union of periods of its TreeTransforms.
+     */
     final def fusePhases(phasess: List[List[Phase]],
                            phasesToSkip: List[String],
                            stopBeforePhases: List[String],

Diff for: compiler/src/dotty/tools/dotc/inlines/Inlines.scala

@@ -86,6 +86,7 @@ object Inlines:
       if (tree.symbol == defn.CompiletimeTesting_typeCheckErrors) return Intrinsics.typeCheckErrors(tree)
 
     CrossVersionChecks.checkExperimentalRef(tree.symbol, tree.srcPos)
+    CrossVersionChecks.checkDeprecatedDeferred(tree.symbol, tree.srcPos)
 
     if tree.symbol.isConstructor then return tree // error already reported for the inline constructor definition