Respect conversion before conform to Any

Author: som-snytt

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

@@ -30,8 +30,9 @@ class TypedFormatChecker(partsElems: List[Tree], parts: List[String], args: List
   def argType(argi: Int, types: Type*): Type =
     require(argi < argc, s"$argi out of range picking from $types")
     val tpe = argTypes(argi)
-    types.find(t => argConformsTo(argi, tpe, t))
-      .orElse(types.find(t => argConvertsTo(argi, tpe, t)))
+    types.find(t => t != defn.AnyType && argConformsTo(argi, tpe, t))
+      .orElse(types.find(t => t != defn.AnyType && argConvertsTo(argi, tpe, t)))
+      .orElse(types.find(t => t == defn.AnyType && argConformsTo(argi, tpe, t)))
       .getOrElse {
         report.argError(s"Found: ${tpe.show}, Required: ${types.map(_.show).mkString(", ")}", argi)
         actuals += args(argi)
@@ -73,15 +74,16 @@ class TypedFormatChecker(partsElems: List[Tree], parts: List[String], args: List
     @tailrec
     def loop(remaining: List[String], n: Int): Unit =
       remaining match
-        case part0 :: more =>
+        case part0 :: remaining =>
           def badPart(t: Throwable): String = "".tap(_ => report.partError(t.getMessage.nn, index = n, offset = 0))
           val part = try StringContext.processEscapes(part0) catch badPart
           val matches = formatPattern.findAllMatchIn(part)
 
           def insertStringConversion(): Unit =
             amended += "%s" + part
-            convert += Conversion(formatPattern.findAllMatchIn("%s").next(), n)  // improve
-            argType(n-1, defn.AnyType)
+            val cv = Conversion(n)
+            cv.accepts(argType(n-1, defn.AnyType))
+            convert += cv
           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)
@@ -105,8 +107,8 @@ class TypedFormatChecker(partsElems: List[Tree], parts: List[String], args: List
             if n == 0 && cv.hasFlag('<') then cv.badFlag('<', "No last arg")
             else if !cv.isLiteral && !cv.isIndexed then errorLeading(cv)
 
-          loop(more, n + 1)
-        case Nil => ()
+          loop(remaining, n + 1)
+        case Nil =>
     end loop
 
     loop(parts, n = 0)
@@ -147,9 +149,10 @@ class TypedFormatChecker(partsElems: List[Tree], parts: List[String], args: List
     // the conversion char is the head of the op string (but see DateTimeXn)
     val cc: Char =
       kind match
-        case ErrorXn => if op.isEmpty then '?' else op(0)
-        case DateTimeXn => if op.length > 1 then op(1) else '?'
-        case _ => op(0)
+        case ErrorXn    => if op.isEmpty then '?' else op(0)
+        case DateTimeXn => if op.length <= 1 then '?' else op(1)
+        case StringXn   => if op.isEmpty then 's' else op(0) // accommodate the default %s
+        case _          => op(0)
 
     def isIndexed: Boolean = index.nonEmpty || hasFlag('<')
     def isError: Boolean   = kind == ErrorXn
@@ -210,10 +213,9 @@ class TypedFormatChecker(partsElems: List[Tree], parts: List[String], args: List
     def accepts(arg: Type): Boolean =
       kind match
         case BooleanXn  => arg == defn.BooleanType orElse warningAt(CC)("Boolean format is null test for non-Boolean")
-        case IntegralXn =>
-          arg == BigIntType || !cond(cc) {
-            case 'o' | 'x' | 'X' if hasAnyFlag("+ (") => "+ (".filter(hasFlag).foreach(bad => badFlag(bad, s"only use '$bad' for BigInt conversions to o, x, X")) ; true
-          }
+        case IntegralXn => arg == BigIntType || !cond(cc) {
+          case 'o' | 'x' | 'X' if hasAnyFlag("+ (") => "+ (".filter(hasFlag).foreach(bad => badFlag(bad, s"only use '$bad' for BigInt conversions to o, x, X")); true
+        }
         case _ => true
 
     // what arg type if any does the conversion accept
@@ -268,6 +270,8 @@ class TypedFormatChecker(partsElems: List[Tree], parts: List[String], args: List
         case Some(cc) => new Conversion(m, i, kindOf(cc(0))).tap(_.verify)
         case None     => new Conversion(m, i, ErrorXn).tap(_.errorAt(Spec)(s"Missing conversion operator in '${m.matched}'; $literalHelp"))
     end apply
+    // construct a default %s conversion
+    def apply(i: Int): Conversion = new Conversion(formatPattern.findAllMatchIn("%").next(), i, StringXn)
     val literalHelp = "use %% for literal %, %n for newline"
   end Conversion