Fix #8531: Annnotations on class value parameters go to the constructor

Mimic the behavior of Scala 2: an annotation on a class value
parameters (but not on a type parameter) is moved to the constructor
parameter and not to any of the derived parameters.

This required adapting the semanticdb extractor to go look for
annotations in constructor parameters too.

Author: smarter

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

@@ -452,6 +452,10 @@ object desugar {
         else originalTparams
       }
       else originalTparams
+
+    // Annotations on class _type_ parameters are set on the derived parameters
+    // but not on the constructor parameters. The reverse is true for
+    // annotations on class _value_ parameters.
     val constrTparams = impliedTparams.map(toDefParam(_, keepAnnotations = false))
     val constrVparamss =
       if (originalVparamss.isEmpty) { // ensure parameter list is non-empty
@@ -463,7 +467,18 @@ object desugar {
         ctx.error(CaseClassMissingNonImplicitParamList(cdef), namePos)
         ListOfNil
       }
-      else originalVparamss.nestedMap(toDefParam(_, keepAnnotations = false))
+      else originalVparamss.nestedMap(toDefParam(_, keepAnnotations = true))
+    val derivedTparams = {
+      val impliedTparamsIt = impliedTparams.iterator
+      constrTparams.map(tparam => derivedTypeParam(tparam)
+        .withAnnotations(impliedTparamsIt.next().mods.annotations))
+    }
+    val derivedVparamss = {
+      val constrVparamsIt = constrVparamss.iterator.flatten
+      constrVparamss.nestedMap(vparam => derivedTermParam(vparam)
+        .withAnnotations(Nil))
+    }
+
     val constr = cpy.DefDef(constr1)(tparams = constrTparams, vparamss = constrVparamss)
 
     val (normalizedBody, enumCases, enumCompanionRef) = {
@@ -499,19 +514,6 @@ object desugar {
 
     def anyRef = ref(defn.AnyRefAlias.typeRef)
 
-    // Annotations are dropped from the constructor parameters but should be
-    // preserved in all derived parameters.
-    val derivedTparams = {
-      val impliedTparamsIt = impliedTparams.iterator
-      constrTparams.map(tparam => derivedTypeParam(tparam)
-        .withAnnotations(impliedTparamsIt.next().mods.annotations))
-    }
-    val derivedVparamss = {
-      val constrVparamsIt = constrVparamss.iterator.flatten
-      constrVparamss.nestedMap(vparam => derivedTermParam(vparam)
-        .withAnnotations(constrVparamsIt.next().mods.annotations))
-    }
-
     val arity = constrVparamss.head.length
 
     val classTycon: Tree = TypeRefTree() // watching is set at end of method
@@ -800,8 +802,10 @@ object desugar {
         val originalVparamsIt = originalVparamss.iterator.flatten
         derivedVparamss match {
           case first :: rest =>
-            first.map(_.withMods(originalVparamsIt.next().mods | caseAccessor)) ++
-            rest.flatten.map(_.withMods(originalVparamsIt.next().mods))
+            // 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())))
           case _ =>
             Nil
         }

compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala

@@ -104,6 +104,14 @@ class ExtractSemanticDB extends Phase:
       || sym == defn.Any_typeCast
       || qualifier.exists(excludeQual)
 
+    private def traverseAnnotsOf(sym: Symbol)(using Context): Unit =
+      for annot <- sym.annotations do
+        if annot.tree.span.exists
+        && annot.tree.span.hasLength
+          annot.tree match
+            case tree: Typed => () // hack for inline code
+            case tree        => traverse(tree)
+
     override def traverse(tree: Tree)(using Context): Unit =
 
       inline def traverseCtorParamTpt(ctorSym: Symbol, tpt: Tree): Unit =
@@ -115,12 +123,7 @@ class ExtractSemanticDB extends Phase:
         else
           traverse(tpt)
 
-      for annot <- tree.symbol.annotations do
-        if annot.tree.span.exists
-        && annot.tree.span.hasLength
-          annot.tree match
-            case tree: Typed => () // hack for inline code
-            case tree        => traverse(tree)
+      traverseAnnotsOf(tree.symbol)
 
       tree match
         case tree: PackageDef =>
@@ -563,6 +566,7 @@ class ExtractSemanticDB extends Phase:
         vparams <- vparamss
         vparam  <- vparams
       do
+        traverseAnnotsOf(vparam.symbol)
         if !excludeSymbol(vparam.symbol)
           val symkinds =
             getters.get(vparam.name).fold(SymbolKind.emptySet)(getter =>

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

@@ -228,12 +228,12 @@ class Constructors extends MiniPhase with IdentityDenotTransformer { thisPhase =
         Nil
       }
       else {
-        if (acc.hasAnnotation(defn.TransientParamAnnot))
+        val param = acc.subst(accessors, paramSyms)
+        if (param.hasAnnotation(defn.TransientParamAnnot))
           ctx.error(em"transient parameter $acc is retained as field in class ${acc.owner}", acc.sourcePos)
         val target = if (acc.is(Method)) acc.field else acc
         if (!target.exists) Nil // this case arises when the parameter accessor is an alias
         else {
-          val param = acc.subst(accessors, paramSyms)
           val assigns = Assign(ref(target), ref(param)).withSpan(tree.span) :: Nil
           if (acc.name != nme.OUTER) assigns
           else {