Cleanup retains annotations in PostTyper

Author: Linyxus

compiler/src/dotty/tools/dotc/cc/Setup.scala

@@ -454,7 +454,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
           case _ => false
 
         def signatureChanges =
-          tree.tpt.hasRememberedType && !sym.isConstructor || paramSignatureChanges
+          (tree.tpt.hasRememberedType || tree.tpt.isInstanceOf[InferredTypeTree]) && !sym.isConstructor || paramSignatureChanges
 
         // Replace an existing symbol info with inferred types where capture sets of
         // TypeParamRefs and TermParamRefs put in correspondence by BiTypeMaps with the

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

@@ -19,6 +19,7 @@ import config.Feature
 import util.SrcPos
 import reporting.*
 import NameKinds.WildcardParamName
+import cc.*
 
 object PostTyper {
   val name: String = "posttyper"
@@ -279,6 +280,17 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase =>
       if !tree.symbol.is(Package) then tree
       else errorTree(tree, em"${tree.symbol} cannot be used as a type")
 
+    // Cleans up retains annotations in inferred type trees. This is needed because
+    // during the typer, it is infeasible to correctly infer the capture sets in most
+    // cases, resulting ill-formed capture sets that could crash the pickler later on.
+    // See #20035.
+    private def cleanupRetainsAnnot(symbol: Symbol, tpt: Tree)(using Context): Tree =
+      tpt match
+        case tpt: InferredTypeTree if !symbol.allOverriddenSymbols.hasNext =>
+          val tpe1 = cleanupRetains(tpt.tpe) 
+          tpt.withType(tpe1)
+        case _ => tpt
+
     override def transform(tree: Tree)(using Context): Tree =
       try tree match {
         // TODO move CaseDef case lower: keep most probable trees first for performance
@@ -388,7 +400,7 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase =>
           registerIfHasMacroAnnotations(tree)
           checkErasedDef(tree)
           Checking.checkPolyFunctionType(tree.tpt)
-          val tree1 = cpy.ValDef(tree)(rhs = normalizeErasedRhs(tree.rhs, tree.symbol))
+          val tree1 = cpy.ValDef(tree)(tpt = cleanupRetainsAnnot(tree.symbol, tree.tpt), rhs = normalizeErasedRhs(tree.rhs, tree.symbol))
           if tree1.removeAttachment(desugar.UntupledParam).isDefined then
             checkStableSelection(tree.rhs)
           processValOrDefDef(super.transform(tree1))
@@ -398,7 +410,7 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase =>
           checkErasedDef(tree)
           Checking.checkPolyFunctionType(tree.tpt)
           annotateContextResults(tree)
-          val tree1 = cpy.DefDef(tree)(rhs = normalizeErasedRhs(tree.rhs, tree.symbol))
+          val tree1 = cpy.DefDef(tree)(tpt = cleanupRetainsAnnot(tree.symbol, tree.tpt), rhs = normalizeErasedRhs(tree.rhs, tree.symbol))
           processValOrDefDef(superAcc.wrapDefDef(tree1)(super.transform(tree1).asInstanceOf[DefDef]))
         case tree: TypeDef =>
           registerIfHasMacroAnnotations(tree)

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -2187,12 +2187,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
             errorTree(tree, em"Something's wrong: missing original symbol for type tree")
         }
       case _ =>
-        val pt1 = cleanupRetains(pt)
-          // Cleans up retains annotations in inferred type trees. This is needed because
-          // during the typer, it is infeasible to correctly infer the capture sets in most
-          // cases, resulting ill-formed capture sets that could crash the pickler later on.
-          // See #20035.
-        completeTypeTree(InferredTypeTree(), pt1, tree)
+        completeTypeTree(InferredTypeTree(), pt, tree)
 
   def typedInLambdaTypeTree(tree: untpd.InLambdaTypeTree, pt: Type)(using Context): Tree =
     val tp =

tests/neg-custom-args/captures/byname.check

@@ -9,7 +9,7 @@
    |  Found:    (x$0: Int) ->{cap2} Int
    |  Required: (x$0: Int) -> Int
    |
-   |  Note that the expected type Int => Int
+   |  Note that the expected type Int -> Int
    |  is the previously inferred result type of method test
    |  which is also the type seen in separately compiled sources.
    |  The new inferred type (x$0: Int) ->{cap2} Int