Tweak syntax of conditions in given instances

Treat

    given (A, B) => ...

as equivalent to

    given A, B => ...

Motivation: Because of the similarity with function types, it's very easy to
wrap multiple types in parentheses by mistake. On the other hand, it
should be extremely rare to demand a tuple of givens. So the syntax tweak
is there to "do what I mean".

Author: odersky

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -2787,7 +2787,10 @@ object Parsers {
       var counter = nparams
       def nextIdx = { counter += 1; counter }
       val paramFlags = if ofClass then Private | Local | ParamAccessor else Param
-      tps.map(makeSyntheticParameter(nextIdx, _, paramFlags | Synthetic | Given))
+      val tps1 = tps match
+        case Tuple(tps1) :: Nil => tps1
+        case _ => tps
+      tps1.map(makeSyntheticParameter(nextIdx, _, paramFlags | Synthetic | Given))
 
     /** OLD: GivenTypes   ::=  AnnotType {‘,’ AnnotType}
      *  NEW: GivenTypes   ::=  Type {‘,’ Type}

tests/pos/tupled-given.scala

@@ -0,0 +1,19 @@
+class A
+class B
+class C
+class D
+class E
+trait F
+
+given A()
+given B()
+given (A, B) => C()    // this one is equivalent to ...
+given A, B => D(), F // ... the one without the parens
+given ((A, B)) => E()  // to demand a tuple, add an extra pair of parens
+
+@main def Test =
+  summon[C]
+  summon[D]
+  summon[F]
+  given (A, B) = (summon[A], summon[B])
+  summon[E]

tests/run/poly-kinded-derives.scala

@@ -7,7 +7,7 @@ object Test extends App {
       given Show[Int] {}
       given [T]: (st: Show[T]) => Show[Tuple1[T]]
       given t2[T, U]: (st: Show[T], su: Show[U]) => Show[(T, U)]
-      given t3 [T, U, V]: (st: Show[T], su: Show[U], sv: Show[V]) => Show[(T, U, V)]
+      given t3 [T, U, V]: (Show[T], Show[U], Show[V]) => Show[(T, U, V)]
 
       def derived[T](given m: Mirror.Of[T], r: Show[m.MirroredElemTypes]): Show[T] = new Show[T] {}
     }