Don't use member type name for deferred givens

When expanding a context bound of a member type, don't use the member name
as the name of the generated deferred given. The same member type might have
different single context bounds in different traits. A class inheriting
several of these traits would then get double definitions in its given clauses.

Partial revert of "Changes to default names for context bound witnesses"

Author: odersky

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

@@ -232,14 +232,16 @@ object desugar {
       flags: FlagSet,
       freshName: => TermName)(using Context): Tree = rhs match
     case ContextBounds(tbounds, cxbounds) =>
+      val isMember = flags.isAllOf(DeferredGivenFlags)
       for bound <- cxbounds do
         val evidenceName = bound match
           case ContextBoundTypeTree(_, _, ownName) if !ownName.isEmpty =>
             ownName
-          case _ if Feature.enabled(Feature.modularity) && cxbounds.tail.isEmpty  =>
+          case _ if !isMember && cxbounds.tail.isEmpty && Feature.enabled(Feature.modularity) =>
             tname.toTermName
           case _ =>
-            freshName
+            if isMember then inventGivenOrExtensionName(bound)
+            else freshName
         val evidenceParam = ValDef(evidenceName, bound, EmptyTree).withFlags(flags)
         evidenceParam.pushAttachment(ContextBoundParam, ())
         evidenceBuf += evidenceParam
@@ -1202,6 +1204,8 @@ object desugar {
           case tree: TypeDef => tree.name.toString
           case tree: AppliedTypeTree if followArgs && tree.args.nonEmpty =>
             s"${apply(x, tree.tpt)}_${extractArgs(tree.args)}"
+          case ContextBoundTypeTree(tycon, paramName, _) =>
+            s"${apply(x, tycon)}_$paramName"
           case InfixOp(left, op, right) =>
             if followArgs then s"${op.name}_${extractArgs(List(left, right))}"
             else op.name.toString

docs/_docs/reference/experimental/typeclasses-syntax.md

@@ -185,22 +185,15 @@ The compiler expands this to the following implementation:
 ```scala
 trait Sorted:
   type Element
-  given Ord[Element] as Element = compiletime.deferred
+  given Ord[Element] = compiletime.deferred
 
 class SortedSet[A](using A: Ord[A]) extends Sorted:
   type Element = A
-  override given Ord[Element] as Element = A // i.e. the A defined by the using clause
+  override given Ord[Element] = A // i.e. the A defined by the using clause
 ```
 
 The using clause in class `SortedSet` provides an implementation for the deferred given in trait `Sorted`.
 
-If there is a single context bound, as in
-```scala
-  type T : C
-```
-the synthesized deferred given will get the (term-)name of the constrained type `T`. If there are multiple bounds,
-the standard convention for naming anonymous givens applies.
-
 **Benefits:**
 
  - Better orthogonality, type parameters and abstract type members now accept the same kinds of bounds.

docs/_docs/reference/experimental/typeclasses.md

@@ -306,22 +306,15 @@ The compiler expands this to the following implementation:
 ```scala
 trait Sorted:
   type Element
-  given Ord[Element] as Element = compiletime.deferred
+  given Ord[Element] = compiletime.deferred
 
 class SortedSet[A](using A: Ord[A]) extends Sorted:
   type Element = A
-  override given Ord[Element] as Element = A // i.e. the A defined by the using clause
+  override given Ord[Element] = A // i.e. the A defined by the using clause
 ```
 
 The using clause in class `SortedSet` provides an implementation for the deferred given in trait `Sorted`.
 
-If there is a single context bound, as in
-```scala
-  type T : C
-```
-the synthesized deferred given will get the (term-)name of the constrained type `T`. If there are multiple bounds,
-the standard convention for naming anonymous givens applies.
-
 **Benefits:**
 
  - Better orthogonality, type parameters and abstract type members now accept the same kinds of bounds.

tests/pos/deferred-givens.scala

@@ -9,7 +9,7 @@ trait A:
 
 class AC extends A:
   type Elem = Double
-  override given Ord[Elem] as Elem = ???
+  override given Ord[Elem] = ???
 
 class AD extends A:
   type Elem = Double
@@ -34,4 +34,3 @@ class E(using x: Ord[String]) extends B:
 
 class F[X: Ord] extends B:
   type Elem = X
-