Support on-demand Symbol.defTree synchronization

In the current compiler, the defTree associated with a symbol becomes
out-of-sync when we transform the trees. This creates a problem for
all analysis that depend on Symbol.defTree.

An analysis that depend on tasty should perform the analysis
immediately after the picklerPhases --- as it has to handle trees
loaded from Tasty which are without any lowering.

Analysis that do not cross boundaries of compilation units
(e.g. linters) are not subject to the restriction above.

Author: liufengyun

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

@@ -105,6 +105,10 @@ object Phases {
               prevPhases += phase.phaseName
               phase
             }
+
+          // synchronize symbol.defTree if necessary
+          if phaseToAdd.synchronizeDefTree then
+            fusedPhases += new SyncDefTree
           fusedPhases += phaseToAdd
           val shouldAddYCheck = YCheckAfter.containsPhase(phaseToAdd) || YCheckAll
           if (shouldAddYCheck) {
@@ -290,9 +294,16 @@ object Phases {
     /** If set, implicit search is enabled */
     def allowsImplicitSearch: Boolean = false
 
-     /** List of names of phases that should precede this phase */
+    /** List of names of phases that should precede this phase */
     def runsAfter: Set[String] = Set.empty
 
+    /** Whether this phase require synchronization of symbol.defTree?
+     *
+     *  The phase `DefTreeSync` will be inserted immediately before this phase
+     *  if `synchronizeDefTree == true`.
+     */
+    def synchronizeDefTree: Boolean = false
+
     /** @pre `isRunnable` returns true */
     def run(using Context): Unit
 

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

@@ -144,6 +144,8 @@ class MegaPhase(val miniPhases: Array[MiniPhase]) extends Phase {
   private var relaxedTypingCache: Boolean = _
   private var relaxedTypingKnown = false
 
+  override val synchronizeDefTree: Boolean = miniPhases.exists(_.synchronizeDefTree)
+
   override final def relaxedTyping: Boolean = {
     if (!relaxedTypingKnown) {
       relaxedTypingCache = miniPhases.exists(_.relaxedTypingInGroup)

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

@@ -0,0 +1,42 @@
+package dotty.tools.dotc
+package transform
+
+
+import dotty.tools.dotc._
+import ast.tpd
+  import tpd._
+
+import dotty.tools.dotc.core._
+import Contexts._
+import Types._
+import Symbols._
+
+import dotty.tools.dotc.transform._
+import MegaPhase._
+
+
+/** Synchronize the tree definition associated with symbols
+ *
+ *  This phase will be automatically inserted before a phase if
+ *  `phase.synchronizeDefTree == true`.
+ *
+ */
+class SyncDefTree extends MiniPhase {
+
+  val phaseName = "syncDefTree"
+
+  override def transformTypeDef(tree: TypeDef)(using Context): Tree = {
+    tree.symbol.defTree = tree
+    tree
+  }
+
+  override def transformValDef(tree: ValDef)(using Context): Tree = {
+    tree.symbol.defTree = tree
+    tree
+  }
+
+  override def transformDefDef(tree: DefDef)(using Context): Tree = {
+    tree.symbol.defTree = tree
+    tree
+  }
+}

compiler/src/dotty/tools/dotc/transform/init/Checker.scala

@@ -30,6 +30,8 @@ class Checker extends MiniPhase {
   override def isEnabled(using Context): Boolean =
     super.isEnabled && ctx.settings.YcheckInit.value
 
+  override def synchronizeDefTree: Boolean = true
+
   override def transformTypeDef(tree: TypeDef)(using Context): tpd.Tree = {
     if (!tree.isClassDef) return tree