The great implicits re-org

Refactoring of implicits with the aim of clearer code and better error
messages. Here's an example:

    -- Error: implicitSearch.scala:15:12 -------------------------------------------
    15 |    sort(xs)  // error (with a partially constructed implicit argument shown)
       |            ^
       |no implicit argument of type Test.Ord[scala.collection.immutable.List[scala.collection.immutable.List[T]]] was found for parameter o of method sort in object Test.
       |I found:
       |
       |    Test.listOrd[T](Test.listOrd[T](/* missing */implicitly[Test.Ord[T]]))
       |
       |But no implicit values were found that match type Test.Ord[T].

Author: odersky

compiler/src/dotty/tools/dotc/ast/Trees.scala

@@ -145,9 +145,9 @@ object Trees {
     }
 
     /** A unique identifier for this tree. Used for debugging, and potentially
-     *  tracking presentation compiler interactions
+     *  tracking presentation compiler interactions.
      */
-    private var myUniqueId: Int = nxId
+    @sharable private var myUniqueId: Int = nxId
 
     def uniqueId = myUniqueId
 
@@ -449,6 +449,11 @@ object Trees {
     override def toString = s"BackquotedIdent($name)"
   }
 
+  class SearchFailureIdent[-T >: Untyped] private[ast] (name: Name)
+    extends Ident[T](name) {
+    override def toString = s"SearchFailureIdent($name)"
+  }
+
   /** qualifier.name, or qualifier#name, if qualifier is a type */
   case class Select[-T >: Untyped] private[ast] (qualifier: Tree[T], name: Name)
     extends RefTree[T] {
@@ -948,6 +953,7 @@ object Trees {
 
     type Ident = Trees.Ident[T]
     type BackquotedIdent = Trees.BackquotedIdent[T]
+    type SearchFailureIdent = Trees.SearchFailureIdent[T]
     type Select = Trees.Select[T]
     type SelectWithSig = Trees.SelectWithSig[T]
     type This = Trees.This[T]

compiler/src/dotty/tools/dotc/ast/untpd.scala

@@ -282,6 +282,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
 
   def Ident(name: Name): Ident = new Ident(name)
   def BackquotedIdent(name: Name): BackquotedIdent = new BackquotedIdent(name)
+  def SearchFailureIdent(name: Name): SearchFailureIdent = new SearchFailureIdent(name)
   def Select(qualifier: Tree, name: Name): Select = new Select(qualifier, name)
   def SelectWithSig(qualifier: Tree, name: Name, sig: Signature): Select = new SelectWithSig(qualifier, name, sig)
   def This(qual: Ident): This = new This(qual)

compiler/src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -26,7 +26,6 @@ class ScalaSettings extends Settings.SettingGroup {
   val migration = BooleanSetting("-migration", "Emit warning and location for migration issues from Scala 2.")
   val encoding = StringSetting("-encoding", "encoding", "Specify character encoding used by source files.", Properties.sourceEncoding)
   val explainTypes = BooleanSetting("-explain-types", "Explain type errors in more detail.")
-  val explainImplicits = BooleanSetting("-explain-implicits", "Explain implicit search errors in more detail.")
   val explain = BooleanSetting("-explain", "Explain errors in more detail.")
   val feature = BooleanSetting("-feature", "Emit warning and location for usages of features that should be imported explicitly.")
   val help = BooleanSetting("-help", "Print a synopsis of standard options")

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

@@ -1981,7 +1981,7 @@ object Types {
       else candidate
 
     def withPrefix(prefix: Type)(implicit ctx: Context): NamedType = designator match {
-      case designator: TermSymbol =>
+      case designator: TermSymbol @unchecked =>
         TermRef(prefix, designator)
       case _ =>
         // If symbol exists, the new signature is the symbol's signature as seen
@@ -3641,22 +3641,25 @@ object Types {
    */
   abstract class FlexType extends UncachedGroundType with ValueType
 
-  class ErrorType private[Types] () extends FlexType {
-    def msg(implicit ctx: Context): Message =
-      ctx.errorTypeMsg.get(this) match {
-        case Some(msgFun) => msgFun()
-        case None => "error message from previous run no longer available"
-      }
+  abstract class ErrorType extends FlexType {
+    def msg(implicit ctx: Context): Message
   }
+
   object ErrorType {
     def apply(msg: => Message)(implicit ctx: Context): ErrorType = {
-      val et = new ErrorType
+      val et = new ErrorType {
+        def msg(implicit ctx: Context): Message =
+          ctx.errorTypeMsg.get(this) match {
+            case Some(msgFun) => msgFun()
+            case None => "error message from previous run no longer available"
+          }
+      }
       ctx.base.errorTypeMsg(et) = () => msg
       et
     }
   }
 
-  object UnspecifiedErrorType extends ErrorType() {
+  object UnspecifiedErrorType extends ErrorType {
     override def msg(implicit ctx: Context): Message = "unspecified error"
   }
 

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

@@ -171,8 +171,8 @@ class PlainPrinter(_ctx: Context) extends Printer {
         changePrec(AndPrec) { toText(tp1) ~ " & " ~ toText(tp2) }
       case OrType(tp1, tp2) =>
         changePrec(OrPrec) { toText(tp1) ~ " | " ~ toText(tp2) }
-      case _: ErrorType =>
-        "<error>"
+      case tp: ErrorType =>
+        s"<error ${tp.msg.msg}>"
       case tp: WildcardType =>
         if (tp.optBounds.exists) "(?" ~ toTextRHS(tp.bounds) ~ ")" else "?"
       case NoType =>
@@ -202,8 +202,6 @@ class PlainPrinter(_ctx: Context) extends Printer {
         ParamRefNameString(tp) ~ ".type"
       case AnnotatedType(tpe, annot) =>
         toTextLocal(tpe) ~ " " ~ toText(annot)
-      case AppliedType(tycon, args) =>
-        toTextLocal(tycon) ~ "[" ~ Text(args.map(argText), ", ") ~ "]"
       case tp: TypeVar =>
         if (tp.isInstantiated)
           toTextLocal(tp.instanceOpt) ~ ("^" provided ctx.settings.YprintDebug.value)
@@ -501,18 +499,16 @@ class PlainPrinter(_ctx: Context) extends Printer {
   def toText(result: SearchResult): Text = result match {
     case result: SearchSuccess =>
       "SearchSuccess: " ~ toText(result.ref) ~ " via " ~ toText(result.tree)
-    case _: NonMatchingImplicit | NoImplicitMatches =>
-      "NoImplicitMatches"
-    case _: DivergingImplicit =>
-      "Diverging Implicit"
-    case result: ShadowedImplicit =>
-      "Shadowed Implicit"
-    case result: FailedImplicit =>
-      "Failed Implicit"
-    case result: AmbiguousImplicits =>
-      "Ambiguous Implicit: " ~ toText(result.alt1) ~ " and " ~ toText(result.alt2)
-    case _ =>
-      "?Unknown Implicit Result?" + result.getClass
+    case result: SearchFailure =>
+      result.reason match {
+        case _: NoMatchingImplicits => "No Matching Implicit"
+        case _: DivergingImplicit => "Diverging Implicit"
+        case _: ShadowedImplicit => "Shadowed Implicit"
+        case result: AmbiguousImplicits =>
+          "Ambiguous Implicit: " ~ toText(result.alt1) ~ " and " ~ toText(result.alt2)
+        case _ =>
+          "?Unknown Implicit Result?" + result.getClass
+    }
   }
 
   def toText(importInfo: ImportInfo): Text = {

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

@@ -7,7 +7,7 @@ import TypeErasure.ErasedValueType
 import Contexts.Context, Scopes.Scope, Denotations._, SymDenotations._, Annotations.Annotation
 import StdNames.{nme, tpnme}
 import ast.{Trees, untpd, tpd}
-import typer.{Namer, Inliner}
+import typer.{Namer, Inliner, Implicits}
 import typer.ProtoTypes.{SelectionProto, ViewProto, FunProto, IgnoredProto, dummyTreeOfType}
 import Trees._
 import TypeApplications._
@@ -332,6 +332,13 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     def toTextCore(tree: Tree): Text = tree match {
       case id: Trees.BackquotedIdent[_] if !homogenizedView =>
         "`" ~ toText(id.name) ~ "`"
+      case id: Trees.SearchFailureIdent[_] =>
+        tree.typeOpt match {
+          case reason: Implicits.SearchFailureType =>
+            toText(id.name) ~ "implicitly[" ~ toText(reason.expectedType) ~ "]"
+          case _ =>
+            toText(id.name)
+        }
       case Ident(name) =>
         tree.typeOpt match {
           case tp: NamedType if name != nme.WILDCARD =>

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

@@ -104,11 +104,11 @@ object ErrorReporting {
 
     def patternConstrStr(tree: Tree): String = ???
 
-    def typeMismatch(tree: Tree, pt: Type, implicitFailure: SearchFailure = NoImplicitMatches): Tree = {
+    def typeMismatch(tree: Tree, pt: Type, implicitFailure: SearchFailureType = NoMatchingImplicits): Tree = {
       val normTp = normalize(tree.tpe, pt)
       val treeTp = if (normTp <:< pt) tree.tpe else normTp
         // use normalized type if that also shows an error, original type otherwise
-      errorTree(tree, typeMismatchMsg(treeTp, pt, implicitFailure.postscript))
+      errorTree(tree, typeMismatchMsg(treeTp, pt, implicitFailure.whyNoConversion))
     }
 
     /** A subtype log explaining why `found` does not conform to `expected` */