Warn when a user defined error message references undefined names

[Jasper-M]

Currently dotty doesn't warn when you reference an unknown type parameter, but silently accepts it. It might be friendlier towards the user to warn that he probably made a typo.

scala> @annotation.implicitNotFound("Bar[${B}] not found") trait Bar[A] 
// defined trait Bar
scala> implicitly[Bar[String]] 
1 |implicitly[Bar[String]]
  |                       ^
  |                       Bar[${B}] not found

[Blaisorblade]

Agreed that would be better, and @smarter already agreed in #4007 (comment).

I tried triaging and labeling but I'm new here, might have to revisit.

[YourPsychiatrist]

I have pretty much figured out how to implement this. Something that still puzzles me though: The argument to the annotation is not interpolated (with the s string context for example);

So what I am asking myself is: Is there a string interpolation subsystem somewhere in the compiler that I can use to extract terms or would I have to implement that myself since the interpolation actually uses the compiler state context and not the program context?

Once that question is cleared, i'd gladly take care of the issue!

[Blaisorblade]

Others know better, but AFAIK: There is an interpolation subsystem in Dotty for Dotty's use, but the arguments of implicitNotFound are parsed using different code; so I don't think I understand the question well.

1. The compiler does have all sorts of interpolators for producing error messages — many are used in:
   https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/reporting/messages.scala.
   And some (including ex) were introduced in 8d4d9a3.
2. Here's how implicitNotFound arguments are parsed, AFAICS:
   https://github.com/lampepfl/dotty/blob/aa64078d9defe1df6856158a16c1f236792231f2/compiler/src/dotty/tools/dotc/typer/ErrorReporting.scala#L131-L142.

However, that code is run when the message is actually used, so the error must be added elsewhere.

[YourPsychiatrist]

Yes this seems like the use-site error reporting. For the declaration of the user-defined error string, I am looking through the literal in the RefChecks phase. But I don't want to reimplement this special kind of interpolation. Is there a spec for how such user defined messages can be structured? Is it equal to what the s context provides?

[smarter]

Is there a spec for how such user defined messages can be structured?

The documentation of the annotation has some details: https://www.scala-lang.org/api/2.13.3/scala/annotation/implicitNotFound.html

[YourPsychiatrist]

Ah! Thank you kindly, then I should be all set.

[YourPsychiatrist]

Just for the reference, I want to also add the def case to this issue since its in the same domain:

class K[A] {
  def m[B](implicit c: C[List[A], B]) = 0
  def n[B](implicit @implicitNotFound("Specific message for C of list of ${A} and ${B}") c: C[List[A], B]) = 1
}

For the sake of completeness, I feel like this issue should also cover this case (more generally, for all DefDefs, including constructors)