Make suggestions of missing implicits imports on type errors

Add an addendum to an error message where the error might be fixed
be some implicit argument or conversion or some extension method
that is however not found. The addendum suggests suggests implicit
imports that might fix the problem.

Author: odersky

compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -278,7 +278,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
   }
 
   /** The string representation of this type used as a prefix */
-  protected def toTextRef(tp: SingletonType): Text = controlled {
+  def toTextRef(tp: SingletonType): Text = controlled {
     tp match {
       case tp: TermRef =>
         toTextPrefix(tp.prefix) ~ selectionString(tp)

compiler/src/dotty/tools/dotc/printing/Printer.scala

@@ -4,7 +4,7 @@ package printing
 
 import core._
 import Texts._, ast.Trees._
-import Types.Type, Symbols.Symbol, Scopes.Scope, Constants.Constant,
+import Types.{Type, SingletonType}, Symbols.Symbol, Scopes.Scope, Constants.Constant,
        Names.Name, Denotations._, Annotations.Annotation
 import typer.Implicits.SearchResult
 import util.SourcePosition
@@ -97,6 +97,9 @@ abstract class Printer {
    */
   def toText(sym: Symbol): Text
 
+  /** Textual representation of singeton type reference */
+  def toTextRef(tp: SingletonType): Text
+
   /** Textual representation of symbol's declaration */
   def dclText(sym: Symbol): Text
 

compiler/src/dotty/tools/dotc/reporting/Reporter.scala

@@ -15,6 +15,7 @@ import diagnostic.messages._
 import diagnostic._
 import ast.{tpd, Trees}
 import Message._
+import core.Decorators._
 
 import java.lang.System.currentTimeMillis
 import java.io.{ BufferedReader, PrintWriter }

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

@@ -150,7 +150,10 @@ object ErrorReporting {
       val expected1 = reported(expected)
       val (found2, expected2) =
         if (found1 frozen_<:< expected1) (found, expected) else (found1, expected1)
-      TypeMismatch(found2, expected2, whyNoMatchStr(found, expected), postScript)
+      val postScript1 =
+        if !postScript.isEmpty then postScript
+        else ctx.typer.implicitSuggestionsFor(ViewProto(found.widen, expected))
+      TypeMismatch(found2, expected2, whyNoMatchStr(found, expected), postScript1)
     }
 
     /** Format `raw` implicitNotFound or implicitAmbiguous argument, replacing

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

@@ -37,6 +37,7 @@ import config.Printers.{implicits, implicitsDetailed}
 import collection.mutable
 import reporting.trace
 import annotation.tailrec
+import scala.util.control.NonFatal
 
 import scala.annotation.internal.sharable
 import scala.annotation.threadUnsafe
@@ -462,6 +463,66 @@ object Implicits {
     def explanation(implicit ctx: Context): String =
       em"${err.refStr(ref)} produces a diverging implicit search when trying to $qualify"
   }
+
+  /** A helper class to find imports of givens that might fix a type error.
+   *
+   *   suggestions(p).search
+   *
+   *  returns a list of TermRefs that refer to implicits or givens
+   *  that satisfy predicate `p`.
+   *
+   *  The search algorithm looks for givens in the smallest set of objects
+   *  and packages that includes
+   *
+   *   - any object that is a defined in an enclosing scope,
+   *   - any object that is a member of an enclosing class,
+   *   - any enclosing package (including the root package),
+   *   - any object that is a member of a searched object or package,
+   *   - any object or package from which something is imported in an enclosing scope,
+   *   - any package that is nested in a searched package, provided
+   *     the package was accessed in some way previously.
+   */
+  class suggestions(qualifies: TermRef => Boolean) with
+    private val seen = mutable.Set[TermRef]()
+
+    private def lookInside(root: Symbol)(given ctx: Context): Boolean =
+      !root.name.lastPart.contains('$')
+      && root.is(ModuleVal, butNot = JavaDefined)
+      && (root.isCompleted || !root.is(Package))
+
+    private def rootsIn(ref: TermRef)(given ctx: Context): List[TermRef] =
+      if seen.contains(ref) then Nil
+      else
+        implicitsDetailed.println(i"search in ${ref.symbol.fullName}")
+        seen += ref
+        ref :: ref.fields
+          .filter(fld => lookInside(fld.symbol))
+          .map(fld => TermRef(ref, fld.symbol.asTerm))
+          .flatMap(rootsIn)
+          .toList
+
+    private def rootsOnPath(tp: Type)(given ctx: Context): List[TermRef] = tp match
+      case ref: TermRef => rootsIn(ref) ::: rootsOnPath(ref.prefix)
+      case _ => Nil
+
+    private def roots(given ctx: Context): List[TermRef] =
+      if ctx.owner.exists then
+        val defined =
+          if ctx.scope eq ctx.outer.scope then Nil
+          else ctx.scope
+            .filter(lookInside(_))
+            .flatMap(sym => rootsIn(sym.termRef))
+        val imported =
+          if ctx.importInfo eq ctx.outer.importInfo then Nil
+          else ctx.importInfo.sym.info match
+            case ImportType(expr) => rootsOnPath(expr.tpe)
+            case _ => Nil
+        defined ++ imported ++ roots(given ctx.outer)
+      else Nil
+
+    def search(given ctx: Context): List[TermRef] =
+      roots.flatMap(_.implicitMembers.filter(qualifies))
+  end suggestions
 }
 
 import Implicits._
@@ -683,6 +744,35 @@ trait Implicits { self: Typer =>
     }
   }
 
+  /** An addendum to an error message where the error might be fixed
+   *  be some implicit value of type `pt` that is however not found.
+   *  The addendum suggests suggests implicit imports that might fix the problem.
+   */
+  override def implicitSuggestionsFor(pt: Type)(given ctx: Context): String =
+    val suggestedRefs =
+      try Implicits.suggestions(_ <:< pt).search(given ctx.fresh.setExploreTyperState())
+      catch case NonFatal(ex) => Nil
+    def refToRawString(ref: TermRef) = ctx.printer.toTextRef(ref).show
+    def refToString(ref: TermRef): String =
+      val raw = refToRawString(ref)
+      ref.prefix match
+        case prefix: TermRef if !raw.contains(".") => s"${refToRawString(prefix)}.$raw"
+        case _ => raw
+    def suggestStr(ref: TermRef) = i"  import ${refToString(ref)}"
+    if suggestedRefs.isEmpty then ""
+    else
+      val suggestions = suggestedRefs.map(suggestStr).distinct
+        // TermRefs might be different but generate the same strings
+      val fix =
+        if suggestions.tail.isEmpty then "The following import"
+        else "One of the following imports"
+      i"""
+         |
+         |$fix might fix the problem:
+         |
+         |$suggestions%\n%
+         """
+
   /** Handlers to synthesize implicits for special types */
   type SpecialHandler = (Type, Span) => Context => Tree
   type SpecialHandlers = List[(ClassSymbol, SpecialHandler)]
@@ -1215,32 +1305,37 @@ trait Implicits { self: Typer =>
             pt.typeSymbol.typeParams.map(_.name.unexpandedName.toString),
             pt.widenExpr.argInfos))
 
-        def hiddenImplicitsAddendum: String = arg.tpe match {
-          case fail: SearchFailureType =>
-
-            def hiddenImplicitNote(s: SearchSuccess) =
-              em"\n\nNote: given instance ${s.ref.symbol.showLocated} was not considered because it was not imported with `import given`."
+        def hiddenImplicitsAddendum: String =
+
+          def hiddenImplicitNote(s: SearchSuccess) =
+            em"\n\nNote: given instance ${s.ref.symbol.showLocated} was not considered because it was not imported with `import given`."
+
+          def FindHiddenImplicitsCtx(ctx: Context): Context =
+            if (ctx == NoContext) ctx
+            else ctx.freshOver(FindHiddenImplicitsCtx(ctx.outer)).addMode(Mode.FindHiddenImplicits)
+
+          val normalImports = arg.tpe match
+            case fail: SearchFailureType =>
+              if (fail.expectedType eq pt) || isFullyDefined(fail.expectedType, ForceDegree.none) then
+                inferImplicit(fail.expectedType, fail.argument, arg.span)(
+                  FindHiddenImplicitsCtx(ctx)) match {
+                  case s: SearchSuccess => hiddenImplicitNote(s)
+                  case f: SearchFailure =>
+                    f.reason match {
+                      case ambi: AmbiguousImplicits => hiddenImplicitNote(ambi.alt1)
+                      case r => ""
+                    }
+                }
+              else
+                // It's unsafe to search for parts of the expected type if they are not fully defined,
+                // since these come with nested contexts that are lost at this point. See #7249 for an
+                // example where searching for a nested type causes an infinite loop.
+                ""
 
-            def FindHiddenImplicitsCtx(ctx: Context): Context =
-              if (ctx == NoContext) ctx
-              else ctx.freshOver(FindHiddenImplicitsCtx(ctx.outer)).addMode(Mode.FindHiddenImplicits)
+          def suggestedImports = implicitSuggestionsFor(pt)
+          if normalImports.isEmpty then suggestedImports else normalImports
+        end hiddenImplicitsAddendum
 
-            if (fail.expectedType eq pt) || isFullyDefined(fail.expectedType, ForceDegree.none) then
-              inferImplicit(fail.expectedType, fail.argument, arg.span)(
-                FindHiddenImplicitsCtx(ctx)) match {
-                case s: SearchSuccess => hiddenImplicitNote(s)
-                case f: SearchFailure =>
-                  f.reason match {
-                    case ambi: AmbiguousImplicits => hiddenImplicitNote(ambi.alt1)
-                    case r => ""
-                  }
-              }
-            else
-              // It's unsafe to search for parts of the expected type if they are not fully defined,
-              // since these come with nested contexts that are lost at this point. See #7249 for an
-              // example where searching for a nested type causes an infinite loop.
-              ""
-        }
         msg(userDefined.getOrElse(
           em"no implicit argument of type $pt was found${location("for")}"))() ++
         hiddenImplicitsAddendum

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

@@ -11,6 +11,7 @@ import util.SourcePosition
 import config.Printers.typr
 import ast.Trees._
 import NameOps._
+import ProtoTypes._
 import collection.mutable
 import reporting.diagnostic.messages._
 import Checking.{checkNoPrivateLeaks, checkNoWildcard}
@@ -266,7 +267,7 @@ trait TypeAssigner {
       errorType(ex"$qualType does not have a constructor", tree.sourcePos)
     else {
       val kind = if (name.isTypeName) "type" else "value"
-      val addendum =
+      def addendum =
         if (qualType.derivesFrom(defn.DynamicClass))
           "\npossible cause: maybe a wrong Dynamic method signature?"
         else qual1.getAttachment(Typer.HiddenSearchFailure) match {
@@ -281,12 +282,17 @@ trait TypeAssigner {
                  |Note that `$name` is treated as an infix operator in Scala 3.
                  |If you do not want that, insert a `;` or empty line in front
                  |or drop any spaces behind the operator."""
-            else ""
+            else
+              implicitSuggestionsFor(
+                ViewProto(qualType.widen,
+                  SelectionProto(name, WildcardType, NoViewsAllowed, privateOK = false)))
         }
       errorType(NotAMember(qualType, name, kind, addendum), tree.sourcePos)
     }
   }
 
+  def implicitSuggestionsFor(pt: Type)(given Context): String = ""
+
   /** The type of the selection in `tree`, where `qual1` is the typed qualifier part.
    *  The selection type is additionally checked for accessibility.
    */

tests/neg/missing-implicit.check

@@ -0,0 +1,55 @@
+-- [E008] Member Not Found Error: tests/neg/missing-implicit.scala:5:25 ------------------------------------------------
+5 |  case x :: xs1 if limit > 0 => consume(xs1, limit - x) // error // error
+  |                   ^^^^^^^
+  |                   value > is not a member of T
+  |
+  |                   One of the following imports might fix the problem:
+  |
+  |                     import math.Ordering.Implicits.infixOrderingOps
+  |                     import math.Ordered.orderingToOrdered
+  |                            
+-- [E008] Member Not Found Error: tests/neg/missing-implicit.scala:5:51 ------------------------------------------------
+5 |  case x :: xs1 if limit > 0 => consume(xs1, limit - x) // error // error
+  |                                             ^^^^^^^
+  |                                             value - is not a member of T
+  |
+  |                                             One of the following imports might fix the problem:
+  |
+  |                                               import math.Fractional.Implicits.infixFractionalOps
+  |                                               import math.Numeric.Implicits.infixNumericOps
+  |                                               import math.Integral.Implicits.infixIntegralOps
+  |                                                      
+-- Error: tests/neg/missing-implicit.scala:10:24 -----------------------------------------------------------------------
+10 |val f = Future[Unit] { } // error
+   |                        ^
+   |                   Cannot find an implicit ExecutionContext. You might pass
+   |                   an (implicit ec: ExecutionContext) parameter to your method.
+   |
+   |                   The ExecutionContext is used to configure how and on which
+   |                   thread pools Futures will run, so the specific ExecutionContext
+   |                   that is selected is important.
+   |
+   |                   If your application does not define an ExecutionContext elsewhere,
+   |                   consider using Scala's global ExecutionContext by defining
+   |                   the following:
+   |
+   |                   implicit val ec: scala.concurrent.ExecutionContext = scala.concurrent.ExecutionContext.global
+   |
+   |                   The following import might fix the problem:
+   |
+   |                     import concurrent.ExecutionContext.Implicits.global
+   |                            
+-- [E007] Type Mismatch Error: tests/neg/missing-implicit.scala:12:25 --------------------------------------------------
+12 |val b: java.lang.Byte = (1: Byte) // error
+   |                         ^^^^^^^
+   |                         Found:    Byte
+   |                         Required: Byte²
+   |
+   |                         where:    Byte  is a class in package scala
+   |                                   Byte² is a class in package lang
+   |
+   |
+   |                         The following import might fix the problem:
+   |
+   |                           import Predef.byte2Byte
+   |                                  

tests/neg/missing-implicit.scala

@@ -0,0 +1,12 @@
+import Predef.{byte2Byte => _}
+import math.Numeric
+
+def consume[T: Numeric](xs: List[T], limit: T): List[T] = xs match
+  case x :: xs1 if limit > 0 => consume(xs1, limit - x) // error // error
+  case _ => xs
+
+import scala.concurrent.Future
+
+val f = Future[Unit] { } // error
+
+val b: java.lang.Byte = (1: Byte) // error