Make suggestions of missing implicits imports on type errors

compiler/src/dotty/tools/dotc/Run.scala

@@ -31,6 +31,12 @@ import scala.util.control.NonFatal
 /** A compiler run. Exports various methods to compile source files */
 class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with ConstraintRunInfo {
 
+  /** If this variable is set to `true`, some core typer operations will
+   *  return immediately. Currently these early abort operations are
+   *  `Typer.typed` and `Implicits.typedImplicit`.
+   */
+  @volatile var isCancelled = false
+
   /** Produces the following contexts, from outermost to innermost
    *
    *    bootStrap:   A context with next available runId and a scope consisting of

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -210,7 +210,9 @@ class Definitions {
   }
   @tu lazy val ScalaPackageObject: Symbol = ctx.requiredModule("scala.package")
   @tu lazy val JavaPackageVal: TermSymbol = ctx.requiredPackage(nme.java)
+  @tu lazy val JavaPackageClass: ClassSymbol = JavaPackageVal.moduleClass.asClass
   @tu lazy val JavaLangPackageVal: TermSymbol = ctx.requiredPackage(jnme.JavaLang)
+  @tu lazy val JavaLangPackageClass: ClassSymbol = JavaLangPackageVal.moduleClass.asClass
 
   // fundamental modules
   @tu lazy val SysPackage : Symbol = ctx.requiredModule("scala.sys.package")

compiler/src/dotty/tools/dotc/core/SymDenotations.scala

@@ -2205,7 +2205,7 @@ object SymDenotations {
 
       if (symbol `eq` defn.ScalaPackageClass) {
         val denots = super.computeNPMembersNamed(name)
-        if (denots.exists) denots
+        if (denots.exists || name == nme.CONSTRUCTOR) denots
         else recur(packageObjs, NoDenotation)
       }
       else recur(packageObjs, NoDenotation)

compiler/src/dotty/tools/dotc/core/TypeErrors.scala

@@ -153,7 +153,7 @@ object CyclicReference {
   def apply(denot: SymDenotation)(implicit ctx: Context): CyclicReference = {
     val ex = new CyclicReference(denot)
     if (!(ctx.mode is Mode.CheckCyclic)) {
-      cyclicErrors.println(ex.getMessage)
+      cyclicErrors.println(s"Cyclic reference involving $denot")
       for (elem <- ex.getStackTrace take 200)
         cyclicErrors.println(elem.toString)
     }

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/reporting/diagnostic/messages.scala

@@ -345,8 +345,10 @@ object messages {
       // Get closest match in `site`
       val closest =
         decls
-        .map { case (n, sym) => (n, distance(n, name.show), sym) }
-        .collect { case (n, dist, sym) if dist <= maxDist => (n, dist, sym) }
+        .map { (n, sym) => (n, distance(n, name.show), sym) }
+        .collect {
+          case (n, dist, sym) if dist <= maxDist && dist < name.toString.length => (n, dist, sym)
+        }
         .groupBy(_._2).toList
         .sortBy(_._1)
         .headOption.map(_._2).getOrElse(Nil)

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

@@ -150,7 +150,15 @@ 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
+           || expected.isRef(defn.AnyClass)
+           || expected.isRef(defn.AnyValClass)
+           || expected.isRef(defn.ObjectClass)
+           || defn.isBottomType(found)
+        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

@@ -14,7 +14,7 @@ import Flags._
 import TypeErasure.{erasure, hasStableErasure}
 import Mode.ImplicitsEnabled
 import NameOps._
-import NameKinds.LazyImplicitName
+import NameKinds.{LazyImplicitName, FlatName}
 import Symbols._
 import Denotations._
 import Types._
@@ -37,6 +37,8 @@ import config.Printers.{implicits, implicitsDetailed}
 import collection.mutable
 import reporting.trace
 import annotation.tailrec
+import scala.util.control.NonFatal
+import java.util.{Timer, TimerTask}
 
 import scala.annotation.internal.sharable
 import scala.annotation.threadUnsafe
@@ -67,6 +69,12 @@ object Implicits {
     final val Extension = 4
   }
 
+  /** Timeout to test a single implicit value as a suggestion, in ms */
+  val testOneImplicitTimeOut = 500
+
+  /** Global timeout to stop looking for further implicit suggestions, in ms */
+  val suggestImplicitTimeOut = 10000
+
   /** A common base class of contextual implicits and of-type implicits which
    *  represents a set of references to implicit definitions.
    */
@@ -462,6 +470,125 @@ 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 Context): Boolean =
+      if root.is(Package) then root.isTerm && root.isCompleted
+      else !root.name.is(FlatName)
+        && !root.name.lastPart.contains('$')
+        && root.is(ModuleVal, butNot = JavaDefined)
+
+    def nestedRoots(site: Type)(given Context): List[Symbol] =
+      val seenNames = mutable.Set[Name]()
+      site.baseClasses.flatMap { bc =>
+        bc.info.decls.filter { dcl =>
+          lookInside(dcl)
+          && !seenNames.contains(dcl.name)
+          && { seenNames += dcl.name; true }
+        }
+      }
+
+    private def rootsStrictlyIn(ref: Type)(given Context): List[TermRef] =
+      val site = ref.widen
+      val refSym = site.typeSymbol
+      val nested =
+        if refSym.is(Package) then
+          if refSym == defn.EmptyPackageClass       // Don't search the empty package
+             || refSym == defn.JavaPackageClass     // As an optimization, don't search java...
+             || refSym == defn.JavaLangPackageClass // ... or java.lang.
+          then Nil
+          else refSym.info.decls.filter(lookInside)
+        else
+          if !refSym.is(Touched) then refSym.ensureCompleted() // JavaDefined is reliably known only after completion
+          if refSym.is(JavaDefined) then Nil
+          else nestedRoots(site)
+      nested
+        .map(mbr => TermRef(ref, mbr.asTerm))
+        .flatMap(rootsIn)
+        .toList
+
+    private def rootsIn(ref: TermRef)(given Context): List[TermRef] =
+      if seen.contains(ref) then Nil
+      else
+        implicits.println(i"search for suggestions in ${ref.symbol.fullName}")
+        seen += ref
+        ref :: rootsStrictlyIn(ref)
+
+    private def rootsOnPath(tp: Type)(given 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.owner.isClass then
+            if ctx.owner eq ctx.outer.owner then Nil
+            else rootsStrictlyIn(ctx.owner.thisType)
+          else
+            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] =
+      val timer = new Timer()
+      val deadLine = System.currentTimeMillis() + suggestImplicitTimeOut
+
+      def test(ref: TermRef)(given Context): Boolean =
+        System.currentTimeMillis < deadLine
+        && {
+          val task = new TimerTask with
+            def run() =
+              implicits.println(i"Cancelling test of $ref when making suggestions for error in ${ctx.source}")
+              ctx.run.isCancelled = true
+          timer.schedule(task, testOneImplicitTimeOut)
+          try qualifies(ref)
+          finally
+            task.cancel()
+            ctx.run.isCancelled = false
+        }
+
+      try
+        roots
+          .filterNot(root => defn.RootImportTypes.exists(_.symbol == root.symbol))
+            // don't suggest things that are imported by default
+          .flatMap(_.implicitMembers.filter(test))
+      catch
+        case ex: Throwable =>
+          if ctx.settings.Ydebug.value then
+          	println("caught exception when searching for suggestions")
+          	ex.printStackTrace()
+          Nil
+      finally timer.cancel()
+    end search
+  end suggestions
 }
 
 import Implicits._
