fix #10857: export from wildcard more definitions

a wildcard export will first search for all public and
non-synthetic members to add. Then once a valid member
is found, that name is then used to search for all
term or type members that use that name and are not
given or private.

As a consequence members like companion objects to
case classes will be exported alongside a type alias
to the case class

Author: bishabosha

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

@@ -1086,15 +1086,24 @@ class Namer { typer: Typer =>
           }
         }
 
+        def addWildcardForwardersNamed(name: TermName, span: Span): Unit =
+          List(name, name.toTypeName)
+            .flatMap(path.tpe.memberBasedOnFlags(_, excluded = Private|Given|ConstructorProxy).alternatives)
+            .foreach(addForwarder(name, _, span)) // ignore if any are not added
+
         def addWildcardForwarders(seen: List[TermName], span: Span): Unit =
+          val nonContextual = mutable.HashSet(seen: _*)
           for mbr <- path.tpe.membersBasedOnFlags(required = EmptyFlags, excluded = PrivateOrSynthetic) do
             if !mbr.symbol.isSuperAccessor then
               // Scala 2 superaccessors have neither Synthetic nor Artfact set, so we
               // need to filter them out here (by contrast, Scala 3 superaccessors are Artifacts)
               val alias = mbr.name.toTermName
-              if !seen.contains(alias)
-                && mbr.matchesImportBound(if mbr.symbol.is(Given) then givenBound else wildcardBound)
-              then addForwarder(alias, mbr, span)
+              if mbr.symbol.is(Given) then
+                if !seen.contains(alias) && mbr.matchesImportBound(givenBound) then
+                  addForwarder(alias, mbr, span)
+              else if !nonContextual.contains(alias) && mbr.matchesImportBound(wildcardBound) then
+                nonContextual += alias
+                addWildcardForwardersNamed(alias, span)
 
         def addForwarders(sels: List[untpd.ImportSelector], seen: List[TermName]): Unit = sels match
           case sel :: sels1 =>

tests/neg/i10857.scala

@@ -0,0 +1,45 @@
+object Module:
+
+  class Bar
+  class Baz
+  class Qux
+
+  object Givens:
+    given GivenBar: Bar = new Bar()
+    def GivenBar(ignored: Int): Bar = new Bar()
+    class GivenBar
+
+  object Members:
+    given Member: Baz = new Baz()
+    private def Member(ignored1: String)(ignored2: Int): Bar = new Bar()
+    def Member(ignored: Int): Baz = new Baz()
+    class Member
+
+  object Combined:
+    given GivenQux: Qux = new Qux()
+    def GivenQux(ignored: Int): Qux = new Qux()
+
+  enum Color:
+    case Red, Green, Blue
+
+  export Color._ // will only export synthetic defs with same name as standard definition
+  export Givens.given // should only export given values
+  export Members._ // should only export values that are not given
+  export Combined.{_, given} // should only export values that are not given
+
+@main def Test =
+
+  println(Module.Red)
+  println(Module.valueOf("Red")) // error: value valueOf is not a member
+
+  println(summon[Module.Bar])
+  println(new Module.GivenBar()) // error: type GivenBar is not a member
+  println(Module.GivenBar(23)) // error: method GivenBar does not take parameters
+
+  println(new Module.Member())
+  println(Module.Member(23))
+  println(Module.Member("?")(23)) // error: Found: ("?" : String) Required: Int
+  println(summon[Module.Baz]) // error: no implicit argument of type Module.Baz was found
+
+  println(summon[Module.Qux])
+  println(Module.GivenQux(23))

tests/run/i10857.scala

@@ -0,0 +1,12 @@
+object Module:
+
+  enum Foo:
+    case Value
+    case Parameterised(i: Int)
+
+  export Foo._
+
+@main def Test =
+  import Module.given
+  println(Module.Parameterised.apply(23)) // synthetic companion object is exported
+  println(Module.Value)