Select local implicits over name-imported over wildcard imported

Author: dwijnand

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

@@ -299,7 +299,7 @@ object Implicits:
   class ContextualImplicits(
       val refs: List[ImplicitRef],
       val outerImplicits: ContextualImplicits | Null,
-      isImport: Boolean)(initctx: Context) extends ImplicitRefs(initctx) {
+      val isImport: Boolean)(initctx: Context) extends ImplicitRefs(initctx) {
     private val eligibleCache = EqHashMap[Type, List[Candidate]]()
 
     /** The level increases if current context has a different owner or scope than
@@ -330,8 +330,19 @@ object Implicits:
       if ownEligible.isEmpty then outerEligible
       else if outerEligible.isEmpty then ownEligible
       else
-        val shadowed = ownEligible.map(_.ref.implicitName).toSet
-        ownEligible ::: outerEligible.filterConserve(cand => !shadowed.contains(cand.ref.implicitName))
+        def filter(xs: List[Candidate], remove: List[Candidate]) =
+          val shadowed = remove.map(_.ref.implicitName).toSet
+          xs.filterConserve(cand => !shadowed.contains(cand.ref.implicitName))
+        def isWildcardImport(using Context) = ctx.importInfo.nn.isWildcardImport
+        if (irefCtx.scope eq irefCtx.outer.scope) && (
+          isImport && !outerImplicits.nn.isImport
+          || isWildcardImport && !isWildcardImport(using outerImplicits.nn.irefCtx)
+        ) then
+          // special cases: definitions beat imports, and named imports beat
+          // wildcard imports, provided both are in contexts with same scope
+          filter(ownEligible, outerEligible) ::: outerEligible
+        else
+          ownEligible ::: filter(outerEligible, ownEligible)
 
     def uncachedEligible(tp: Type)(using Context): List[Candidate] =
       Stats.record("uncached eligible")

tests/run/i18183.scala

@@ -0,0 +1,41 @@
+case class Foo(n: Int)
+
+class Bar(n: Int):
+  implicit val foo: Foo = new Foo(n)
+
+class InMethod:
+  def wild(bar: Bar): Unit =
+    import bar._
+    implicit val foo: Foo = new Foo(2)
+    assert(foo eq implicitly[Foo])
+
+  def named(bar: Bar): Unit =
+    import bar.foo
+    implicit val foo: Foo = new Foo(2)
+    assert(foo eq implicitly[Foo])
+
+  def namedWild(bar: Bar): Unit =
+    val bar2 = new Bar(2)
+    import bar.foo
+    import bar2._
+    assert(bar.foo eq implicitly[Foo])
+
+  def wildNamed(bar: Bar): Unit =
+    val bar2 = new Bar(2)
+    import bar2._
+    import bar.foo
+    assert(bar.foo eq implicitly[Foo])
+
+class InClass(bar: Bar):
+  import bar._
+  implicit val foo: Foo = new Foo(2)
+  assert(foo eq implicitly[Foo])
+
+object Test:
+  def main(args: Array[String]): Unit =
+    val bar = new Bar(1)
+    new InMethod().wild(bar)
+    new InMethod().named(bar)
+    new InMethod().namedWild(bar)
+    new InMethod().wildNamed(bar)
+    new InClass(bar)