Implement mvp of #4008

Author: Niklas Vest

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

@@ -164,7 +164,8 @@ enum ErrorMessageID extends java.lang.Enum[ErrorMessageID] {
     UnexpectedPatternForSummonFromID,
     AnonymousInstanceCannotBeEmptyID,
     TypeSpliceInValPatternID,
-    ModifierNotAllowedForDefinitionID
+    ModifierNotAllowedForDefinitionID,
+    InvalidReferenceInImplicitNotFoundAnnotationID
 
   def errorNumber = ordinal - 2
 }

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

@@ -2390,3 +2390,14 @@ import ast.tpd
     def msg = s"Modifier `${flag.flagsString}` is not allowed for this definition"
     def explain = ""
   }
+
+  class InvalidReferenceInImplicitNotFoundAnnotation(typeVar: String,full: String, owner: String)(using Context)
+    extends ReferenceMsg(InvalidReferenceInImplicitNotFoundAnnotationID) {
+    def msg = em"""|Invalid reference to a type variable "${hl(typeVar)}" found
+                   | in the user-defined error message ${hl("\"" + full + "\"")}
+                   |  in the @${ctx.definitions.ImplicitNotFoundAnnot.name.show} annotation argument.
+                   |
+                   |The variable does not occur in the signature of ${hl(owner)}.
+                   |""".stripMargin
+    def explain = ""
+  }

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

@@ -4,7 +4,7 @@ package typer
 import transform._
 import core._
 import Symbols._, Types._, Contexts._, Flags._, Names._, NameOps._
-import StdNames._, Denotations._, SymUtils._, Phases._
+import StdNames._, Denotations._, SymUtils._, Phases._, SymDenotations._
 import NameKinds.DefaultGetterName
 import Annotations._
 import util.Spans._
@@ -19,9 +19,11 @@ import Decorators._
 import typer.ErrorReporting._
 import config.Feature.warnOnMigration
 import reporting._
+import scala.util.matching.Regex._
+import Constants.Constant
 
 object RefChecks {
-  import tpd.{Tree, MemberDef}
+  import tpd.{Tree, MemberDef, Literal, Template, DefDef}
 
   val name: String = "refchecks"
 
@@ -926,6 +928,24 @@ object RefChecks {
   }
 
   val NoLevelInfo: RefChecks.OptLevelInfo = new OptLevelInfo()
+
+  /**
+   * Verify that references in the implicitNotFound annotation user-defined message are valid.
+   * (i.e. they refer to a type variable that really occurs in the signature of the annotated symbol.)
+   */
+  private def checkImplicitNotFoundAnnotation(tree: Template, sd: SymDenotation)(using Context): Unit =
+    for
+      annotation <- sd.annotations if annotation.symbol == ctx.definitions.ImplicitNotFoundAnnot
+      arg <- annotation.arguments.collect { case Literal(c: Constant) => c.stringValue }
+    do
+      // matches quoted references such as "${(A)}", "${(Abc)}", etc.
+      val reference = """(?<=\$\{)[a-zA-Z]+(?=\})""".r
+      val matches = reference.findAllMatchIn(arg)
+      for Match(ref) <- matches if !sd.typeParams.exists(_.denot.name.show == ref) do
+        val msg = InvalidReferenceInImplicitNotFoundAnnotation(ref, arg, sd.name.show)
+        val pos = ctx.source.atSpan(sd.symbol.span)
+        report.warning(msg, pos)
+
 }
 import RefChecks._
 
