Keep using frozen_=:=, copy annotations symbols in PostTyper

compiler/src/dotty/tools/dotc/ast/TreeTypeMap.scala

@@ -21,6 +21,9 @@ import Decorators.*
  *  @param newOwners New owners, replacing previous owners.
  *  @param substFrom The symbols that need to be substituted.
  *  @param substTo   The substitution targets.
+ *  @param cpy       A tree copier that is used to create new trees.
+ *  @param alwaysCopySymbols If set, symbols are always copied, even when they
+ *                           are not impacted by the transformation.
  *
  *  The reason the substitution is broken out from the rest of the type map is
  *  that all symbols have to be substituted at the same time. If we do not do this,
@@ -38,7 +41,9 @@ class TreeTypeMap(
   val newOwners: List[Symbol] = Nil,
   val substFrom: List[Symbol] = Nil,
   val substTo: List[Symbol] = Nil,
-  cpy: tpd.TreeCopier = tpd.cpy)(using Context) extends tpd.TreeMap(cpy) {
+  cpy: tpd.TreeCopier = tpd.cpy,
+  alwaysCopySymbols: Boolean = false,
+)(using Context) extends tpd.TreeMap(cpy) {
   import tpd.*
 
   def copy(
@@ -48,7 +53,7 @@ class TreeTypeMap(
       newOwners: List[Symbol],
       substFrom: List[Symbol],
       substTo: List[Symbol])(using Context): TreeTypeMap =
-    new TreeTypeMap(typeMap, treeMap, oldOwners, newOwners, substFrom, substTo)
+    new TreeTypeMap(typeMap, treeMap, oldOwners, newOwners, substFrom, substTo, cpy, alwaysCopySymbols)
 
   /** If `sym` is one of `oldOwners`, replace by corresponding symbol in `newOwners` */
   def mapOwner(sym: Symbol): Symbol = sym.subst(oldOwners, newOwners)
@@ -202,7 +207,7 @@ class TreeTypeMap(
    *  between original and mapped symbols.
    */
   def withMappedSyms(syms: List[Symbol]): TreeTypeMap =
-    withMappedSyms(syms, mapSymbols(syms, this))
+    withMappedSyms(syms, mapSymbols(syms, this, mapAlways = alwaysCopySymbols))
 
   /** The tree map with the substitution between originals `syms`
    *  and mapped symbols `mapped`. Also goes into mapped classes
@@ -224,6 +229,10 @@ class TreeTypeMap(
         tmap1
       }
 
+  def withAlwaysCopySymbols: TreeTypeMap =
+    if alwaysCopySymbols then this
+    else new TreeTypeMap(typeMap, treeMap, oldOwners, newOwners, substFrom, substTo, cpy, alwaysCopySymbols = true)
+
   override def toString =
     def showSyms(syms: List[Symbol]) =
       syms.map(sym => s"$sym#${sym.id}").mkString(", ")

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

@@ -66,17 +66,15 @@ object Annotations {
             if tm.isRange(x) then x
             else
               val tp1 = tm(tree.tpe)
-              foldOver(if tp1 == tree.tpe then x else tp1, tree)
+              foldOver(if !tp1.exists || (tp1 frozen_=:= tree.tpe) then x else tp1, tree)
         val diff = findDiff(NoType, args)
         if tm.isRange(diff) then EmptyAnnotation
         else if diff.exists then
-          // In case of changes, the symbol in the annotation's tree should be
-          // copied so that the same symbol is not used for different trees.
-          val ttm =
-            new TreeTypeMap(typeMap = tm):
-              final override def withMappedSyms(syms: List[Symbol]): TreeTypeMap =
-                withMappedSyms(syms, mapSymbols(syms, this, mapAlways = true))
-          derivedAnnotation(ttm.transform(tree))
+          // If the annotation has been transformed, we need to make sure that the
+          // symbol are copied so that we don't end up with the same symbol in different
+          // trees, which would lead to a crash in pickling.
+          val mappedTree = TreeTypeMap(typeMap = tm, alwaysCopySymbols = true).transform(tree)
+          derivedAnnotation(mappedTree)
         else this
 
     /** Does this annotation refer to a parameter of `tl`? */

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

@@ -2,7 +2,7 @@ package dotty.tools
 package dotc
 package transform
 
-import dotty.tools.dotc.ast.{Trees, tpd, untpd, desugar}
+import dotty.tools.dotc.ast.{Trees, TreeTypeMap, tpd, untpd, desugar}
 import scala.collection.mutable
 import core.*
 import dotty.tools.dotc.typer.Checking
@@ -157,7 +157,14 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase =>
       val saved = inJavaAnnot
       inJavaAnnot = annot.symbol.is(JavaDefined)
       if (inJavaAnnot) checkValidJavaAnnotation(annot)
-      try transform(annot)
+      try
+        val res = transform(annot)
+        if res ne annot then
+          // If the annotation has been transformed, we need to make sure that the
+          // symbol are copied so that we don't end up with the same symbol in different
+          // trees, which would lead to a crash in pickling.
+          TreeTypeMap(alwaysCopySymbols = true)(res)
+        else res
       finally inJavaAnnot = saved
     }
 

tests/pos/annot-17939c.scala

@@ -0,0 +1,5 @@
+class qualified(f: Int => Boolean) extends annotation.StaticAnnotation
+class Box[T](val y: T)
+def Test =
+  val x: String @qualified((x: Int) => Box(42).y == 2) = ???
+  val y = x