Allow several for type-bounds

In a `for` clause of an implied imports, allow several bounds,
separated by commas. Writing
```
import a.b.{for C, D}
```
is equivalent to
```
import a.b.{for C | D}
```
but feels more natural.

Author: odersky

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

@@ -2310,15 +2310,22 @@ object Parsers {
       /** ImportSelectors ::= `{' {ImportSelector `,'} FinalSelector ‘}’
        *  FinalSelector   ::=  ImportSelector
        *                    |  ‘_’
-       *                    |  ‘for’ InfixType
+       *                    |  ‘for’ InfixType {‘,’ InfixType}
        */
       def importSelectors(): List[Tree] = in.token match {
         case USCORE =>
           wildcardIdent() :: Nil
         case FOR =>
           if (!importImplied)
               syntaxError(em"`for` qualifier only allowed in `import implied`")
-          atSpan(in.skipToken()) { TypeBoundsTree(EmptyTree, infixType()) } :: Nil
+          atSpan(in.skipToken()) {
+            var t = infixType()
+            while (in.token == COMMA) {
+              val op = atSpan(in.skipToken()) { Ident(tpnme.raw.BAR) }
+              t = InfixOp(t, op, infixType())
+            }
+            TypeBoundsTree(EmptyTree, t)
+          } :: Nil
         case _ =>
           importSelector() :: {
             if (in.token == COMMA) {

docs/docs/internals/syntax.md

@@ -338,7 +338,7 @@ ImportExpr        ::=  StableId ‘.’ (id | ‘_’ | ImportSelectors)
 ImportSelectors   ::=  ‘{’ {ImportSelector ‘,’} FinalSelector ‘}’
 FinalSelector     ::=  ImportSelector                                           Ident(name)
                     |  ‘_’                                                      Pair(id, id)
-                    |  ‘for’ InfixType                                          TypeBoundsTree(EmptyTree, tpt)
+                    |  ‘for’ InfixType {‘,’ InfixType}                          TypeBoundsTree(EmptyTree, tpt)
 ImportSelector    ::=  id [‘=>’ id | ‘=>’ ‘_’]
 Export            ::=  ‘export’ [‘implied’] ImportExpr {‘,’ ImportExpr}
 ```

tests/run/implied-for.scala

@@ -4,18 +4,22 @@ object A {
 
   class B extends T
   class C extends T
+  class D
 
   implied b for B
   implied c for C
-  implied d for T
+  implied t for T
+  implied d for D
 }
 
 object Test extends App {
   import A._
-  import implied A.{d, for B}
+  import implied A.{t, for B, D}
 
-  println(d)
-  val x: B = b
+  val x1: B = b
+  val x2: T = t
+  val x3: D = d
 
   assert(the[T].isInstanceOf[B])
+  assert(the[D].isInstanceOf[D])
 }