@@ -1012,6 +1032,7 @@ class RefChecks extends MiniPhase { thisPhase =>
     if (cls.is(Trait)) tree.parents.foreach(checkParentPrefix(cls, _))
     checkCompanionNameClashes(cls)
     checkAllOverrides(cls)
+    checkImplicitNotFoundAnnotation(tree, cls.classDenot)
     tree
   }
   catch {

tests/neg-custom-args/fatal-warnings/i4008.check

@@ -0,0 +1,40 @@
+-- [E157] Reference Error: ./tests/neg-custom-args/fatal-warnings/i4008.scala:6:6
+6 |class ShouldWarn1[A]
+  |      ^
+  |Invalid reference to a type variable "B" found
+  | in the user-defined error message "An implicit ShouldWarn1[${B}] is not in scope"
+  |  in the @implicitNotFound annotation argument.
+  |
+  |The variable does not occur in the signature of ShouldWarn1.
+-- [E157] Reference Error: ./tests/neg-custom-args/fatal-warnings/i4008.scala:10:6
+10 |trait ShouldWarn2[B]
+   |      ^
+   |Invalid reference to a type variable "A" found
+   | in the user-defined error message "An implicit ShouldWarn2[${A}] is not in scope"
+   |  in the @implicitNotFound annotation argument.
+   |
+   |The variable does not occur in the signature of ShouldWarn2.
+-- [E157] Reference Error: ./tests/neg-custom-args/fatal-warnings/i4008.scala:14:6
+14 |trait ShouldWarn3[B, C]
+   |      ^
+   |Invalid reference to a type variable "A" found
+   | in the user-defined error message "An implicit ShouldWarn3[${A},${B}] is not in scope"
+   |  in the @implicitNotFound annotation argument.
+   |
+   |The variable does not occur in the signature of ShouldWarn3.
+-- [E157] Reference Error: ./tests/neg-custom-args/fatal-warnings/i4008.scala:18:6
+18 |class ShouldWarn4[C, D]
+   |      ^
+   |Invalid reference to a type variable "A" found
+   | in the user-defined error message "An implicit ShouldWarn4[${A},${B}] is not in scope"
+   |  in the @implicitNotFound annotation argument.
+   |
+   |The variable does not occur in the signature of ShouldWarn4.
+-- [E157] Reference Error: ./tests/neg-custom-args/fatal-warnings/i4008.scala:22:6
+22 |class ShouldWarn5[C, D]
+   |      ^
+   |Invalid reference to a type variable "Abc" found
+   | in the user-defined error message "An implicit ShouldWarn5[${C},${Abc}] is not in scope"
+   |  in the @implicitNotFound annotation argument.
+   |
+   |The variable does not occur in the signature of ShouldWarn5.

tests/neg-custom-args/fatal-warnings/i4008.scala

@@ -0,0 +1,59 @@
+// ===== Template annotations =====
+
+
+// class, 1TP, invalid ref
+@annotation.implicitNotFound("An implicit ShouldWarn1[${B}] is not in scope")
+class ShouldWarn1[A]
+
+// trait, 1TP, invalid ref
+@annotation.implicitNotFound("An implicit ShouldWarn2[${A}] is not in scope")
+trait ShouldWarn2[B]
+
+// trait, 2TP, 1 invalid ref
+@annotation.implicitNotFound("An implicit ShouldWarn3[${A},${B}] is not in scope")
+trait ShouldWarn3[B, C]
+
+// class, 2TP, 2 invalid refs
+@annotation.implicitNotFound("An implicit ShouldWarn4[${A},${B}] is not in scope")
+class ShouldWarn4[C, D]
+
+// class, 2TP, 1 invalid multi-char refs
+@annotation.implicitNotFound("An implicit ShouldWarn5[${C},${Abc}] is not in scope")
+class ShouldWarn5[C, D]
+
+// trait, 1TP, valid ref
+@annotation.implicitNotFound("An implicit ShouldntWarn1[${A}] is not in scope")
+trait ShouldntWarn1[A]
+
+// class, 2TP, only one ref but that one is valid
+@annotation.implicitNotFound("An implicit ShouldntWarn2[${A}, ...] is not in scope")
+class ShouldntWarn2[A, B]
+
+// trait, 2TP, 2 valid refs
+@annotation.implicitNotFound("An implicit ShouldntWarn3[${A}, ${B}] is not in scope")
+trait ShouldntWarn3[A, B]
+
+// class, 2TP, 2 valid refs
+@annotation.implicitNotFound("An implicit ShouldntWarn4[${Hello},${World}] is not in scope")
+class ShouldntWarn4[Hello, World]
+
+
+// ===== DefDef param annotations =====
+
+
+@annotation.implicitNotFound("Hopefully you don't see this!")
+class C[A]
+
+object x {
+  def someMethod[A](using @annotation.implicitNotFound("No C[${A}] found") sc: C[A]) = ???
+}
+
+
+// ===== use site =====
+
+
+@main def run = {
+  // println(implicitly[C[String]])
+  println("Hai")
+  // someMethod
+}