-Wtostring-interpolated for f

Author: som-snytt

compiler/src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -167,6 +167,7 @@ private sealed trait WarningSettings:
   private val WenumCommentDiscard = BooleanSetting(WarningSetting, "Wenum-comment-discard", "Warn when a comment ambiguously assigned to multiple enum cases is discarded.")
   private val WimplausiblePatterns = BooleanSetting(WarningSetting, "Wimplausible-patterns", "Warn if comparison with a pattern value looks like it might always fail.")
   private val WunstableInlineAccessors = BooleanSetting(WarningSetting, "WunstableInlineAccessors", "Warn an inline methods has references to non-stable binary APIs.")
+  private val WtoStringInterpolated = BooleanSetting(WarningSetting, "Wtostring-interpolated", "Warn a standard interpolator used toString on a reference type.")
   private val Wunused: Setting[List[ChoiceWithHelp[String]]] = MultiChoiceHelpSetting(
     WarningSetting,
     name = "Wunused",

compiler/src/dotty/tools/dotc/transform/localopt/FormatChecker.scala

@@ -64,7 +64,7 @@ class TypedFormatChecker(partsElems: List[Tree], parts: List[String], args: List
 
   /** For N part strings and N-1 args to interpolate, normalize parts and check arg types.
    *
-   *  Returns normalized part strings and args, where args correcpond to conversions in tail of parts.
+   *  Returns normalized part strings and args, where args correspond to conversions in tail of parts.
    */
   def checked: (List[String], List[Tree]) =
     val amended = ListBuffer.empty[String]
@@ -83,12 +83,15 @@ class TypedFormatChecker(partsElems: List[Tree], parts: List[String], args: List
             val cv = Conversion(n)
             cv.accepts(argType(n-1, defn.AnyType))
             convert += cv
+            cv.lintToString(argTypes(n-1))
+
           def errorLeading(op: Conversion) = op.errorAt(Spec)(s"conversions must follow a splice; ${Conversion.literalHelp}")
           def accept(op: Conversion): Unit =
             if !op.isLeading then errorLeading(op)
             op.accepts(argType(n-1, op.acceptableVariants*))
             amended += part
             convert += op
+            op.lintToString(argTypes(n-1))
 
           // after the first part, a leading specifier is required for the interpolated arg; %s is supplied if needed
           if n == 0 then amended += part
@@ -217,6 +220,10 @@ class TypedFormatChecker(partsElems: List[Tree], parts: List[String], args: List
         }
         case _ => true
 
+    def lintToString(arg: Type): Unit =
+      if ctx.settings.WtoStringInterpolated.value && kind == StringXn && !(arg =:= defn.StringType) && !isPrimitiveValueType(arg)
+      then warningAt(CC)("interpolation uses toString")
+
     // what arg type if any does the conversion accept
     def acceptableVariants: List[Type] =
       kind match