declare derived type params as synthetic

Author: bishabosha

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

@@ -137,8 +137,8 @@ object desugar {
 
   /** A derived type definition watching `sym` */
   def derivedTypeParamWithVariance(sym: TypeSymbol)(using Context): TypeDef =
-    val variance = (Covariant | Contravariant) & sym.flags
-    TypeDef(sym.name, DerivedFromParamTree().watching(sym)).withFlags(TypeParam | variance)
+    val variance = VarianceFlags & sym.flags
+    TypeDef(sym.name, DerivedFromParamTree().watching(sym)).withFlags(TypeParam | Synthetic | variance)
 
   /** A value definition copied from `vdef` with a tpt typetree derived from it */
   def derivedTermParam(vdef: ValDef)(using Context): ValDef =

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

@@ -12,6 +12,7 @@ import util.SrcPos
 import config.Printers.variances
 import config.Feature.migrateTo3
 import reporting.trace
+import printing.Formatting.hl
 
 /** Provides `check` method to check that all top-level definitions
  *  in tree are variance correct. Does not recurse inside methods.
@@ -169,13 +170,10 @@ class VarianceChecker(using Context) {
         def msg =
           val enumAddendum =
             val towner = tvar.owner
-            if towner.isAllOf(EnumCase) && towner.isClass
-              && tvar.span.exists && towner.span.exists
-              && tvar.span.start < towner.span.start // implies that `tvar` was not user declared
-            then
+            if towner.isAllOf(EnumCase) && towner.isClass && tvar.is(Synthetic) then
               val example =
                 "See an example at http://dotty.epfl.ch/docs/reference/enums/adts.html#parameter-variance-of-enums"
-              i"\nenum case ${towner} requires explicit declaration of $tvar to resolve this issue.\n$example"
+              i"\n${hl("enum case")} ${towner.name} requires explicit declaration of $tvar to resolve this issue.\n$example"
             else
               ""
           i"${varianceLabel(tvar.flags)} $tvar occurs in ${varianceLabel(required)} position in type ${sym.info} of $sym$enumAddendum"

docs/docs/reference/enums/adts.md

@@ -97,7 +97,7 @@ function type, leading to the following error:
 2 |  case Refl(f: T => T)
   |            ^^^^^^^^^
   |contravariant type T occurs in covariant position in type T => T of value f
-  |enum case class Refl requires explicit declaration of type T to resolve this issue.
+  |enum case Refl requires explicit declaration of type T to resolve this issue.
 ```
 Because `Refl` does not declare explicit parameters, it looks to the compiler like the following:
 ```scala
@@ -106,14 +106,16 @@ enum View[-T]:
 ```
 
 The compiler has inferred for `Refl` the contravariant type parameter `T1`, following `T` in `View`.
-We can now clearly see that `Refl` needs to declare its own type parameters to satisfy the variance condition,
+We can now clearly see that `Refl` needs to declare its own non-variant type parameter to correctly type `f`,
 and can remedy the error by the following change to `Refl`:
 
 ```diff
 enum View[-T]:
 -  case Refl(f: T => T)
-+  case Refl[T](f: T => T) extends View[T]
++  case Refl[U](f: U => U) extends View[U]
 ```
+Above, type `U` is chosen as the parameter for `Refl` to highlight that it has a different meaning to
+type `T` in `View`, but any name will do.
 
 Enumerations and ADTs have been presented as two different
 concepts. But since they share the same syntactic construct, they can

tests/neg-custom-args/fatal-warnings/enum-variance.check

@@ -1,8 +1,8 @@
 -- Error: tests/neg-custom-args/fatal-warnings/enum-variance.scala:2:12 ------------------------------------------------
-2 |  case Refl(f: T => T) // error: enum case class Refl requires explicit declaration of type T
+2 |  case Refl(f: T => T) // error: enum case Refl requires explicit declaration of type T
   |            ^^^^^^^^^
   |            contravariant type T occurs in covariant position in type T => T of value f
-  |            enum case class Refl requires explicit declaration of type T to resolve this issue.
+  |            enum case Refl requires explicit declaration of type T to resolve this issue.
   |            See an example at http://dotty.epfl.ch/docs/reference/enums/adts.html#parameter-variance-of-enums
 -- Error: tests/neg-custom-args/fatal-warnings/enum-variance.scala:5:16 ------------------------------------------------
 5 |  case Refl[-T](f: T => T) extends ExplicitView[T] // error: contravariant type T occurs in covariant position

tests/neg-custom-args/fatal-warnings/enum-variance.scala

@@ -1,5 +1,5 @@
 enum View[-T]:
-  case Refl(f: T => T) // error: enum case class Refl requires explicit declaration of type T
+  case Refl(f: T => T) // error: enum case Refl requires explicit declaration of type T
 
 enum ExplicitView[-T]: // desugared version of View
   case Refl[-T](f: T => T) extends ExplicitView[T] // error: contravariant type T occurs in covariant position