Skip to content

Commit 6c45f5c

Browse files
prolativprolativ
committed
Fix #4986: Support implicitNotFound on parameters
1 parent c900cde commit 6c45f5c

20 files changed

+310
-124
lines changed

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

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -2425,8 +2425,8 @@ import ast.tpd
24252425

24262426
class InvalidReferenceInImplicitNotFoundAnnotation(typeVar: String, owner: String)(using Context)
24272427
extends ReferenceMsg(InvalidReferenceInImplicitNotFoundAnnotationID) {
2428-
def msg = em"""|Invalid reference to a type variable "${hl(typeVar)}" found in the annotation argument.
2429-
|The variable does not occur in the signature of ${hl(owner)}.
2428+
def msg = em"""|Invalid reference to a type variable ${hl(typeVar)} found in the annotation argument.
2429+
|The variable does not occur as a parameter in the scope of ${hl(owner)}.
24302430
|""".stripMargin
24312431
def explain = ""
24322432
}

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

Lines changed: 7 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -12,6 +12,8 @@ import config.Feature
1212
import java.util.regex.Matcher.quoteReplacement
1313
import reporting._
1414

15+
import scala.util.matching.Regex
16+
1517
object ErrorReporting {
1618

1719
import tpd._
@@ -133,11 +135,13 @@ object ErrorReporting {
133135
*/
134136
def userDefinedErrorString(raw: String, paramNames: List[String], args: List[Type]): String = {
135137
def translate(name: String): Option[String] = {
136-
assert(paramNames.length == args.length)
137138
val idx = paramNames.indexOf(name)
138-
if (idx >= 0) Some(quoteReplacement(ex"${args(idx)}")) else None
139+
if (idx >= 0) Some(ex"${args(idx)}") else None
139140
}
140-
"""\$\{\w*\}""".r.replaceSomeIn(raw, m => translate(m.matched.drop(2).init))
141+
142+
"""\$\{\s*([^}\s]+)\s*\}""".r.replaceAllIn(raw, (_: Regex.Match) match {
143+
case Regex.Groups(v) => quoteReplacement(translate(v).getOrElse(""))
144+
})
141145
}
142146

143147
def rewriteNotice: String =

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

Lines changed: 58 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -812,9 +812,14 @@ trait Implicits:
812812
arg
813813
}
814814

815-
def missingArgMsg(arg: Tree, pt: Type, where: String)(using Context): String = {
815+
private def typeVariablesInScope(sym: Symbol)(using Context): List[Symbol] =
816+
sym.ownersIterator.flatMap{ ownerSym =>
817+
ownerSym.typeParams ++ ownerSym.paramSymss.flatten.filter(_.isType)
818+
}.toList
816819

817-
def msg(shortForm: String)(headline: String = shortForm) = arg match {
820+
def missingArgMsg(arg: Tree, pt: Type, where: String, paramSymWithMethodTree: Option[(Symbol, Tree)] = None)(using Context): String = {
821+
822+
def formatMsg(shortForm: String)(headline: String = shortForm) = arg match {
818823
case arg: Trees.SearchFailureIdent[?] =>
819824
shortForm
820825
case _ =>
@@ -886,17 +891,11 @@ trait Implicits:
886891
case (_, alt @ AmbiguousImplicitMsg(msg)) =>
887892
userDefinedAmbiguousImplicitMsg(alt, msg)
888893
case _ =>
889-
msg(s"ambiguous implicit arguments: ${ambi.explanation}${location("of")}")(
894+
formatMsg(s"ambiguous implicit arguments: ${ambi.explanation}${location("of")}")(
890895
s"ambiguous implicit arguments of type ${pt.show} found${location("for")}")
891896
}
892897

893898
case _ =>
894-
val userDefined = userDefinedMsg(pt.typeSymbol, defn.ImplicitNotFoundAnnot).map(raw =>
895-
err.userDefinedErrorString(
896-
raw,
897-
pt.typeSymbol.typeParams.map(_.name.unexpandedName.toString),
898-
pt.widenExpr.dropDependentRefinement.argInfos))
899-
900899
def hiddenImplicitsAddendum: String =
901900

902901
def hiddenImplicitNote(s: SearchSuccess) =
@@ -928,9 +927,56 @@ trait Implicits:
928927
if normalImports.isEmpty then suggestedImports else normalImports
929928
end hiddenImplicitsAddendum
930929

931-
msg(userDefined.getOrElse(
932-
em"no implicit argument of type $pt was found${location("for")}"))() ++
933-
hiddenImplicitsAddendum
930+
val userDefinedParamMessage = paramSymWithMethodTree.flatMap{ (sym, tree) =>
931+
userDefinedMsg(sym, defn.ImplicitNotFoundAnnot).map{ rawMsg =>
932+
val paramSyms = typeVariablesInScope(sym)
933+
val paramTypeRefs = paramSyms.map(_.typeRef.typeConstructor)
934+
935+
val argTypes = tree match {
936+
case TypeApply(Select(qual, _), targs) =>
937+
val methodOwnerType = qual.tpe
938+
val methodOwner = tree.symbol.owner
939+
val methodTypeParams = tree.symbol.paramSymss.flatten.filter(_.isType)
940+
val methodTypeArgs = targs.map(_.tpe)
941+
paramTypeRefs.map(_.asSeenFrom(methodOwnerType, methodOwner).subst(methodTypeParams, methodTypeArgs))
942+
case _ => paramTypeRefs
943+
}
944+
945+
err.userDefinedErrorString(
946+
rawMsg,
947+
paramSyms.map(_.name.unexpandedName.toString),
948+
argTypes
949+
)
950+
}
951+
}
952+
953+
val userDefinedTypeMessage = userDefinedMsg(pt.typeSymbol, defn.ImplicitNotFoundAnnot).map{ rawMsg =>
954+
def extractTypeParams(tpe: Type): List[(String, Type)] =
955+
tpe match {
956+
case ap @ AppliedType(tycon, _) =>
957+
val paramsNames = ap.typeSymbol.typeParams.map(_.name.unexpandedName.toString)
958+
val paramsValues = ap.widenExpr.dropDependentRefinement.argInfos
959+
paramsNames.zip(paramsValues) ++ extractTypeParams(tycon)
960+
case RefinedType(parent, _, refinedInfo) => extractTypeParams(parent) ++ extractTypeParams(refinedInfo)
961+
case TypeRef(prefix, _) => extractTypeParams(prefix)
962+
case AnnotatedType(parent, _) => extractTypeParams(parent)
963+
case _ => List.empty
964+
}
965+
966+
val (paramsNames, paramsValues) = extractTypeParams(pt).unzip
967+
968+
err.userDefinedErrorString(
969+
rawMsg,
970+
paramsNames,
971+
paramsValues
972+
)
973+
}
974+
975+
val shortMessage = userDefinedParamMessage.orElse(userDefinedTypeMessage).getOrElse(
976+
em"no implicit argument of type $pt was found${location("for")}"
977+
)
978+
979+
formatMsg(shortMessage)() ++ hiddenImplicitsAddendum
934980
}
935981
}
936982

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

Lines changed: 46 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -23,7 +23,7 @@ import scala.util.matching.Regex._
2323
import Constants.Constant
2424

2525
object RefChecks {
26-
import tpd.{Tree, MemberDef, Literal, Template, DefDef}
26+
import tpd.{Tree, MemberDef, NamedArg, Literal, Template, DefDef}
2727

2828
val name: String = "refchecks"
2929

@@ -943,46 +943,58 @@ object RefChecks {
943943
* (i.e. they refer to a type variable that really occurs in the signature of the annotated symbol.)
944944
*/
945945
private object checkImplicitNotFoundAnnotation:
946-
947946
/** Warns if the class or trait has an @implicitNotFound annotation
948947
* with invalid type variable references.
949948
*/
950949
def template(sd: SymDenotation)(using Context): Unit =
951-
for
952-
annotation <- sd.getAnnotation(defn.ImplicitNotFoundAnnot)
953-
l@Literal(c: Constant) <- annotation.argument(0)
954-
do forEachTypeVariableReferenceIn(c.stringValue) { case (ref, start) =>
955-
if !sd.typeParams.exists(_.denot.name.show == ref) then
956-
reportInvalidReferences(l, ref, start, sd)
957-
}
950+
val typeParamsNames = sd.ownersIterator.toSeq.flatMap(_.typeParams).map(_.denot.name.show)
951+
checkReferences(sd, typeParamsNames)
958952

959953
/** Warns if the def has parameters with an `@implicitNotFound` annotation
960954
* with invalid type variable references.
961955
*/
962956
def defDef(sd: SymDenotation)(using Context): Unit =
957+
val typeParamsNames = sd.ownersIterator.toSeq.flatMap{ ownerSym =>
958+
ownerSym.typeParams ++ ownerSym.paramSymss.flatten.filter(_.isType)
959+
}.map(_.name.show)
960+
963961
for
964962
paramSymss <- sd.paramSymss
965963
param <- paramSymss
966-
do
967-
for
968-
annotation <- param.getAnnotation(defn.ImplicitNotFoundAnnot)
969-
l@Literal(c: Constant) <- annotation.argument(0)
970-
do forEachTypeVariableReferenceIn(c.stringValue) { case (ref, start) =>
971-
if !sd.paramSymss.flatten.exists(_.name.show == ref) then
972-
reportInvalidReferences(l, ref, start, sd)
973-
}
964+
if param.isTerm
965+
do checkReferences(param.denot, typeParamsNames)
966+
967+
private object PositionedStringLiteralArgument:
968+
def unapply(tree: Tree): Option[(String, Span)] = tree match {
969+
case l@Literal(Constant(s: String)) => Some((s, l.span))
970+
case NamedArg(_, l@Literal(Constant(s: String))) => Some((s, l.span))
971+
case _ => None
972+
}
973+
974+
private def checkReferences(sd: SymDenotation, typeParamsNames: Seq[String])(using Context): Unit =
975+
for
976+
annotation <- sd.getAnnotation(defn.ImplicitNotFoundAnnot)
977+
PositionedStringLiteralArgument(msg, span) <- annotation.argument(0)
978+
do forEachTypeVariableReferenceIn(msg) { case (ref, start) =>
979+
if !typeParamsNames.contains(ref) then
980+
reportInvalidReference(span, ref, start, sd)
981+
}
974982

975-
/** Reports an invalid reference to a type variable `typeRef` that was found in `l` */
976-
private def reportInvalidReferences(
977-
l: Literal,
983+
/** Reports an invalid reference to a type variable `typeRef` that was found in `span` */
984+
private def reportInvalidReference(
985+
span: Span,
978986
typeRef: String,
979-
offsetInLiteral: Int,
987+
variableOffsetinArgumentLiteral: Int,
980988
sd: SymDenotation
981989
)(using Context) =
982-
val msg = InvalidReferenceInImplicitNotFoundAnnotation(
983-
typeRef, if (sd.isConstructor) "the constructor" else sd.name.show)
984-
val span = l.span.shift(offsetInLiteral + 1) // +1 because of 0-based index
985-
val pos = ctx.source.atSpan(span.startPos)
990+
val typeRefName = s"`$typeRef`"
991+
val ownerName =
992+
if sd.isType then s"type `${sd.name.show}`"
993+
else if sd.owner.isConstructor then s"the constructor of `${sd.owner.owner.name.show}`"
994+
else s"method `${sd.owner.name.show}`"
995+
val msg = InvalidReferenceInImplicitNotFoundAnnotation(typeRefName, ownerName)
996+
val startPos = span.shift(variableOffsetinArgumentLiteral + 1).startPos // +1 because of 0-based index
997+
val pos = ctx.source.atSpan(startPos)
986998
report.warning(msg, pos)
987999

9881000
/** Calls the supplied function for each quoted reference to a type variable in <pre>s</pre>.
@@ -999,10 +1011,15 @@ object RefChecks {
9991011
* @param f A function to apply to every pair of (\<type variable>, \<position in string>).
10001012
*/
10011013
private def forEachTypeVariableReferenceIn(s: String)(f: (String, Int) => Unit) =
1002-
// matches quoted references such as "${(A)}", "${(Abc)}", etc.
1003-
val reference = """(?<=\$\{)[a-zA-Z]+(?=\})""".r
1004-
val matches = reference.findAllIn(s)
1005-
for m <- matches do f(m, matches.start)
1014+
// matches quoted references such as "${A}", "${ Abc }", etc.
1015+
val referencePattern = """\$\{\s*([^}\s]+)\s*\}""".r
1016+
val matches = referencePattern.findAllIn(s)
1017+
for reference <- matches do
1018+
val referenceOffset = matches.start
1019+
val prefixlessReference = reference.replaceFirst("""\$\{\s*""", "")
1020+
val variableOffset = referenceOffset + reference.length - prefixlessReference.length
1021+
val variableName = prefixlessReference.replaceFirst("""\s*\}""", "")
1022+
f(variableName, variableOffset)
10061023

10071024
end checkImplicitNotFoundAnnotation
10081025

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

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -3108,11 +3108,13 @@ class Typer extends Namer
31083108
val propFail = propagatedFailure(args)
31093109

31103110
def issueErrors(): Tree = {
3111+
val paramSyms = tree.symbol.paramSymss.flatten.map(sym => sym.name -> sym).toMap
3112+
31113113
wtp.paramNames.lazyZip(wtp.paramInfos).lazyZip(args).foreach { (paramName, formal, arg) =>
31123114
arg.tpe match {
31133115
case failure: SearchFailureType =>
31143116
report.error(
3115-
missingArgMsg(arg, formal, implicitParamString(paramName, methodStr, tree)),
3117+
missingArgMsg(arg, formal, implicitParamString(paramName, methodStr, tree), Some((paramSyms(paramName), tree))),
31163118
tree.srcPos.endPos)
31173119
case _ =>
31183120
}

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

Lines changed: 16 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -1,40 +1,40 @@
11
-- [E158] Reference Error: tests/neg-custom-args/fatal-warnings/i4008.scala:5:56 ---------------------------------------
22
5 |@annotation.implicitNotFound("An implicit ShouldWarn1[${B}] is not in scope") // error
33
| ^
4-
| Invalid reference to a type variable "B" found in the annotation argument.
5-
| The variable does not occur in the signature of ShouldWarn1.
4+
| Invalid reference to a type variable `B` found in the annotation argument.
5+
| The variable does not occur as a parameter in the scope of type `ShouldWarn1`.
66
-- [E158] Reference Error: tests/neg-custom-args/fatal-warnings/i4008.scala:9:56 ---------------------------------------
77
9 |@annotation.implicitNotFound("An implicit ShouldWarn2[${A}] is not in scope") // error
88
| ^
9-
| Invalid reference to a type variable "A" found in the annotation argument.
10-
| The variable does not occur in the signature of ShouldWarn2.
9+
| Invalid reference to a type variable `A` found in the annotation argument.
10+
| The variable does not occur as a parameter in the scope of type `ShouldWarn2`.
1111
-- [E158] Reference Error: tests/neg-custom-args/fatal-warnings/i4008.scala:13:56 --------------------------------------
1212
13 |@annotation.implicitNotFound("An implicit ShouldWarn3[${A},${B}] is not in scope") // error
1313
| ^
14-
| Invalid reference to a type variable "A" found in the annotation argument.
15-
| The variable does not occur in the signature of ShouldWarn3.
14+
| Invalid reference to a type variable `A` found in the annotation argument.
15+
| The variable does not occur as a parameter in the scope of type `ShouldWarn3`.
1616
-- [E158] Reference Error: tests/neg-custom-args/fatal-warnings/i4008.scala:17:56 --------------------------------------
1717
17 |@annotation.implicitNotFound("An implicit ShouldWarn4[${A},${B}] is not in scope") // error // error
1818
| ^
19-
| Invalid reference to a type variable "A" found in the annotation argument.
20-
| The variable does not occur in the signature of ShouldWarn4.
19+
| Invalid reference to a type variable `A` found in the annotation argument.
20+
| The variable does not occur as a parameter in the scope of type `ShouldWarn4`.
2121
-- [E158] Reference Error: tests/neg-custom-args/fatal-warnings/i4008.scala:17:61 --------------------------------------
2222
17 |@annotation.implicitNotFound("An implicit ShouldWarn4[${A},${B}] is not in scope") // error // error
2323
| ^
24-
| Invalid reference to a type variable "B" found in the annotation argument.
25-
| The variable does not occur in the signature of ShouldWarn4.
24+
| Invalid reference to a type variable `B` found in the annotation argument.
25+
| The variable does not occur as a parameter in the scope of type `ShouldWarn4`.
2626
-- [E158] Reference Error: tests/neg-custom-args/fatal-warnings/i4008.scala:21:61 --------------------------------------
2727
21 |@annotation.implicitNotFound("An implicit ShouldWarn5[${C},${Abc}] is not in scope") // error
2828
| ^
29-
| Invalid reference to a type variable "Abc" found in the annotation argument.
30-
| The variable does not occur in the signature of ShouldWarn5.
29+
| Invalid reference to a type variable `Abc` found in the annotation argument.
30+
| The variable does not occur as a parameter in the scope of type `ShouldWarn5`.
3131
-- [E158] Reference Error: tests/neg-custom-args/fatal-warnings/i4008.scala:44:54 --------------------------------------
3232
44 |class C[A](using @annotation.implicitNotFound("No C[${B}] found") c: Class[A]) // error
3333
| ^
34-
| Invalid reference to a type variable "B" found in the annotation argument.
35-
| The variable does not occur in the signature of the constructor.
34+
| Invalid reference to a type variable `B` found in the annotation argument.
35+
| The variable does not occur as a parameter in the scope of the constructor of `C`.
3636
-- [E158] Reference Error: tests/neg-custom-args/fatal-warnings/i4008.scala:46:62 --------------------------------------
3737
46 |def someMethod1[A](using @annotation.implicitNotFound("No C[${B}] found") sc: C[A]) = 0 // error
3838
| ^
39-
| Invalid reference to a type variable "B" found in the annotation argument.
40-
| The variable does not occur in the signature of someMethod1.
39+
| Invalid reference to a type variable `B` found in the annotation argument.
40+
| The variable does not occur as a parameter in the scope of method `someMethod1`.

0 commit comments

Comments
 (0)