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)
@@ -438,6 +438,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
     (kindString(sym) ~~ {
       if (sym.isAnonymousClass) toTextParents(sym.info.parents) ~~ "{...}"
       else if (hasMeaninglessName(sym) && !printDebug) simpleNameString(sym.owner) + idString(sym)
+      else if sym.is(Package) then fullNameString(sym)
       else nameString(sym)
     }).close
 

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/printing/RefinedPrinter.scala

@@ -900,6 +900,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     def name =
       if (printDebug)
         nameString(sym)
+      else if sym.is(Package) then
+        fullNameString(sym)
       else if (sym.is(ModuleClass) && sym.isPackageObject && sym.name.stripModuleClassSuffix == tpnme.PACKAGE)
         nameString(sym.owner.name)
       else if (sym.is(ModuleClass))

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,12 @@ 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 min n.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.implicitSuggestionAddendum(ViewProto(found.widen, expected))
+      TypeMismatch(found2, expected2, whyNoMatchStr(found, expected), postScript1)
     }
 
     /** Format `raw` implicitNotFound or implicitAmbiguous argument, replacing