In case apply rewrite, only issue deprecation when using companion

When a case apply is rewritten to the constructor, only warn about
the class being deprecated if the companion object was used directly.

```
@deprecated case class C(x: Int)
C(1) // warn
val Alias = C
Alias(1) // no warn
```

The warning was introduced in PRs 4955 and 5646.

Scala 2.12 doesn't perform the case apply rewrite if the receiver is
an alias, but that changed in 2.13 in PR 10560, where the workaround
for fixing issue 5626 was narrowed down.

Author: lrytz

src/compiler/scala/tools/nsc/typechecker/RefChecks.scala

@@ -1233,15 +1233,16 @@ abstract class RefChecks extends Transform {
 // Transformation ------------------------------------------------------------
 
     /* Convert a reference to a case factory of type `tpe` to a new of the class it produces. */
-    def toConstructor(pos: Position, tpe: Type): Tree = {
+    def toConstructor(pos: Position, tpe: Type, checkTarget: Boolean): Tree = {
       val rtpe = tpe.finalResultType
       assert(rtpe.typeSymbol hasFlag CASE, tpe)
       val tree = localTyper.typedOperator {
         atPos(pos) {
           Select(New(TypeTree(rtpe)), rtpe.typeSymbol.primaryConstructor)
         }
       }
-      checkUndesiredProperties(rtpe.typeSymbol, tree.pos)
+      if (checkTarget)
+        checkUndesiredProperties(rtpe.typeSymbol, tree.pos)
       checkUndesiredProperties(rtpe.typeSymbol.primaryConstructor, tree.pos)
       tree
     }
@@ -1667,8 +1668,7 @@ abstract class RefChecks extends Transform {
         case x => throw new MatchError(x)
       }
       sym.name == nme.apply &&
-        !sym.hasStableFlag && // ???
-        sym.isCase &&
+        sym.isCase && // only synthetic case apply methods
         isClassTypeAccessible(tree) &&
         !tree.tpe.finalResultType.typeSymbol.primaryConstructor.isLessAccessibleThan(tree.symbol)
     }
@@ -1689,7 +1689,12 @@ abstract class RefChecks extends Transform {
         case _ =>
       }
       loop(tree)
-      toConstructor(tree.pos, tree.tpe)
+      def qualIsModule(t: Tree): Boolean = t match {
+        case TypeApply(qual, _) => qualIsModule(qual)
+        case Select(qual, _) => qual.symbol == tree.symbol.owner.module
+        case _ => true
+      }
+      toConstructor(tree.pos, tree.tpe, qualIsModule(tree))
     }
 
     private def transformApply(tree: Apply): Tree = tree match {

test/files/neg/t13006.check

@@ -0,0 +1,24 @@
+t13006.scala:7: warning: class C is deprecated
+  type X[T] = C[T] // warn
+              ^
+t13006.scala:17: warning: class C is deprecated
+  def t3 = C.apply(20)   // warn
+             ^
+t13006.scala:18: warning: class C is deprecated
+  def t4 = new C(10)     // warn
+               ^
+t13006.scala:21: warning: constructor D in class D is deprecated
+  def u1 = A.Y.apply(10) // warn
+               ^
+t13006.scala:22: warning: constructor D in class D is deprecated
+  def u2 = new A.Y(10)   // warn
+           ^
+t13006.scala:23: warning: constructor D in class D is deprecated
+  def u3 = D.apply(10)   // warn
+             ^
+t13006.scala:24: warning: constructor D in class D is deprecated
+  def u4 = new D(10)     // warn
+           ^
+error: No warnings can be incurred under -Werror.
+7 warnings
+1 error

test/files/neg/t13006.scala

@@ -0,0 +1,26 @@
+//> using options -deprecation -Werror
+
+@deprecated case class C[T](x: T)
+case class D @deprecated() (x: Int)
+
+object A {
+  type X[T] = C[T] // warn
+  val X = C        // no warn
+
+  type Y = D       // no warn
+  val Y = D        // no warn
+}
+
+class T {
+  def t1 = A.X.apply(10) // no warn
+  def t2 = new A.X(10)   // no warn
+  def t3 = C.apply(20)   // warn
+  def t4 = new C(10)     // warn
+  def t5 = C.hashCode    // no warn
+
+  def u1 = A.Y.apply(10) // warn
+  def u2 = new A.Y(10)   // warn
+  def u3 = D.apply(10)   // warn
+  def u4 = new D(10)     // warn
+  def u5(d: D) = 10      // no warn
+}