Fix #4986: Support implicitNotFound on parameters

Also fixes some complex cases of resolving type variables in `implicitNotFound` message for annotations put on type definitions

Author: prolativ

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

@@ -2425,8 +2425,8 @@ import ast.tpd
 
   class InvalidReferenceInImplicitNotFoundAnnotation(typeVar: String, owner: String)(using Context)
     extends ReferenceMsg(InvalidReferenceInImplicitNotFoundAnnotationID) {
-    def msg = em"""|Invalid reference to a type variable "${hl(typeVar)}" found in the annotation argument.
-                   |The variable does not occur in the signature of ${hl(owner)}.
+    def msg = em"""|Invalid reference to a type variable ${hl(typeVar)} found in the annotation argument.
+                   |The variable does not occur as a parameter in the scope of ${hl(owner)}.
                    |""".stripMargin
     def explain = ""
   }

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

@@ -12,6 +12,8 @@ import config.Feature
 import java.util.regex.Matcher.quoteReplacement
 import reporting._
 
+import scala.util.matching.Regex
+
 object ErrorReporting {
 
   import tpd._
@@ -133,11 +135,13 @@ object ErrorReporting {
      */
     def userDefinedErrorString(raw: String, paramNames: List[String], args: List[Type]): String = {
       def translate(name: String): Option[String] = {
-        assert(paramNames.length == args.length)
         val idx = paramNames.indexOf(name)
-        if (idx >= 0) Some(quoteReplacement(ex"${args(idx)}")) else None
+        if (idx >= 0) Some(ex"${args(idx)}") else None
       }
-      """\$\{\w*\}""".r.replaceSomeIn(raw, m => translate(m.matched.drop(2).init))
+
+      """\$\{\s*([^}\s]+)\s*\}""".r.replaceAllIn(raw, (_: Regex.Match) match {
+        case Regex.Groups(v) => quoteReplacement(translate(v).getOrElse(""))
+      })
     }
 
     def rewriteNotice: String =

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

@@ -812,9 +812,14 @@ trait Implicits:
     arg
   }
 
-  def missingArgMsg(arg: Tree, pt: Type, where: String)(using Context): String = {
+  private def typeVariablesInScope(sym: Symbol)(using Context): List[Symbol] =
+    sym.ownersIterator.flatMap{ ownerSym =>
+      ownerSym.typeParams ++ ownerSym.paramSymss.flatten.filter(_.isType)
+    }.toList
 
-    def msg(shortForm: String)(headline: String = shortForm) = arg match {
+  def missingArgMsg(arg: Tree, pt: Type, where: String, paramSymWithMethodTree: Option[(Symbol, Tree)] = None)(using Context): String = {
+
+    def formatMsg(shortForm: String)(headline: String = shortForm) = arg match {
       case arg: Trees.SearchFailureIdent[?] =>
         shortForm
       case _ =>
@@ -886,17 +891,11 @@ trait Implicits:
           case (_, alt @ AmbiguousImplicitMsg(msg)) =>
             userDefinedAmbiguousImplicitMsg(alt, msg)
           case _ =>
-            msg(s"ambiguous implicit arguments: ${ambi.explanation}${location("of")}")(
+            formatMsg(s"ambiguous implicit arguments: ${ambi.explanation}${location("of")}")(
                 s"ambiguous implicit arguments of type ${pt.show} found${location("for")}")
         }
 
       case _ =>
-        val userDefined = userDefinedMsg(pt.typeSymbol, defn.ImplicitNotFoundAnnot).map(raw =>
-          err.userDefinedErrorString(
-            raw,
-            pt.typeSymbol.typeParams.map(_.name.unexpandedName.toString),
-            pt.widenExpr.dropDependentRefinement.argInfos))
-
         def hiddenImplicitsAddendum: String =
 
           def hiddenImplicitNote(s: SearchSuccess) =
@@ -928,9 +927,56 @@ trait Implicits:
           if normalImports.isEmpty then suggestedImports else normalImports
         end hiddenImplicitsAddendum
 
-        msg(userDefined.getOrElse(
-          em"no implicit argument of type $pt was found${location("for")}"))() ++
-        hiddenImplicitsAddendum
+        val userDefinedParamMessage = paramSymWithMethodTree.flatMap{ (sym, tree) =>
+          userDefinedMsg(sym, defn.ImplicitNotFoundAnnot).map{ rawMsg =>
+            val paramSyms = typeVariablesInScope(sym)
+            val paramTypeRefs = paramSyms.map(_.typeRef.typeConstructor)
+
+            val argTypes = tree match {
+              case TypeApply(Select(qual, _), targs) =>
+                val methodOwnerType = qual.tpe
+                val methodOwner = tree.symbol.owner
+                val methodTypeParams = tree.symbol.paramSymss.flatten.filter(_.isType)
+                val methodTypeArgs = targs.map(_.tpe)
+                paramTypeRefs.map(_.asSeenFrom(methodOwnerType, methodOwner).subst(methodTypeParams, methodTypeArgs))
+              case _ => paramTypeRefs
+            }
+
+            err.userDefinedErrorString(
+              rawMsg,
+              paramSyms.map(_.name.unexpandedName.toString),
+              argTypes
+            )
+          }
+        }
+
+        val userDefinedTypeMessage = userDefinedMsg(pt.typeSymbol, defn.ImplicitNotFoundAnnot).map{ rawMsg =>
+          def extractTypeParams(tpe: Type): List[(String, Type)] =
+            tpe match {
+              case ap @ AppliedType(tycon, _) =>
+                val paramsNames = ap.typeSymbol.typeParams.map(_.name.unexpandedName.toString)
+                val paramsValues = ap.widenExpr.dropDependentRefinement.argInfos
+                paramsNames.zip(paramsValues) ++ extractTypeParams(tycon)
+              case RefinedType(parent, _, refinedInfo) => extractTypeParams(parent)
+              case TypeRef(prefix, _) => extractTypeParams(prefix)
+              case AnnotatedType(parent, _) => extractTypeParams(parent)
+              case _ => List.empty
+            }
+
+          val (paramsNames, paramsValues) = extractTypeParams(pt).unzip
+
+          err.userDefinedErrorString(
+            rawMsg,
+            paramsNames,
+            paramsValues
+          )
+        }
+
+        val shortMessage = userDefinedParamMessage.orElse(userDefinedTypeMessage).getOrElse(
+          em"no implicit argument of type $pt was found${location("for")}"
+        )
+
+        formatMsg(shortMessage)() ++ hiddenImplicitsAddendum
     }
   }
 

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

@@ -23,7 +23,7 @@ import scala.util.matching.Regex._
 import Constants.Constant
 
 object RefChecks {
-  import tpd.{Tree, MemberDef, Literal, Template, DefDef}
+  import tpd.{Tree, MemberDef, NamedArg, Literal, Template, DefDef}
 
   val name: String = "refchecks"
 
@@ -943,46 +943,58 @@ object RefChecks {
    *  (i.e. they refer to a type variable that really occurs in the signature of the annotated symbol.)
    */
   private object checkImplicitNotFoundAnnotation:
-
     /** Warns if the class or trait has an @implicitNotFound annotation
      *  with invalid type variable references.
      */
     def template(sd: SymDenotation)(using Context): Unit =
-      for
-        annotation <- sd.getAnnotation(defn.ImplicitNotFoundAnnot)
-        l@Literal(c: Constant) <- annotation.argument(0)
-      do forEachTypeVariableReferenceIn(c.stringValue) { case (ref, start) =>
-        if !sd.typeParams.exists(_.denot.name.show == ref) then
-          reportInvalidReferences(l, ref, start, sd)
-      }
+      val typeParamsNames = sd.ownersIterator.toSeq.flatMap(_.typeParams).map(_.denot.name.show)
+      checkReferences(sd, typeParamsNames)
 
     /** Warns if the def has parameters with an `@implicitNotFound` annotation
      *  with invalid type variable references.
      */
     def defDef(sd: SymDenotation)(using Context): Unit =
+      val typeParamsNames = sd.ownersIterator.toSeq.flatMap{ ownerSym =>
+        ownerSym.typeParams ++ ownerSym.paramSymss.flatten.filter(_.isType)
+      }.map(_.name.show)
+
       for
         paramSymss <- sd.paramSymss
         param <- paramSymss
-      do
-        for
-          annotation <- param.getAnnotation(defn.ImplicitNotFoundAnnot)
-          l@Literal(c: Constant) <- annotation.argument(0)
-        do forEachTypeVariableReferenceIn(c.stringValue) { case (ref, start) =>
-          if !sd.paramSymss.flatten.exists(_.name.show == ref) then
-            reportInvalidReferences(l, ref, start, sd)
-        }
+        if param.isTerm
+      do checkReferences(param.denot, typeParamsNames)
+
+    private object PositionedStringLiteralArgument:
+      def unapply(tree: Tree): Option[(String, Span)] = tree match {
+        case l@Literal(Constant(s: String)) => Some((s, l.span))
+        case NamedArg(_, l@Literal(Constant(s: String))) => Some((s, l.span))
+        case _ => None
+      }
+
+    private def checkReferences(sd: SymDenotation, typeParamsNames: Seq[String])(using Context): Unit =
+      for
+        annotation <- sd.getAnnotation(defn.ImplicitNotFoundAnnot)
+        PositionedStringLiteralArgument(msg, span) <- annotation.argument(0)
+      do forEachTypeVariableReferenceIn(msg) { case (ref, start) =>
+        if !typeParamsNames.contains(ref) then
+          reportInvalidReference(span, ref, start, sd)
+      }
 
-    /** Reports an invalid reference to a type variable `typeRef` that was found in `l` */
-    private def reportInvalidReferences(
-      l: Literal,
+    /** Reports an invalid reference to a type variable `typeRef` that was found in `span` */
+    private def reportInvalidReference(
+      span: Span,
       typeRef: String,
-      offsetInLiteral: Int,
+      variableOffsetinArgumentLiteral: Int,
       sd: SymDenotation
     )(using Context) =
-      val msg = InvalidReferenceInImplicitNotFoundAnnotation(
-        typeRef, if (sd.isConstructor) "the constructor" else sd.name.show)
-      val span = l.span.shift(offsetInLiteral + 1) // +1 because of 0-based index
-      val pos = ctx.source.atSpan(span.startPos)
+      val typeRefName = s"`$typeRef`"
+      val ownerName =
+        if sd.isType then s"type `${sd.name.show}`"
+        else if sd.owner.isConstructor then s"the constructor of `${sd.owner.owner.name.show}`"
+        else s"method `${sd.owner.name.show}`"
+      val msg = InvalidReferenceInImplicitNotFoundAnnotation(typeRefName, ownerName)
+      val startPos = span.shift(variableOffsetinArgumentLiteral + 1).startPos // +1 because of 0-based index
+      val pos = ctx.source.atSpan(startPos)
       report.warning(msg, pos)
 
     /** Calls the supplied function for each quoted reference to a type variable in <pre>s</pre>.
@@ -999,10 +1011,15 @@ object RefChecks {
      * @param f A function to apply to every pair of (\<type variable>, \<position in string>).
      */
     private def forEachTypeVariableReferenceIn(s: String)(f: (String, Int) => Unit) =
-      // matches quoted references such as "${(A)}", "${(Abc)}", etc.
-      val reference = """(?<=\$\{)[a-zA-Z]+(?=\})""".r
-      val matches = reference.findAllIn(s)
-      for m <- matches do f(m, matches.start)
+      // matches quoted references such as "${A}", "${ Abc }", etc.
+      val referencePattern = """\$\{\s*([^}\s]+)\s*\}""".r
+      val matches = referencePattern.findAllIn(s)
+      for reference <- matches do
+        val referenceOffset = matches.start
+        val prefixlessReference = reference.replaceFirst("""\$\{\s*""", "")
+        val variableOffset = referenceOffset + reference.length - prefixlessReference.length
+        val variableName = prefixlessReference.replaceFirst("""\s*\}""", "")
+        f(variableName, variableOffset)
 
   end checkImplicitNotFoundAnnotation
 

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

@@ -2003,6 +2003,13 @@ class Typer extends Namer
       checkThisConstrCall(rhs1)
     }
 
+    if sym.is(Method) && sym.owner.denot.isRefinementClass then
+      for annot <- sym.paramSymss.flatten.filter(_.isTerm).flatMap(_.getAnnotation(defn.ImplicitNotFoundAnnot)) do
+        report.warning(
+          i"The annotation ${defn.ImplicitNotFoundAnnot} is not allowed on parameters of methods defined inside a refinement and it will have no effect",
+          annot.tree.sourcePos
+        )
+
     val ddef2 = assignType(cpy.DefDef(ddef)(name, tparams1, vparamss1, tpt1, rhs1), sym)
 
     checkSignatureRepeatedParam(sym)
@@ -3108,12 +3115,17 @@ class Typer extends Namer
         val propFail = propagatedFailure(args)
 
         def issueErrors(): Tree = {
+          lazy val paramSyms = tree.symbol.paramSymss.flatten.map(sym => sym.name -> sym).toMap
+
           wtp.paramNames.lazyZip(wtp.paramInfos).lazyZip(args).foreach { (paramName, formal, arg) =>
             arg.tpe match {
               case failure: SearchFailureType =>
+                val paramSymWithMethodTree = if tree.symbol.exists then Some((paramSyms(paramName), tree)) else None
+
                 report.error(
-                  missingArgMsg(arg, formal, implicitParamString(paramName, methodStr, tree)),
-                  tree.srcPos.endPos)
+                  missingArgMsg(arg, formal, implicitParamString(paramName, methodStr, tree), paramSymWithMethodTree),
+                  tree.srcPos.endPos
+                )
               case _ =>
             }
           }

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

@@ -1,40 +1,40 @@
 -- [E158] Reference Error: tests/neg-custom-args/fatal-warnings/i4008.scala:5:56 ---------------------------------------
 5 |@annotation.implicitNotFound("An implicit ShouldWarn1[${B}] is not in scope") // error
   |                                                        ^
-  |                                        Invalid reference to a type variable "B" found in the annotation argument.
-  |                                        The variable does not occur in the signature of ShouldWarn1.
+  |                                    Invalid reference to a type variable `B` found in the annotation argument.
+  |                                    The variable does not occur as a parameter in the scope of type `ShouldWarn1`.
 -- [E158] Reference Error: tests/neg-custom-args/fatal-warnings/i4008.scala:9:56 ---------------------------------------
 9 |@annotation.implicitNotFound("An implicit ShouldWarn2[${A}] is not in scope") // error
   |                                                        ^
-  |                                        Invalid reference to a type variable "A" found in the annotation argument.
-  |                                        The variable does not occur in the signature of ShouldWarn2.
+  |                                    Invalid reference to a type variable `A` found in the annotation argument.
+  |                                    The variable does not occur as a parameter in the scope of type `ShouldWarn2`.
 -- [E158] Reference Error: tests/neg-custom-args/fatal-warnings/i4008.scala:13:56 --------------------------------------
 13 |@annotation.implicitNotFound("An implicit ShouldWarn3[${A},${B}] is not in scope") // error
    |                                                        ^
-   |                                      Invalid reference to a type variable "A" found in the annotation argument.
-   |                                      The variable does not occur in the signature of ShouldWarn3.
+   |                                  Invalid reference to a type variable `A` found in the annotation argument.
+   |                                  The variable does not occur as a parameter in the scope of type `ShouldWarn3`.
 -- [E158] Reference Error: tests/neg-custom-args/fatal-warnings/i4008.scala:17:56 --------------------------------------
 17 |@annotation.implicitNotFound("An implicit ShouldWarn4[${A},${B}] is not in scope") // error // error
    |                                                        ^
-   |                                      Invalid reference to a type variable "A" found in the annotation argument.
-   |                                      The variable does not occur in the signature of ShouldWarn4.
+   |                                  Invalid reference to a type variable `A` found in the annotation argument.
+   |                                  The variable does not occur as a parameter in the scope of type `ShouldWarn4`.
 -- [E158] Reference Error: tests/neg-custom-args/fatal-warnings/i4008.scala:17:61 --------------------------------------
 17 |@annotation.implicitNotFound("An implicit ShouldWarn4[${A},${B}] is not in scope") // error // error
    |                                                             ^
-   |                                      Invalid reference to a type variable "B" found in the annotation argument.
-   |                                      The variable does not occur in the signature of ShouldWarn4.
+   |                                  Invalid reference to a type variable `B` found in the annotation argument.
+   |                                  The variable does not occur as a parameter in the scope of type `ShouldWarn4`.
 -- [E158] Reference Error: tests/neg-custom-args/fatal-warnings/i4008.scala:21:61 --------------------------------------
 21 |@annotation.implicitNotFound("An implicit ShouldWarn5[${C},${Abc}] is not in scope") // error
    |                                                             ^
-   |                                    Invalid reference to a type variable "Abc" found in the annotation argument.
-   |                                    The variable does not occur in the signature of ShouldWarn5.
+   |                                  Invalid reference to a type variable `Abc` found in the annotation argument.
+   |                                  The variable does not occur as a parameter in the scope of type `ShouldWarn5`.
 -- [E158] Reference Error: tests/neg-custom-args/fatal-warnings/i4008.scala:44:54 --------------------------------------
 44 |class C[A](using @annotation.implicitNotFound("No C[${B}] found") c: Class[A]) // error
    |                                                      ^
-   |                                      Invalid reference to a type variable "B" found in the annotation argument.
-   |                                      The variable does not occur in the signature of the constructor.
+   |                              Invalid reference to a type variable `B` found in the annotation argument.
+   |                              The variable does not occur as a parameter in the scope of the constructor of `C`.
 -- [E158] Reference Error: tests/neg-custom-args/fatal-warnings/i4008.scala:46:62 --------------------------------------
 46 |def someMethod1[A](using @annotation.implicitNotFound("No C[${B}] found") sc: C[A]) = 0 // error
    |                                                              ^
-   |                                      Invalid reference to a type variable "B" found in the annotation argument.
-   |                                      The variable does not occur in the signature of someMethod1.
+   |                                Invalid reference to a type variable `B` found in the annotation argument.
+   |                                The variable does not occur as a parameter in the scope of method `someMethod1`.