Don’t suggest to import things that are already available

Author: julienrf

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

@@ -144,6 +144,17 @@ trait ImportSuggestions:
     val timer = new Timer()
     val deadLine = System.currentTimeMillis() + suggestImplicitTimeOut
 
+    // Candidates that are already available without explicit import because they
+    // are already provided by the context (imported or inherited) or because they
+    // are in the implicit scope of `pt`.
+    val alreadyAvailableCandidates: Set[Symbol] = {
+      val wildProto = wildApprox(pt)
+      val contextualCandidates = ctx.implicits.eligible(wildProto)
+      val implicitScopeCandidates = ctx.run.implicitScope(wildProto, ctx).eligible
+      val allCandidates = contextualCandidates ++ implicitScopeCandidates
+      allCandidates.map(_.implicitRef.underlyingRef.symbol).toSet
+    }
+
     /** Test whether the head of a given instance matches the expected type `pt`,
      *  ignoring any dependent implicit arguments.
      */
@@ -221,7 +232,9 @@ trait ImportSuggestions:
           Nil
 
       roots
-        .flatMap(_.implicitMembers.filter(shallowTest))
+        .flatMap(_.implicitMembers.filter { ref =>
+          !alreadyAvailableCandidates(ref.symbol) && shallowTest(ref)
+        })
           // filter whether the head of the implicit can match
         .partition(deepTest)
           // partition into full matches and head matches

tests/neg/missing-implicit3.check

@@ -1,18 +1,12 @@
 -- Error: tests/neg/missing-implicit3.scala:3:37 -----------------------------------------------------------------------
 3 |val sortedFoos = List(new Foo).sorted // error
   |                                     ^
-  |                  No implicit Ordering defined for B
+  |                 No implicit Ordering defined for B
   |
-  |                  where:    B is a type variable with constraint >: Foo
-  |                  ..
-  |                  I found:
+  |                 where:    B is a type variable with constraint >: Foo
+  |                 ..
+  |                 I found:
   |
-  |                      scala.math.Ordering.ordered[A](/* missing */implicitly[scala.math.Ordering.AsComparable[B]])
+  |                     scala.math.Ordering.comparatorToOrdering[A](/* missing */implicitly[java.util.Comparator[B]])
   |
-  |                  But no implicit values were found that match type scala.math.Ordering.AsComparable[B].
-  |
-  |                  One of the following imports might make progress towards fixing the problem:
-  |
-  |                    import math.Ordering.comparatorToOrdering
-  |                    import math.Ordering.ordered
-  |                           
+  |                 But no implicit values were found that match type java.util.Comparator[B].