Correctly handle meta-annotations for ctor param val/vars.

As a consequence, this fixes #9881.

Author: sjrd

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

@@ -793,10 +793,8 @@ object desugar {
         val originalVparamsIt = originalVparamss.iterator.flatten
         derivedVparamss match {
           case first :: rest =>
-            // Annotations on the class _value_ parameters are not set on the parameter accessors
-            def mods(vdef: ValDef) = vdef.mods.withAnnotations(Nil)
-            first.map(_.withMods(mods(originalVparamsIt.next()) | caseAccessor)) ++
-            rest.flatten.map(_.withMods(mods(originalVparamsIt.next())))
+            first.map(_.withMods(originalVparamsIt.next().mods | caseAccessor)) ++
+            rest.flatten.map(_.withMods(originalVparamsIt.next().mods))
           case _ =>
             Nil
         }

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

@@ -933,13 +933,18 @@ class Definitions {
   @tu lazy val VolatileAnnot: ClassSymbol = requiredClass("scala.volatile")
   @tu lazy val FieldMetaAnnot: ClassSymbol = requiredClass("scala.annotation.meta.field")
   @tu lazy val GetterMetaAnnot: ClassSymbol = requiredClass("scala.annotation.meta.getter")
+  @tu lazy val ParamMetaAnnot: ClassSymbol = requiredClass("scala.annotation.meta.param")
   @tu lazy val SetterMetaAnnot: ClassSymbol = requiredClass("scala.annotation.meta.setter")
   @tu lazy val ShowAsInfixAnnot: ClassSymbol = requiredClass("scala.annotation.showAsInfix")
   @tu lazy val FunctionalInterfaceAnnot: ClassSymbol = requiredClass("java.lang.FunctionalInterface")
   @tu lazy val InfixAnnot: ClassSymbol = requiredClass("scala.annotation.infix")
   @tu lazy val TargetNameAnnot: ClassSymbol = requiredClass("scala.annotation.targetName")
   @tu lazy val VarargsAnnot: ClassSymbol = requiredClass("scala.annotation.varargs")
 
+  // A list of meta-annotations that are relevant for fields and accessors
+  @tu lazy val FieldAccessorMetaAnnots: Set[Symbol] =
+    Set(FieldMetaAnnot, GetterMetaAnnot, ParamMetaAnnot, SetterMetaAnnot)
+
   // A list of annotations that are commonly used to indicate that a field/method argument or return
   // type is not null. These annotations are used by the nullification logic in JavaNullInterop to
   // improve the precision of type nullification.

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

@@ -147,6 +147,14 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
         case tree: ValOrDefDef if !tree.symbol.is(Synthetic) =>
           checkInferredWellFormed(tree.tpt)
           val sym = tree.symbol
+          if sym.is(Method) then
+            if sym.isSetter then
+              removeUnwantedAnnotations(sym, defn.SetterMetaAnnot, NoSymbol, keepIfNoRelevantAnnot = false)
+          else
+            if sym.is(Param) then
+              removeUnwantedAnnotations(sym, defn.ParamMetaAnnot, NoSymbol, keepIfNoRelevantAnnot = true)
+            else
+              removeUnwantedAnnotations(sym, defn.GetterMetaAnnot, defn.FieldMetaAnnot, keepIfNoRelevantAnnot = !sym.is(ParamAccessor))
           if sym.isScala2Macro && !ctx.settings.XignoreScala2Macros.value then
             if !sym.owner.unforcedDecls.exists(p => !p.isScala2Macro && p.name == sym.name && p.signature == sym.signature)
                // Allow scala.reflect.materializeClassTag to be able to compile scala/reflect/package.scala
@@ -168,6 +176,18 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
         => Checking.checkAppliedTypesIn(tree)
       case _ =>
 
+    private def removeUnwantedAnnotations(sym: Symbol, metaAnnotSym: Symbol,
+        metaAnnotSymBackup: Symbol, keepIfNoRelevantAnnot: Boolean)(using Context): Unit =
+      def shouldKeep(annot: Annotation): Boolean =
+        val annotSym = annot.symbol
+        annotSym.hasAnnotation(metaAnnotSym)
+          || annotSym.hasAnnotation(metaAnnotSymBackup)
+          || (keepIfNoRelevantAnnot && {
+            !annotSym.annotations.exists(metaAnnot => defn.FieldAccessorMetaAnnots.contains(metaAnnot.symbol))
+          })
+      if sym.annotations.nonEmpty then
+        sym.filterAnnotations(shouldKeep(_))
+
     private def transformSelect(tree: Select, targs: List[Tree])(using Context): Tree = {
       val qual = tree.qualifier
       qual.symbol.moduleClass.denot match {

tests/run/i9881.scala

@@ -0,0 +1,21 @@
+import java.io._
+
+class Config(s: String)
+
+class ConfigException(@transient val config: Config = null)
+    extends java.io.Serializable
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    val e = new ConfigException(new Config("not serializable"))
+    val byteStream = new ByteArrayOutputStream()
+    val objectStream = new ObjectOutputStream(byteStream)
+    objectStream.writeObject(e)
+    objectStream.close()
+    val bytes = byteStream.toByteArray()
+    val inStream = new ByteArrayInputStream(bytes)
+    val inObjectStream = new ObjectInputStream(inStream)
+    val copy = inObjectStream.readObject()
+    inObjectStream.close()
+  }
+}