Better diagnostics for too unspecific implicit searches

Fixes #15998

Author: odersky

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

@@ -125,25 +125,25 @@ object ErrorReporting {
     def typeMismatch(tree: Tree, pt: Type, implicitFailure: SearchFailureType = NoMatchingImplicits): Tree = {
       val normTp = normalize(tree.tpe, pt)
       val normPt = normalize(pt, pt)
-      
+
       def contextFunctionCount(tp: Type): Int = tp.stripped match
         case defn.ContextFunctionType(_, restp, _) => 1 + contextFunctionCount(restp)
         case _ => 0
       def strippedTpCount = contextFunctionCount(tree.tpe) - contextFunctionCount(normTp)
       def strippedPtCount = contextFunctionCount(pt) - contextFunctionCount(normPt)
-      
+
       val (treeTp, expectedTp) =
         if normTp <:< normPt || strippedTpCount != strippedPtCount
         then (tree.tpe, pt)
         else (normTp, normPt)
         // use normalized types if that also shows an error, and both sides stripped
         // the same number of context functions. Use original types otherwise.
-        
+
       def missingElse = tree match
         case If(_, _, elsep @ Literal(Constant(()))) if elsep.span.isSynthetic =>
           "\nMaybe you are missing an else part for the conditional?"
         case _ => ""
-        
+
       errorTree(tree, TypeMismatch(treeTp, expectedTp, Some(tree), implicitFailure.whyNoConversion, missingElse))
     }
 
@@ -262,6 +262,9 @@ class ImplicitSearchError(
         case _ =>
           defaultAmbiguousImplicitMsg(ambi)
       }
+    case ambi @ TooUnspecific(target) =>
+      ex"""No implicit search was attempted${location("for")}
+          |since the expected type $target is too unspecific"""
     case _ =>
       val shortMessage = userDefinedImplicitNotFoundParamMessage
         .orElse(userDefinedImplicitNotFoundTypeMessage)

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

@@ -411,14 +411,14 @@ object Implicits:
 
   /** A failed search */
   case class SearchFailure(tree: Tree) extends SearchResult {
-    final def isAmbiguous: Boolean = tree.tpe.isInstanceOf[AmbiguousImplicits]
+    final def isAmbiguous: Boolean = tree.tpe.isInstanceOf[AmbiguousImplicits | TooUnspecific]
     final def reason: SearchFailureType = tree.tpe.asInstanceOf[SearchFailureType]
   }
 
   object SearchFailure {
     def apply(tpe: SearchFailureType, span: Span)(using Context): SearchFailure = {
       val id = tpe match
-        case tpe: AmbiguousImplicits =>
+        case tpe: (AmbiguousImplicits | TooUnspecific) =>
           untpd.SearchFailureIdent(nme.AMBIGUOUS, s"/* ambiguous: ${tpe.explanation} */")
         case _ =>
           untpd.SearchFailureIdent(nme.MISSING, "/* missing */")
@@ -504,11 +504,14 @@ object Implicits:
     SearchFailure(ImplicitSearchTooLarge, NoSpan)(using NoContext)
 
   /** A failure value indicating that an implicit search for a conversion was not tried */
-  class TooUnspecific(target: Type) extends NoMatchingImplicits(NoType, EmptyTree, OrderingConstraint.empty):
+  case class TooUnspecific(target: Type) extends NoMatchingImplicits(NoType, EmptyTree, OrderingConstraint.empty):
     override def whyNoConversion(using Context): String =
       i"""
          |Note that implicit conversions were not tried because the result of an implicit conversion
          |must be more specific than $target"""
+    override def explanation(using Context) =
+      i"""${super.explanation}.
+         |The expected type $target is not specific enough, so no search was attempted"""
     override def toString = s"TooUnspecific"
 
   /** An ambiguous implicits failure */
@@ -1484,7 +1487,7 @@ trait Implicits:
 
     private def searchImplicit(contextual: Boolean): SearchResult =
       if isUnderspecified(wildProto) then
-        NoMatchingImplicitsFailure
+        SearchFailure(TooUnspecific(pt), span)
       else
         val eligible =
           if contextual then

tests/neg/i15998.check

@@ -0,0 +1,36 @@
+-- [E007] Type Mismatch Error: tests/neg/i15998.scala:11:23 ------------------------------------------------------------
+11 |  RingSeq.isRotationOf("DAB") // error
+   |                       ^^^^^
+   |                      Found:    ("DAB" : String)
+   |                      Required: CC[A]
+   |
+   |                      where:    A  is a type variable
+   |                                CC is a type variable with constraint <: [B] =>> collection.SeqOps[B, CC, CC[B]]
+   |
+   |                      Note that implicit conversions were not tried because the result of an implicit conversion
+   |                      must be more specific than CC[A]
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E008] Not Found Error: tests/neg/i15998.scala:12:9 -----------------------------------------------------------------
+12 |  "ABCD".isRotationOf("DAB")  // error
+   |  ^^^^^^^^^^^^^^^^^^^
+   |  value isRotationOf is not a member of String.
+   |  An extension method was tried, but could not be fully constructed:
+   |
+   |      RingSeq.isRotationOf[A, CC]("ABCD")    failed with
+   |
+   |          Found:    ("ABCD" : String)
+   |          Required: CC[A]
+   |          
+   |          where:    A  is a type variable
+   |                    CC is a type variable with constraint <: [B] =>> collection.SeqOps[B, CC, CC[B]]
+   |          
+   |          Note that implicit conversions were not tried because the result of an implicit conversion
+   |          must be more specific than CC[A]
+-- Error: tests/neg/i15998.scala:21:13 ---------------------------------------------------------------------------------
+21 |  val x = foo  // error
+   |             ^
+   |             No implicit search was attempted for parameter x of method foo
+   |             since the expected type X is too unspecific
+   |
+   |             where:    X is a type variable

tests/neg/i15998.scala

@@ -0,0 +1,21 @@
+import scala.collection.SeqOps
+
+trait ComparingOps:
+  extension[A, CC[B] <: SeqOps[B, CC, CC[B]]](ring: CC[A])
+    def isRotationOf(that: CC[A]): Boolean = ???
+
+object RingSeq extends ComparingOps
+import RingSeq.*
+
+@main def Test =
+  RingSeq.isRotationOf("DAB") // error
+  "ABCD".isRotationOf("DAB")  // error
+
+  // workaround
+  RingSeq.isRotationOf[Char, IndexedSeq]("DAB")
+  RingSeq.isRotationOf(wrapString("DAB"))
+  wrapString("ABCD").isRotationOf("DAB")
+
+  def foo[X](using x: X): X = x
+
+  val x = foo  // error