Fix #10178: Put the wildcard demon back in the bottle

This was a very interesting bug. Why did `any2stringadd` appear out of the blue?
The first observation was that it was resolved by an import of an identifier with
`_` as its name. Why? Because we have a standard predefined import
```scala
import Predef.{any2stringadd => _, _}
```
The correct encoding for the removal `_` is as an empty tree, but by mistake
we generated an import with a `_` ident instead. So this counted as a renaming
of `any2stringadd` to the identifier `_`.

How did we end up with an identifier `_` that needed to be resolved? This was a
second bug in Desugar, method `makeIdPat`. Here we needed to create binds for parts
of a pattern. If the pattern was already a Bind, we used that one instead. But the
`Bind` in question was anonymous, using `_` as the pattern variable. So we did not
replace that by a fresh identifier, but used `_` as the identifier instead. However,
`_` is treated specially as a binder; it does not generate a symbol in the enclosing
scope. So resolving the `_` identifier did not see the enclosing bind and searched
further out instead, until it found the "renamed" import. Beautiful! It shows that
treating wildcards as some sort of identifiers is fraught with surprises.

Author: odersky

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

@@ -1456,10 +1456,15 @@ object desugar {
 
       /** If `pat` is not an Identifier, a Typed(Ident, _), or a Bind, wrap
        *  it in a Bind with a fresh name. Return the transformed pattern, and the identifier
-       *  that refers to the bound variable for the pattern.
+       *  that refers to the bound variable for the pattern. Wildcard Binds are
+       *  also replaced by Binds with fresh names.
        */
       def makeIdPat(pat: Tree): (Tree, Ident) = pat match {
-        case Bind(name, _) => (pat, Ident(name))
+        case Bind(name, pat1) =>
+          if name == nme.WILDCARD then
+            val name = UniqueName.fresh()
+            (cpy.Bind(pat)(name, pat1), Ident(name))
+          else (pat, Ident(name))
         case id: Ident if isVarPattern(id) && id.name != nme.WILDCARD => (id, id)
         case Typed(id: Ident, _) if isVarPattern(id) && id.name != nme.WILDCARD => (pat, id)
         case _ =>

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

@@ -26,7 +26,7 @@ object ImportInfo {
       :: untpd.ImportSelector(untpd.Ident(nme.EMPTY))  // ... and also all given members
       :: Nil
     if ref.isPredef then                               // do not import any2stringadd
-      selectors = untpd.ImportSelector(untpd.Ident(nme.any2stringadd), untpd.Ident(nme.WILDCARD))
+      selectors = untpd.ImportSelector(untpd.Ident(nme.any2stringadd), untpd.EmptyTree)
         :: selectors
 
     def sym(using Context) =

tests/run/i10178.scala

@@ -0,0 +1,5 @@
+@main def Test: Unit =
+  for
+    x <- Option(23)
+    given Int = x
+  do assert(summon[Int] == 23)