Fix variance checking in default getters

This is needed to compile geny in the community build which does:

    def count(f: A => Boolean = ((_: Any) => true))

This happened to work before the previous commit because the inferred
type of the getter was `Any => Boolean`.

Crucially, we can only disable variance checking for default getters
whose result type matches the parameter type of the method, see
default-getter-variance.scala for a detailed justification of why this
is safe.

This fixes lets us get rid of an unjustified usage of
`@uncheckedVariance` when desugaring case classes.

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

@@ -602,13 +602,8 @@ object desugar {
     //     def _1: T1 = this.p1
     //     ...
     //     def _N: TN = this.pN (unless already given as valdef or parameterless defdef)
-    //     def copy(p1: T1 = p1: @uncheckedVariance, ...,
-    //              pN: TN = pN: @uncheckedVariance)(moreParams) =
+    //     def copy(p1: T1 = p1..., pN: TN = pN)(moreParams) =
     //       new C[...](p1, ..., pN)(moreParams)
-    //
-    // Note: copy default parameters need @uncheckedVariance; see
-    // neg/t1843-variances.scala for a test case. The test would give
-    // two errors without @uncheckedVariance, one of them spurious.
     val (caseClassMeths, enumScaffolding) = {
       def syntheticProperty(name: TermName, tpt: Tree, rhs: Tree) =
         DefDef(name, Nil, tpt, rhs).withMods(synthetic)
@@ -638,10 +633,8 @@ object desugar {
         }
         if (mods.is(Abstract) || hasRepeatedParam) Nil  // cannot have default arguments for repeated parameters, hence copy method is not issued
         else {
-          def copyDefault(vparam: ValDef) =
-            makeAnnotated("scala.annotation.unchecked.uncheckedVariance", refOfDef(vparam))
           val copyFirstParams = derivedVparamss.head.map(vparam =>
-            cpy.ValDef(vparam)(rhs = copyDefault(vparam)))
+            cpy.ValDef(vparam)(rhs = refOfDef(vparam)))
           val copyRestParamss = derivedVparamss.tail.nestedMap(vparam =>
             cpy.ValDef(vparam)(rhs = EmptyTree))
           DefDef(

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

@@ -1442,7 +1442,9 @@ class Namer { typer: Typer =>
         if (defaultTp eq pt) && (tp frozen_<:< defaultTp) then
           // When possible, widen to the default getter parameter type to permit a
           // larger choice of overrides (see `default-getter.scala`).
-          defaultTp
+          // For justification on the use of `@uncheckedVariance`, see
+          // `default-getter-variance.scala`.
+          AnnotatedType(defaultTp, Annotation(defn.UncheckedVarianceAnnot))
         else tp.widenTermRefExpr.simplified match
           case ctp: ConstantType if isInlineVal => ctp
           case tp =>

tests/pos/default-getter-variance.scala

@@ -0,0 +1,45 @@
+class Foo[+A] {
+  def count(f: A => Boolean = _ => true): Unit = {}
+  // The preceding line is valid, even though the generated default getter
+  // has type `A => Boolean` which wouldn't normally pass variance checks
+  // because it's equivalent to the following overloads which are valid:
+  def count2(f: A => Boolean): Unit = {}
+  def count2(): Unit = count(_ => true)
+}
+
+class Bar1[+A] extends Foo[A] {
+  override def count(f: A => Boolean): Unit = {}
+  // This reasoning extends to overrides:
+  override def count2(f: A => Boolean): Unit = {}
+}
+
+class Bar2[+A] extends Foo[A] {
+  override def count(f: A => Boolean = _ => true): Unit = {}
+  // ... including overrides which also override the default getter:
+  override def count2(f: A => Boolean): Unit = {}
+  override def count2(): Unit = count(_ => true)
+}
+
+// This can be contrasted with the need for variance checks in
+// `protected[this] methods (cf tests/neg/t7093.scala),
+// default getters do not have the same problem since they cannot
+// appear in arbitrary contexts.
+
+
+// Crucially, this argument does not apply to situations in which the default
+// getter result type is not a subtype of the parameter type, for example (from
+// tests/neg/variance.scala):
+//
+//   class Foo[+A: ClassTag](x: A) {
+//     private[this] val elems: Array[A] = Array(x)
+//     def f[B](x: Array[B] = elems): Array[B] = x
+//   }
+//
+// If we tried to rewrite this with an overload, it would fail
+// compilation:
+//
+//  def f[B](): Array[B] = f(elems) // error: Found: Array[A], Expected: Array[B]
+//
+// So we only disable variance checking for default getters whose
+// result type is the method parameter type, this is checked by
+// `tests/neg/variance.scala`