Avoid widening derived instances too far

If derived instances are created in companions with the Synthetic flag
set then widenImplied will widen too far, and the derived instances will
have too low a priority to be selected over a freshly derived instances
at the summoning site.

Author: milessabin

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

@@ -49,10 +49,14 @@ trait Deriving { this: Typer =>
       val instanceName = s"derived$$$clsName".toTermName
       if (ctx.denotNamed(instanceName).exists)
         ctx.error(i"duplicate typeclass derivation for $clsName", pos)
-      else
+      else {
+        // If we set the Synthetic flag here widenImplied will widen too far and the
+        // derived instance will have too low a priority to be selected over a freshly
+        // derived instance at the summoning site.
         synthetics +=
-          ctx.newSymbol(ctx.owner, instanceName, Implied | Synthetic | Method, info, coord = pos.span)
+          ctx.newSymbol(ctx.owner, instanceName, Implied | Method, info, coord = pos.span)
             .entered
+      }
     }
 
     /** Check derived type tree `derived` for the following well-formedness conditions:

tests/run/derived-specificity.scala

@@ -0,0 +1,28 @@
+import scala.deriving._
+
+object Test extends App {
+  case class Foo() derives Bar, Baz
+  case class Bar[T](id: String)
+  object Bar {
+    implicit def barGen[T](implicit m: Mirror.Of[T]): Bar[T] = Bar("Bar.barGen")
+    def derived[T](implicit m: Mirror.Of[T]): Bar[T] = Bar("Bar.derived")
+  }
+
+  trait Baz[T] {
+    def id: String
+  }
+  object Baz {
+    def apply[T](id0: String): Baz[T] = new Baz[T] {
+      def id = id0
+    }
+    implicit def bazGen[T](implicit m: Mirror.Of[T]): Baz[T] = Baz("Baz.bazGen")
+    def derived[T](implicit m: Mirror.Of[T]): Baz[T] = Baz("Baz.derived")
+  }
+
+  val bar = implicitly[Bar[Foo]]
+  assert(bar.id == "Bar.derived") 
+
+  val baz = implicitly[Baz[Foo]]
+  assert(baz.id == "Baz.derived") 
+}
+