Change bounded wildcard import syntax

It's now `_: Type` instead of `for Type` and it works
for all kinds of imports. There are use cases for normal
imports as well. E.g.
```
import Color.{_: Color}
```
to get just the enum cases and nothing else.

Author: odersky

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

@@ -2388,12 +2388,18 @@ object Parsers {
 
       /** ImportSelectors ::= `{' {ImportSelector `,'} FinalSelector ‘}’
        *  FinalSelector   ::=  ImportSelector
-       *                    |  ‘_’
-       *                    |  ‘for’ InfixType {‘,’ InfixType}
+       *                    |  ‘_’ [‘:’ Type]
        */
       def importSelectors(): List[Tree] = in.token match {
         case USCORE =>
-          wildcardIdent() :: Nil
+          atSpan(in.skipToken()) {
+            val id = Ident(nme.WILDCARD)
+            if (in.token == COLON) {
+              in.nextToken()
+              TypeBoundsTree(EmptyTree, typ())
+            }
+            else id
+          } :: Nil
         case FOR =>
           if (!importDelegate)
               syntaxError(em"`for` qualifier only allowed in `import given`")

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

@@ -91,26 +91,26 @@ class ImportInfo(symf: Context => Symbol, val selectors: List[untpd.Tree],
             myForwardMapping = myForwardMapping.updated(name, name)
             myReverseMapping = myReverseMapping.updated(name, name)
           case TypeBoundsTree(_, tpt) =>
-            myWildcardImport = true // details are handled separately in impliedBounds
+            myWildcardImport = true // details are handled separately in wildcardBounds
         }
         recur(sels1)
       case nil =>
     }
     recur(selectors)
   }
 
-  private[this] var myDelegateBound: Type = null
+  private[this] var myWildcardBound: Type = null
 
-  def impliedBound(implicit ctx: Context): Type = {
-    if (myDelegateBound == null)
-      myDelegateBound = selectors.lastOption match {
+  def wildcardBound(implicit ctx: Context): Type = {
+    if (myWildcardBound == null)
+      myWildcardBound = selectors.lastOption match {
         case Some(TypeBoundsTree(_, untpd.TypedSplice(tpt))) => tpt.tpe
         case Some(TypeBoundsTree(_, tpt)) =>
-          myDelegateBound = NoType
+          myWildcardBound = NoType
           ctx.typer.typedAheadType(tpt).tpe
         case _ => NoType
       }
-    myDelegateBound
+    myWildcardBound
   }
 
   private def implicitFlags(implicit ctx: Context) =
@@ -128,8 +128,8 @@ class ImportInfo(symf: Context => Symbol, val selectors: List[untpd.Tree],
           val renamed = forwardMapping(ref.name)
           if (renamed == ref.name) ref :: Nil
           else if (renamed != null) new RenamedImplicitRef(ref, renamed) :: Nil
-          else if (!impliedBound.exists ||
-                   normalizedCompatible(ref, impliedBound, keepConstraint = false)) ref :: Nil
+          else if (!wildcardBound.exists ||
+                   normalizedCompatible(ref, wildcardBound, keepConstraint = false)) ref :: Nil
           else Nil
         }
       }

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

@@ -189,9 +189,9 @@ class Typer extends Namer
           var excl = EmptyFlags
           if (imp.importDelegate) reqd |= Delegate else excl |= Delegate
           var denot = pre.memberBasedOnFlags(name, reqd, excl).accessibleFrom(pre)(refctx)
-          if (checkBounds && imp.impliedBound.exists)
+          if (checkBounds && imp.wildcardBound.exists)
             denot = denot.filterWithPredicate(mbr =>
-              NoViewsAllowed.normalizedCompatible(mbr.info, imp.impliedBound, keepConstraint = false))
+              NoViewsAllowed.normalizedCompatible(mbr.info, imp.wildcardBound, keepConstraint = false))
 
             // Pass refctx so that any errors are reported in the context of the
             // reference instead of the
@@ -234,7 +234,7 @@ class Typer extends Namer
        */
       def wildImportRef(imp: ImportInfo)(implicit ctx: Context): Type =
         if (imp.isWildcardImport && !imp.excluded.contains(name.toTermName) && name != nme.CONSTRUCTOR)
-          selection(imp, name, checkBounds = imp.importDelegate)
+          selection(imp, name, checkBounds = true)
         else NoType
 
       /** Is (some alternative of) the given predenotation `denot`

docs/docs/internals/syntax.md

@@ -340,8 +340,7 @@ Import            ::=  ‘import’ [‘given’] ImportExpr {‘,’ ImportExpr
 ImportExpr        ::=  StableId ‘.’ (id | ‘_’ | ImportSelectors)                Import(expr, sels)
 ImportSelectors   ::=  ‘{’ {ImportSelector ‘,’} FinalSelector ‘}’
 FinalSelector     ::=  ImportSelector                                           Ident(name)
-                    |  ‘_’                                                      Pair(id, id)
-                    |  ‘for’ InfixType {‘,’ InfixType}                          TypeBoundsTree(EmptyTree, tpt)
+                    |  ‘_’ [‘:’ Type]                                           TypeBoundsTree(EmptyTree, tpt)
 ImportSelector    ::=  id [‘=>’ id | ‘=>’ ‘_’]
 Export            ::=  ‘export’ [‘given’] ImportExpr {‘,’ ImportExpr}
 ```

docs/docs/reference/contextual/delegates.md

@@ -19,7 +19,6 @@ given IntOrd as Ord[Int] {
 }
 
 given ListOrd[T] as Ord[List[T]] given (ord: Ord[T]) {
-  where Ord[T], { x <= 0 }
 
   def compare(xs: List[T], ys: List[T]): Int = (xs, ys) match {
     case (Nil, Nil) => 0

docs/docs/reference/contextual/import-delegate.md

@@ -58,6 +58,18 @@ import given Instances.{im, _: Ordering[_]}
 ```
 would import `im`, `intOrd`, and `listOrd` but leave out `ec`. By-type imports cannot be mixed with a wildcard import in the same import clause.
 
+Bounded wildcard selectors also work for normal imports and exports. For instance, consider the following `enum` definition:
+```scala
+enum Color {
+  case Red, Green, Blue, Magenta
+
+  def isPrimary(c: Color): Boolean = ...
+}
+export Color.{_: Color}
+```
+The export clause makes all four three `Color` values available as unqualified constants, but
+leaves the `isPrimary` method alone.
+
 ### Migration
 
 The rules for imports given above have the consequence that a library

tests/run/boundedImports.scala

@@ -0,0 +1,27 @@
+class C[X]
+
+object A extends C[String] {
+
+  val a: A.type = this
+  val b: String = ""
+  val c: Integer = 10
+
+}
+
+enum Color {
+  case Red, Green, Blue
+
+  def identity(x: Any): Any = ""
+}
+
+object Test extends App {
+  val c = 0
+
+  import A.{_: C[_] | String}
+  assert(a eq A)
+  assert(b == "")
+  assert(c == 0)
+
+  import Color.{_: Color}
+  assert(identity("hello") == "hello")
+}