Backport "Add note about type mismatch in automatically inserted apply argument" to LTS

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

@@ -18,6 +18,9 @@ class ExploringReporter extends StoreReporter(null, fromTyperState = false):
   override def removeBufferedMessages(using Context): List[Diagnostic] =
     try infos.toList finally reset()
 
+  override def mapBufferedMessages(f: Diagnostic => Diagnostic)(using Context): Unit =
+    infos.mapInPlace(f)
+
   def reset(): Unit = infos.clear()
 
-end ExploringReporter
+end ExploringReporter

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

@@ -270,6 +270,9 @@ abstract class Reporter extends interfaces.ReporterResult {
   /** If this reporter buffers messages, remove and return all buffered messages. */
   def removeBufferedMessages(using Context): List[Diagnostic] = Nil
 
+  /** If this reporter buffers messages, apply `f` to all buffered messages. */
+  def mapBufferedMessages(f: Diagnostic => Diagnostic)(using Context): Unit = ()
+
   /** Issue all messages in this reporter to next outer one, or make sure they are written. */
   def flush()(using Context): Unit =
     val msgs = removeBufferedMessages

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

@@ -21,7 +21,7 @@ class StoreReporter(outer: Reporter | Null = Reporter.NoReporter, fromTyperState
 
   protected var infos: mutable.ListBuffer[Diagnostic] | Null = null
 
-  def doReport(dia: Diagnostic)(using Context): Unit = {
+  override def doReport(dia: Diagnostic)(using Context): Unit = {
     typr.println(s">>>> StoredError: ${dia.message}") // !!! DEBUG
     if (infos == null) infos = new mutable.ListBuffer
     infos.uncheckedNN += dia
@@ -37,6 +37,9 @@ class StoreReporter(outer: Reporter | Null = Reporter.NoReporter, fromTyperState
     if (infos != null) try infos.uncheckedNN.toList finally infos = null
     else Nil
 
+  override def mapBufferedMessages(f: Diagnostic => Diagnostic)(using Context): Unit =
+    if infos != null then infos.uncheckedNN.mapInPlace(f)
+
   override def pendingMessages(using Context): List[Diagnostic] =
     if (infos != null) infos.uncheckedNN.toList else Nil
 

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

@@ -287,7 +287,7 @@ extends NotFoundMsg(MissingIdentID) {
   }
 }
 
-class TypeMismatch(val found: Type, expected: Type, inTree: Option[untpd.Tree], addenda: => String*)(using Context)
+class TypeMismatch(val found: Type, expected: Type, val inTree: Option[untpd.Tree], addenda: => String*)(using Context)
   extends TypeMismatchMsg(found, expected)(TypeMismatchID):
 
   def msg(using Context) =

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

@@ -1020,6 +1020,33 @@ trait Applications extends Compatibility {
             }
           }
 
+       /** If the applied function is an automatically inserted `apply`
+        * method and one of its arguments has a type mismatch , append
+        * a note to the error message that explains where the required
+        * type comes from. See #19680 and associated test case.
+        */
+      def maybeAddInsertedApplyNote(failedState: TyperState, fun1: Tree)(using Context): Unit =
+        if fun1.symbol.name == nme.apply && fun1.span.isSynthetic then
+          fun1 match
+            case Select(qualifier, _) =>
+              def mapMessage(dia: Diagnostic): Diagnostic =
+                dia match
+                  case dia: Diagnostic.Error =>
+                    dia.msg match
+                      case msg: TypeMismatch =>
+                        msg.inTree match
+                          case Some(arg) if tree.args.exists(_.span == arg.span) =>
+                            val noteText =
+                              i"""The required type comes from a parameter of the automatically
+                                  |inserted `apply` method of `${qualifier.tpe}`.""".stripMargin
+                            Diagnostic.Error(msg.appendExplanation("\n\n" + noteText), dia.pos)
+                          case _ => dia
+                      case msg => dia
+                  case dia => dia
+              failedState.reporter.mapBufferedMessages(mapMessage)
+            case _ => ()
+        else ()
+
       fun1.tpe match {
         case err: ErrorType => cpy.Apply(tree)(fun1, proto.typedArgs()).withType(err)
         case TryDynamicCallType =>
@@ -1080,7 +1107,11 @@ trait Applications extends Compatibility {
               simpleApply(fun1, proto)
             } {
               (failedVal, failedState) =>
-                def fail = { failedState.commit(); failedVal }
+                def fail =
+                  maybeAddInsertedApplyNote(failedState, fun1)
+                  failedState.commit()
+                  failedVal
+
                 // Try once with original prototype and once (if different) with tupled one.
                 // The reason we need to try both is that the decision whether to use tupled
                 // or not was already taken but might have to be revised when an implicit

tests/neg/19680.check

@@ -0,0 +1,23 @@
+-- [E007] Type Mismatch Error: tests/neg/19680.scala:9:67 --------------------------------------------------------------
+9 |def renderWidget(using Config): Unit = renderWebsite("/tmp")(Config()) // error: found Config, required Int
+  |                                                             ^^^^^^^^
+  |                                                             Found:    Config
+  |                                                             Required: Int
+  |---------------------------------------------------------------------------------------------------------------------
+  | Explanation (enabled by `-explain`)
+  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  |
+  | Tree: new Config()
+  | I tried to show that
+  |   Config
+  | conforms to
+  |   Int
+  | but none of the attempts shown below succeeded:
+  |
+  |   ==> Config  <:  Int  = false
+  |
+  | The tests were made under the empty constraint
+  |
+  | The required type comes from a parameter of the automatically
+  | inserted `apply` method of `scala.collection.StringOps`.
+   ---------------------------------------------------------------------------------------------------------------------

tests/neg/19680.scala

@@ -0,0 +1,9 @@
+//> using options -explain
+
+// Tests that the error message indicates that the required type `Int` comes
+// from the automatically inserted `apply` method of `String`. This note is
+// inserted by `insertedApplyNote` in `Applications`.
+
+class Config()
+def renderWebsite(path: String)(using config: Config): String = ???
+def renderWidget(using Config): Unit = renderWebsite("/tmp")(Config()) // error: found Config, required Int

tests/neg/19680b.check

@@ -0,0 +1,24 @@
+-- [E007] Type Mismatch Error: tests/neg/19680b.scala:2:21 -------------------------------------------------------------
+2 |def Test = List(1,2)("hello") // error: found String, required Int
+  |                     ^^^^^^^
+  |                     Found:    ("hello" : String)
+  |                     Required: Int
+  |---------------------------------------------------------------------------------------------------------------------
+  | Explanation (enabled by `-explain`)
+  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  |
+  | Tree: "hello"
+  | I tried to show that
+  |   ("hello" : String)
+  | conforms to
+  |   Int
+  | but none of the attempts shown below succeeded:
+  |
+  |   ==> ("hello" : String)  <:  Int
+  |     ==> String  <:  Int  = false
+  |
+  | The tests were made under the empty constraint
+  |
+  | The required type comes from a parameter of the automatically
+  | inserted `apply` method of `List[Int]`.
+   ---------------------------------------------------------------------------------------------------------------------

tests/neg/19680b.scala

@@ -0,0 +1,2 @@
+//> using options -explain
+def Test = List(1,2)("hello") // error: found String, required Int