Change wildcard given selectors

Implements a syntax change for wildcard imports.
Instead of
```scala
import p.{given _}
```
write
```scala
import p.given
```
The same applies for wildcard given imports in braces: `given _` is contracted to just `given`. Given-by-type imports remain unaffected: It's still
```scala
import p.{given T}
```
for those.

The rationale is that we should not make it needlessly hard to write wildcard given imports. The additional underscore after a `given` is not needed for disambiguation and clutters the code.

Author: odersky

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

@@ -3094,16 +3094,18 @@ object Parsers {
     /**  ImportExpr ::= SimpleRef {‘.’ id} ‘.’ ImportSpec
      *   ImportSpec  ::=  id
      *                 | ‘_’
+     *                 | ‘given’
      *                 | ‘{’ ImportSelectors) ‘}’
      */
     def importExpr(mkTree: ImportConstr): () => Tree = {
 
       /** '_' */
       def wildcardSelectorId() = atSpan(in.skipToken()) { Ident(nme.WILDCARD) }
+      def givenSelectorId(start: Offset) = atSpan(start) { Ident(nme.EMPTY) }
 
       /** ImportSelectors  ::=  id [‘=>’ id | ‘=>’ ‘_’] [‘,’ ImportSelectors]
        *                     |  WildCardSelector {‘,’ WildCardSelector}
-       *  WildCardSelector ::=  ‘given’ (‘_' | InfixType)
+       *  WildCardSelector ::=  ‘given’ [InfixType]
        *                     |  ‘_'
        */
       def importSelectors(idOK: Boolean): List[ImportSelector] =
@@ -3114,12 +3116,13 @@ object Parsers {
               ImportSelector(wildcardSelectorId())
             case GIVEN =>
               val start = in.skipToken()
-              def givenSelector() = atSpan(start) { Ident(nme.EMPTY) }
               if in.token == USCORE then
                 in.nextToken()
-                ImportSelector(givenSelector()) // Let the selector span all of `given _`; needed for -Ytest-pickler
+                ImportSelector(givenSelectorId(start)) // Let the selector span all of `given _`; needed for -Ytest-pickler
+              else if canStartTypeTokens.contains(in.token) then
+                ImportSelector(givenSelectorId(start), bound = infixType())
               else
-                ImportSelector(givenSelector(), bound = infixType())
+                ImportSelector(givenSelectorId(start))
             case _ =>
               val from = termIdent()
               if !idOK then syntaxError(i"named imports cannot follow wildcard imports")
@@ -3143,6 +3146,8 @@ object Parsers {
         in.token match
           case USCORE =>
             mkTree(qual, ImportSelector(wildcardSelectorId()) :: Nil)
+          case GIVEN =>
+            mkTree(qual, ImportSelector(givenSelectorId(in.skipToken())) :: Nil)
           case LBRACE =>
             mkTree(qual, inBraces(importSelectors(idOK = true)))
           case _ =>

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

@@ -261,7 +261,7 @@ object Tokens extends TokensCommon {
   final val canStartStatTokens3: TokenSet = canStartExprTokens3 | mustStartStatTokens | BitSet(
     AT, CASE)
 
-  final val canEndStatTokens: TokenSet = atomicExprTokens | BitSet(TYPE, RPAREN, RBRACE, RBRACKET, OUTDENT)
+  final val canEndStatTokens: TokenSet = atomicExprTokens | BitSet(TYPE, GIVEN, RPAREN, RBRACE, RBRACKET, OUTDENT)
 
   /** Tokens that stop a lookahead scan search for a `<-`, `then`, or `do`.
    *  Used for disambiguating between old and new syntax.

docs/docs/internals/syntax.md

@@ -348,10 +348,11 @@ Import            ::=  ‘import’ ImportExpr {‘,’ ImportExpr}
 ImportExpr        ::=  SimpleRef {‘.’ id} ‘.’ ImportSpec                          Import(expr, sels)
 ImportSpec        ::=  id
                     | ‘_’
+                    | ‘given’
                     | ‘{’ ImportSelectors) ‘}’
 ImportSelectors   ::=  id [‘=>’ id | ‘=>’ ‘_’] [‘,’ ImportSelectors]
                     |  WildCardSelector {‘,’ WildCardSelector}
-WildCardSelector  ::=  ‘given’ (‘_' | InfixType)
+WildCardSelector  ::=  ‘given’ [InfixType]
                     |  ‘_'
 Export            ::=  ‘export’ [‘given’] ImportExpr {‘,’ ImportExpr}
 

docs/docs/reference/contextual/given-imports.md

@@ -14,22 +14,22 @@ object A {
 
 object B {
   import A._
-  import A.{given _}
+  import A.given
 }
 ```
 
 In the code above, the `import A._` clause of object `B` will import all members
-of `A` _except_ the given instance `tc`. Conversely, the second import `import A.{given _}` will import _only_ that given instance.
+of `A` _except_ the given instance `tc`. Conversely, the second import `import A.given` will import _only_ that given instance.
 The two import clauses can also be merged into one:
 
 ```scala
 object B {
-  import A.{given _, _}
+  import A.{given, _}
 }
 ```
 
 Generally, a normal wildcard selector `_` brings all definitions other than givens or extensions into scope
-whereas a `given _` selector brings all givens (including those resulting from extensions) into scope.
+whereas a `given` selector brings all givens (including those resulting from extensions) into scope.
 
 There are two main benefits arising from these rules:
 
@@ -106,13 +106,13 @@ normal imports to givens and given imports.
 The following modifications avoid this hurdle to migration.
 
  1. A `given` import selector also brings old style implicits into scope. So, in Scala 3.0
-    an old-style implicit definition can be brought into scope either by a `_` or a `given _` wildcard selector.
+    an old-style implicit definition can be brought into scope either by a `_` or a `given` wildcard selector.
 
  2. In Scala 3.1, old-style implicits accessed through a `_` wildcard import will give a deprecation warning.
 
  3. In some version after 3.1, old-style implicits accessed through a `_` wildcard import will give a compiler error.
 
-These rules mean that library users can use `given _` selectors to access old-style implicits in Scala 3.0,
+These rules mean that library users can use `given` selectors to access old-style implicits in Scala 3.0,
 and will be gently nudged and then forced to do so in later versions. Libraries can then switch to
 given instances once their user base has migrated.
 
@@ -123,10 +123,11 @@ Import            ::=  ‘import’ ImportExpr {‘,’ ImportExpr}
 ImportExpr        ::=  StableId ‘.’ ImportSpec
 ImportSpec        ::=  id
                     |  ‘_’
+                    |  ‘given’
                     |  ‘{’ ImportSelectors) ‘}’
 ImportSelectors   ::=  id [‘=>’ id | ‘=>’ ‘_’] [‘,’ ImportSelectors]
                     |  WildCardSelector {‘,’ WildCardSelector}
 WildCardSelector  ::=  ‘_'
-                    |  ‘given’ (‘_' | InfixType)
+                    |  ‘given’ [InfixType]
 Export            ::=  ‘export’ ImportExpr {‘,’ ImportExpr}
 ```

tests/disabled/pos-macros/i7853/SummonJsonEncoderTest_2.scala

@@ -1,6 +1,6 @@
 import scala.deriving._
 import scala.quoted._
-import JsonEncoder.{given _, _}
+import JsonEncoder.{given, _}
 
 object SummonJsonEncoderTest {
 

tests/neg-custom-args/impl-conv/B.scala

@@ -1,7 +1,7 @@
 package implConv
 
 object B {
-  import A.{_, given _}
+  import A.{_, given}
 
   "".foo
 

tests/neg-custom-args/implicit-conversions.scala

@@ -21,7 +21,7 @@ object D {
 }
 
 object Test {
-  import D.{given _}
+  import D.given
 
   val x1: A = new B  // error under -Xfatal-warnings -feature
   val x2: B = new A  // error under -Xfatal-warnings -feature

tests/neg-macros/i7048e.scala

@@ -13,7 +13,7 @@ abstract class Test {
 
     {
       val t: Test = this
-      import t.{given _}
+      import t.given
       println(summon[Type[t.T]].show)
       // val r = '{Option.empty[t.T]} // access to value t from wrong staging level
       val r2 = '{Option.empty[${t.T}]} // works

tests/neg/import-implied.scala

@@ -16,12 +16,12 @@ object C {
   foo(using tc)  // ok
 }
 object D {
-  import A.{foo, given _}
+  import A.{foo, given}
   foo            // ok
   foo(using tc)  // ok
 }
 object E {
-  import A.{_, given _}
+  import A.{_, given}
   foo            // ok
   foo(using tc)  // ok
 }

tests/pos-macros/i7011/Macros_1.scala

@@ -3,7 +3,7 @@ import scala.quoted._
 inline def mcr(body: => Any): Unit = ${mcrImpl('body)}
 
 def mcrImpl[T](body: Expr[Any])(using ctx: QuoteContext) : Expr[Any] = {
-  import ctx.tasty.{_, given _}
+  import ctx.tasty.{_, given}
 
   val bTree = body.unseal
   val under = bTree.underlyingArgument