Implement changed import implied rules

`import implied` now also imports old-style implicits.

Missing implicits errors now report if an implied instance
could have been imported if a regular import is changed
to an import implied.

Author: odersky

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

@@ -101,4 +101,7 @@ object Mode {
 
   /** We are synthesizing the receiver of an extension method */
   val SynthesizeExtMethodReceiver: Mode = newMode(23, "SynthesizeExtMethodReceiver")
+
+  /** Are we trying to find a hidden implicit? */
+  val FindHiddenImplicits: Mode = newMode(24, "FindHiddenImplicits")
 }

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

@@ -364,7 +364,7 @@ object Implicits {
 
   abstract class SearchFailureType extends ErrorType {
     def expectedType: Type
-    protected def argument: Tree
+    def argument: Tree
 
     /** A "massaging" function for displayed types to give better info in error diagnostics */
     def clarify(tp: Type)(implicit ctx: Context): Type = tp
@@ -822,6 +822,7 @@ trait Implicits { self: Typer =>
   }
 
   def missingArgMsg(arg: Tree, pt: Type, where: String)(implicit ctx: Context): String = {
+
     def msg(shortForm: String)(headline: String = shortForm) = arg match {
       case arg: Trees.SearchFailureIdent[_] =>
         shortForm
@@ -836,6 +837,7 @@ trait Implicits { self: Typer =>
               |But ${tpe.explanation}."""
         }
     }
+
     def location(preposition: String) = if (where.isEmpty) "" else s" $preposition $where"
 
     /** Extract a user defined error message from a symbol `sym`
@@ -898,7 +900,30 @@ trait Implicits { self: Typer =>
             raw,
             pt.typeSymbol.typeParams.map(_.name.unexpandedName.toString),
             pt.argInfos))
-        msg(userDefined.getOrElse(em"no implicit argument of type $pt was found${location("for")}"))()
+
+        def hiddenImplicitsAddendum: String = arg.tpe match {
+          case fail: SearchFailureType =>
+
+            def hiddenImplicitNote(s: SearchSuccess) =
+              em"\n\nNote: implied instance ${s.ref.symbol.showLocated} was not considered because it was not imported with an `import implied`."
+
+            def FindHiddenImplicitsCtx(ctx: Context): Context =
+              if (ctx == NoContext) ctx
+              else ctx.freshOver(FindHiddenImplicitsCtx(ctx.outer)).addMode(Mode.FindHiddenImplicits)
+
+            inferImplicit(fail.expectedType, fail.argument, fail.argument.span)(
+              FindHiddenImplicitsCtx(ctx)) match {
+              case s: SearchSuccess => hiddenImplicitNote(s)
+              case f: SearchFailure =>
+                f.reason match {
+                  case ambi: AmbiguousImplicits => hiddenImplicitNote(ambi.alt1)
+                  case r => ""
+                }
+            }
+        }
+        msg(userDefined.getOrElse(
+          em"no implicit argument of type $pt was found${location("for")}"))() ++
+        hiddenImplicitsAddendum
     }
   }
 

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

@@ -95,7 +95,9 @@ class ImportInfo(symf: Context => Symbol, val selectors: List[untpd.Tree],
     recur(selectors)
   }
 
-  private def implicitFlag = if (importImplied) Implied else Implicit
+  private def implicitFlag(implicit ctx: Context) =
+    if (importImplied || ctx.mode.is(Mode.FindHiddenImplicits)) ImplicitOrImplied
+    else Implicit
 
   /** The implicit references imported by this import clause */
   def importedImplicits(implicit ctx: Context): List[ImplicitRef] = {

tests/pos/i5978.scala

@@ -4,27 +4,74 @@ opaque type Position[Buffer] = Int
 
 trait TokenParser[Token, R]
 
-object TextParser {
-  implied TP for TokenParser[Char, Position[CharSequence]] {}
+package p1 {
 
-  implied FromCharToken
-    given (T: TokenParser[Char, Position[CharSequence]]) for Conversion[Char, Position[CharSequence]] = ???
+  object TextParser {
+    implied TP for TokenParser[Char, Position[CharSequence]] {}
+
+    implied FromCharToken
+      given (T: TokenParser[Char, Position[CharSequence]]) for Conversion[Char, Position[CharSequence]] = ???
+  }
+
+
+  object Testcase {
+    def main(args: Array[String]): Unit = {
+      import implied TextParser._
+      import TextParser._
+
+      val tp_v: TokenParser[Char, Position[CharSequence]] = TextParser.TP
+      val tp_i = the[TokenParser[Char, Position[CharSequence]]]
+      val co_i = the[Conversion[Char, Position[CharSequence]]]
+      val co_x : Position[CharSequence] = 'x'
+
+      {
+        implied XXX for Conversion[Char, Position[CharSequence]] = co_i
+        val co_y : Position[CharSequence] = 'x'
+      }
+    }
+  }
+}
+package p2 {
+
+  object TextParser {
+    implicit object TP extends TokenParser[Char, Position[CharSequence]] {}
+
+    implicit def FromCharToken(c: Char)(implicit T: TokenParser[Char, Position[CharSequence]]): Position[CharSequence] = ???
+  }
+
+  object Testcase {
+    def main(args: Array[String]): Unit = {
+      import TextParser._
+      import implied TextParser._
+
+      val tp_v: TokenParser[Char, Position[CharSequence]] = TextParser.TP
+      val tp_i = the[TokenParser[Char, Position[CharSequence]]]
+      val co_x : Position[CharSequence] = 'x'
+    }
+  }
 }
+package p3 {
 
+  object TextParser {
+    implicit object TP extends TokenParser[Char, Position[CharSequence]] {}
+
+    implicit def FromCharToken(implicit T: TokenParser[Char, Position[CharSequence]]): Conversion[Char, Position[CharSequence]] = ???
+  }
 
-object Testcase {
-  def main(args: Array[String]): Unit = {
-    import TextParser._
-    import implied TextParser._
+  object Testcase {
+    def main(args: Array[String]): Unit = {
+      import implied TextParser._
+      import TextParser._
 
-    val tp_v: TokenParser[Char, Position[CharSequence]] = TextParser.TP
-    val tp_i = the[TokenParser[Char, Position[CharSequence]]]
-    val co_i = the[Conversion[Char, Position[CharSequence]]]
-    val co_x : Position[CharSequence] = 'x'
+      val tp_v: TokenParser[Char, Position[CharSequence]] = TextParser.TP
+      val tp_i = the[TokenParser[Char, Position[CharSequence]]]
+      implicit val co_i: Conversion[Char, Position[CharSequence]] = the[Conversion[Char, Position[CharSequence]]]
+      val co_x : Position[CharSequence] = 'x'
 
-    {
-      implied XXX for Conversion[Char, Position[CharSequence]] = co_i
-      val co_y : Position[CharSequence] = 'x'
+      {
+        implied XXX for Conversion[Char, Position[CharSequence]] = co_i
+        val co_y : Position[CharSequence] = 'x'
+      }
     }
   }
 }