@@ -683,6 +810,33 @@ trait Implicits { self: Typer =>
     }
   }
 
+  /** An addendum to an error message where the error might be fixed
+   *  by some implicit value of type `pt` that is however not found.
+   *  The addendum suggests given imports that might fix the problem.
+   *  If there's nothing to suggest, an empty string is returned.
+   */
+  override def implicitSuggestionsFor(pt: Type)(given ctx: Context): String =
+    val suggestedRefs =
+      Implicits.suggestions(_ <:< pt).search(given ctx.fresh.setExploreTyperState())
+    def importString(ref: TermRef): String =
+      s"  import ${ctx.printer.toTextRef(ref).show}"
+    val suggestions = suggestedRefs.map(importString)
+      .filter(_.contains('.'))
+      .distinct  // TermRefs might be different but generate the same strings
+      .sorted    // To get test stability. TODO: Find more useful sorting criteria
+    if suggestions.isEmpty then ""
+    else
+      val fix =
+        if suggestions.tail.isEmpty then "The following import"
+        else "One of the following imports"
+      i"""
+         |
+         |$fix might fix the problem:
+         |
+         |$suggestions%\n%
+         """
+  end implicitSuggestionsFor
+
   /** Handlers to synthesize implicits for special types */
   type SpecialHandler = (Type, Span) => Context => Tree
   type SpecialHandlers = List[(ClassSymbol, SpecialHandler)]
@@ -1215,32 +1369,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
@@ -1378,6 +1537,7 @@ trait Implicits { self: Typer =>
 
     /** Try to typecheck an implicit reference */
     def typedImplicit(cand: Candidate, contextual: Boolean)(implicit ctx: Context): SearchResult = trace(i"typed implicit ${cand.ref}, pt = $pt, implicitsEnabled == ${ctx.mode is ImplicitsEnabled}", implicits, show = true) {
+      if ctx.run.isCancelled then return NoMatchingImplicitsFailure
       record("typedImplicit")
       val ref = cand.ref
       val generated: Tree = tpd.ref(ref).withSpan(span.startPos)