No warn when case class calls deprecated members

Author: som-snytt

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

@@ -3,6 +3,7 @@ package dotc
 package transform
 
 import core.*
+import Annotations.Annotation
 import Symbols.*, Types.*, Contexts.*, Flags.*, SymUtils.*, Decorators.*, reporting.*
 import util.SrcPos
 import config.{ScalaVersion, NoScalaVersion, Feature, ScalaRelease}
@@ -33,42 +34,63 @@ class CrossVersionChecks extends MiniPhase:
   end checkUndesiredProperties
 
   /** If @deprecated is present, and the point of reference is not enclosed
-   * in either a deprecated member or a scala bridge method, issue a warning.
+   *  in either a deprecated member or a scala bridge method, issue a warning.
    */
   private def checkDeprecated(sym: Symbol, pos: SrcPos)(using Context): Unit =
 
     /** is the owner an enum or its companion and also the owner of sym */
-    def isEnumOwner(owner: Symbol)(using Context) =
+    def isEnumOwner(owner: Symbol) =
       // pre: sym is an enumcase
       if owner.isEnumClass then owner.companionClass eq sym.owner
       else if owner.is(ModuleClass) && owner.companionClass.isEnumClass then owner eq sym.owner
       else false
 
-    def isDeprecatedOrEnum(owner: Symbol)(using Context) =
+    def isDeprecatedOrEnum(owner: Symbol) =
       // pre: sym is an enumcase
       owner.isDeprecated
       || isEnumOwner(owner)
 
-    /**Skip warnings for synthetic members of case classes during declaration and
-     * scan the chain of outer declaring scopes from the current context
-     * a deprecation warning will be skipped if one the following holds
-     * for a given declaring scope:
-     * - the symbol associated with the scope is also deprecated.
-     * - if and only if `sym` is an enum case, the scope is either
-     *   a module that declares `sym`, or the companion class of the
-     *   module that declares `sym`.
+    /** Skip warnings for synthetic members of case classes during declaration and
+     *  scan the chain of outer declaring scopes from the current context
+     *  a deprecation warning will be skipped if one the following holds
+     *  for a given declaring scope:
+     *  - the symbol associated with the scope is also deprecated.
+     *  - if and only if `sym` is an enum case, the scope is either
+     *    a module that declares `sym`, or the companion class of the
+     *    module that declares `sym`.
      */
-    def skipWarning(using Context): Boolean =
-      (ctx.owner.is(Synthetic) && sym.is(CaseClass))
-        || ctx.owner.ownersIterator.exists(if sym.isEnumCase then isDeprecatedOrEnum else _.isDeprecated)
-
-    // Also check for deprecation of the companion class for synthetic methods
-    val toCheck = sym :: (if sym.isAllOf(SyntheticMethod) then sym.owner.companionClass :: Nil else Nil)
-    for sym <- toCheck; annot <- sym.getAnnotation(defn.DeprecatedAnnot) do
+    def siteIsSyntheticCaseClassMember =
+      val owner = ctx.owner
+      def symIsCaseOrMember =
+        val klass = owner.enclosingClass
+        val kompanion = klass.companionClass
+        // deprecated sym is either enclosing case class or a sibling member
+        def checkSym(k: Symbol) = sym == k || sym.owner == k
+        (klass.is(CaseClass) || kompanion.is(CaseClass))
+        &&
+        (checkSym(klass) || checkSym(kompanion))
+      owner.is(Synthetic) && symIsCaseOrMember
+    def siteIsEnclosedByDeprecatedElement =
+      ctx.owner.ownersIterator.exists:
+        if sym.isEnumCase then isDeprecatedOrEnum else _.isDeprecated
+    def skipWarning: Boolean =
+      siteIsSyntheticCaseClassMember || siteIsEnclosedByDeprecatedElement
+
+    def maybeWarn(annotee: Symbol, annot: Annotation) =
       if !skipWarning then
         val msg = annot.argumentConstant(0).map(": " + _.stringValue).getOrElse("")
         val since = annot.argumentConstant(1).map(" since " + _.stringValue).getOrElse("")
-        report.deprecationWarning(em"${sym.showLocated} is deprecated${since}${msg}", pos)
+        report.deprecationWarning(em"${annotee.showLocated} is deprecated${since}${msg}", pos)
+
+    // Also check for deprecation of the companion class for synthetic methods in the companion module
+    sym.getAnnotation(defn.DeprecatedAnnot) match
+      case Some(annot) => maybeWarn(sym, annot)
+      case _ =>
+        if sym.isAllOf(SyntheticMethod) then
+          val companion = sym.owner.companionClass
+          if companion.is(CaseClass) then companion.getAnnotation(defn.DeprecatedAnnot).foreach(maybeWarn(companion, _))
+
+  end checkDeprecated
 
   private def checkExperimentalAnnots(sym: Symbol)(using Context): Unit =
     if sym.exists && !sym.isInExperimentalScope then

tests/pos/i11022.scala

@@ -1,3 +1,5 @@
 // scalac: -Werror -deprecation
 @deprecated("no CaseClass")
 case class CaseClass(rgb: Int)
+
+case class K(@deprecated("don't use k, ok?","0.1") k: Int)