Intrinsify StringContext.f

Ported the current macro implementation

Author: nicolasstucki

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -553,6 +553,9 @@ class Definitions {
     @tu lazy val Seq_length       : Symbol = SeqClass.requiredMethod(nme.length)
     @tu lazy val Seq_toSeq        : Symbol = SeqClass.requiredMethod(nme.toSeq)
 
+  @tu lazy val StringOps: Symbol = requiredClass("scala.collection.StringOps")
+    @tu lazy val StringOps_format: Symbol  = StringOps.requiredMethod(nme.format)
+
   @tu lazy val ArrayType: TypeRef = requiredClassRef("scala.Array")
   def ArrayClass(using Context): ClassSymbol = ArrayType.symbol.asClass
     @tu lazy val Array_apply     : Symbol = ArrayClass.requiredMethod(nme.apply)
@@ -733,9 +736,6 @@ class Definitions {
     @tu lazy val StringContextModule_standardInterpolator: Symbol = StringContextModule.requiredMethod(nme.standardInterpolator)
     @tu lazy val StringContextModule_processEscapes: Symbol = StringContextModule.requiredMethod(nme.processEscapes)
 
-  @tu lazy val InternalStringContextMacroModule: Symbol = requiredModule("dotty.internal.StringContextMacro")
-    @tu lazy val InternalStringContextMacroModule_f: Symbol = InternalStringContextMacroModule.requiredMethod(nme.f)
-
   @tu lazy val PartialFunctionClass: ClassSymbol = requiredClass("scala.PartialFunction")
     @tu lazy val PartialFunction_isDefinedAt: Symbol = PartialFunctionClass.requiredMethod(nme.isDefinedAt)
     @tu lazy val PartialFunction_applyOrElse: Symbol = PartialFunctionClass.requiredMethod(nme.applyOrElse)

compiler/src/dotty/tools/dotc/core/StdNames.scala

@@ -477,6 +477,7 @@ object StdNames {
     val flagsFromBits : N       = "flagsFromBits"
     val flatMap: N              = "flatMap"
     val foreach: N              = "foreach"
+    val format: N               = "format"
     val fromDigits: N           = "fromDigits"
     val fromProduct: N          = "fromProduct"
     val genericArrayOps: N      = "genericArrayOps"

library/src-bootstrapped/dotty/internal/StringContextMacro.scala renamed to compiler/src/dotty/tools/dotc/transform/localopt/StringContextChecker.scala

@@ -1,13 +1,20 @@
-// ALWAYS KEEP THIS FILE IN src-bootstrapped, DO NOT MOVE TO src
-
-package dotty.internal
-
-import scala.quoted._
-
-object StringContextMacro {
-
-  /** Implementation of scala.StringContext.f used in Dotty */
-  inline def f(inline sc: StringContext)(inline args: Any*): String = ${ interpolate('sc, 'args) }
+package dotty.tools.dotc
+package transform.localopt
+
+import dotty.tools.dotc.ast.Trees._
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Decorators._
+import dotty.tools.dotc.core.Constants.Constant
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.StdNames._
+import dotty.tools.dotc.core.NameKinds._
+import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.core.Types._
+
+// Ported from old dotty.internal.StringContextMacro
+// TODO: port Scala 2 logic? (see https://github.com/scala/scala/blob/2.13.x/src/compiler/scala/tools/reflect/FormatInterpolator.scala#L74)
+object StringContextChecker {
+  import tpd._
 
   /** This trait defines a tool to report errors/warnings that do not depend on Position. */
   trait Reporter {
@@ -51,53 +58,52 @@ object StringContextMacro {
     def restoreReported() : Unit
   }
 
-  /** Interpolates the arguments to the formatting String given inside a StringContext
-   *
-   *  @param strCtxExpr the Expr that holds the StringContext which contains all the chunks of the formatting string
-   *  @param args the Expr that holds the sequence of arguments to interpolate to the String in the correct format
-   *  @return the Expr containing the formatted and interpolated String or an error/warning if the parameters are not correct
-   */
-  private def interpolate(strCtxExpr: Expr[StringContext], argsExpr: Expr[Seq[Any]])(using qctx: QuoteContext): Expr[String] = {
-    import qctx.tasty._
-    val sourceFile = strCtxExpr.unseal.pos.sourceFile
-
-    val (partsExpr, parts) = strCtxExpr match {
-      case Expr.StringContext(p1 as Consts(p2)) => (p1.toList, p2.toList)
-      case _ => report.throwError("Expected statically known String Context", strCtxExpr)
+  /** Check the format of the parts of the f".." arguments and returns the string parts of the StringContext */
+  def checkedParts(strContext_f: Tree, args0: Tree)(using Context): String = {
+
+    val (partsExpr, parts) = strContext_f match {
+      case TypeApply(Select(Apply(_, (parts: SeqLiteral) :: Nil), _), _) =>
+        (parts.elems, parts.elems.map { case Literal(Constant(str: String)) => str } )
+      case _ =>
+        report.error("Expected statically known String Context", strContext_f.srcPos)
+        return ""
     }
 
-    val args = argsExpr match {
-      case Varargs(args) => args
-      case _ => report.throwError("Expected statically known argument list", argsExpr)
+    val args = args0 match {
+      case args: SeqLiteral => args.elems
+      case _ =>
+        report.error("Expected statically known argument list", args0.srcPos)
+        return ""
     }
 
     val reporter = new Reporter{
       private[this] var reported = false
       private[this] var oldReported = false
       def partError(message : String, index : Int, offset : Int) : Unit = {
         reported = true
-        val positionStart = partsExpr(index).unseal.pos.start + offset
-        error(message, sourceFile, positionStart, positionStart)
+        val pos = partsExpr(index).sourcePos
+        val posOffset = pos.withSpan(pos.span.shift(offset))
+        report.error(message, posOffset)
       }
       def partWarning(message : String, index : Int, offset : Int) : Unit = {
         reported = true
-        val positionStart = partsExpr(index).unseal.pos.start + offset
-        warning(message, sourceFile, positionStart, positionStart)
+        val pos = partsExpr(index).sourcePos
+        val posOffset = pos.withSpan(pos.span.shift(offset))
+        report.warning(message, posOffset)
       }
 
       def argError(message : String, index : Int) : Unit = {
         reported = true
-        error(message, args(index).unseal.pos)
+        report.error(message, args(index).srcPos)
       }
 
       def strCtxError(message : String) : Unit = {
         reported = true
-        val positionStart = strCtxExpr.unseal.pos.start
-        error(message, sourceFile, positionStart, positionStart)
+        report.error(message, strContext_f.srcPos)
       }
       def argsError(message : String) : Unit = {
         reported = true
-        error(message, argsExpr.unseal.pos)
+        report.error(message, args0.srcPos)
       }
 
       def hasReported() : Boolean = {
@@ -114,18 +120,11 @@ object StringContextMacro {
       }
     }
 
-    interpolate(parts, args, argsExpr, reporter)
+    checked(parts, args, reporter)
   }
 
-  /** Helper function for the interpolate function above
-   *
-   *  @param partsExpr the list of parts enumerated as Expr
-   *  @param args the list of arguments enumerated as Expr
-   *  @param reporter the reporter to return any error/warning when a problem is encountered
-   *  @return the Expr containing the formatted and interpolated String or an error/warning report if the parameters are not correct
-   */
-  def interpolate(parts0 : List[String], args : Seq[Expr[Any]], argsExpr: Expr[Seq[Any]], reporter : Reporter)(using qctx: QuoteContext) : Expr[String] = {
-    import qctx.tasty._
+  def checked(parts0: List[String], args: List[Tree], reporter: Reporter)(using Context): String = {
+
 
     /** Checks if the number of arguments are the same as the number of formatting strings
      *
@@ -585,21 +584,21 @@ object StringContextMacro {
      *  nothing otherwise
      */
     def checkTypeWithArgs(argument : (Type, Int), conversionChar : Char, partIndex : Int, flags : List[(Char, Int)]) = {
-      val booleans = List(Type.of[Boolean], Type.of[Null])
-      val dates = List(Type.of[Long], Type.of[java.util.Calendar], Type.of[java.util.Date])
-      val floatingPoints = List(Type.of[Double], Type.of[Float], Type.of[java.math.BigDecimal])
-      val integral = List(Type.of[Int], Type.of[Long], Type.of[Short], Type.of[Byte], Type.of[java.math.BigInteger])
-      val character = List(Type.of[Char], Type.of[Byte], Type.of[Short], Type.of[Int])
+      val booleans = List(defn.BooleanType, defn.NullType)
+      val dates = List(defn.LongType, requiredClass("java.util.Calendar").typeRef, requiredClass("java.util.Date").typeRef)
+      val floatingPoints = List(defn.DoubleType, defn.FloatType, requiredClass("java.math.BigDecimal").typeRef)
+      val integral = List(defn.IntType, defn.LongType, defn.ShortType, defn.ByteType, requiredClass("java.math.BigInteger").typeRef)
+      val character = List(defn.CharType, defn.ByteType, defn.ShortType, defn.IntType)
 
       val (argType, argIndex) = argument
       conversionChar match {
         case 'c' | 'C' => checkSubtype(argType, "Char", argIndex, character : _*)
         case 'd' | 'o' | 'x' | 'X' => {
           checkSubtype(argType, "Int", argIndex, integral : _*)
           if (conversionChar != 'd') {
-            val notAllowedFlagOnCondition = List(('+', !(argType <:< Type.of[java.math.BigInteger]), "only use '+' for BigInt conversions to o, x, X"),
-            (' ', !(argType <:< Type.of[java.math.BigInteger]), "only use ' ' for BigInt conversions to o, x, X"),
-            ('(', !(argType <:< Type.of[java.math.BigInteger]), "only use '(' for BigInt conversions to o, x, X"),
+            val notAllowedFlagOnCondition = List(('+', !(argType <:< requiredClass("java.math.BigInteger").typeRef), "only use '+' for BigInt conversions to o, x, X"),
+            (' ', !(argType <:< requiredClass("java.math.BigInteger").typeRef), "only use ' ' for BigInt conversions to o, x, X"),
+            ('(', !(argType <:< requiredClass("java.math.BigInteger").typeRef), "only use '(' for BigInt conversions to o, x, X"),
             (',', true, "',' only allowed for d conversion of integral types"))
             checkFlags(partIndex, flags, notAllowedFlagOnCondition : _*)
           }
@@ -608,7 +607,7 @@ object StringContextMacro {
         case 't' | 'T' => checkSubtype(argType, "Date", argIndex, dates : _*)
         case 'b' | 'B' => checkSubtype(argType, "Boolean", argIndex, booleans : _*)
         case 'h' | 'H' | 'S' | 's' =>
-          if (!(argType <:< Type.of[java.util.Formattable]))
+          if !(argType <:< requiredClass("java.util.Formattable").typeRef) then
             for {flag <- flags ; if (flag._1 == '#')}
               reporter.argError("type mismatch;\n found   : " + argType.widen.show.stripPrefix("scala.Predef.").stripPrefix("java.lang.").stripPrefix("scala.") + "\n required: java.util.Formattable", argIndex)
         case 'n' | '%' =>
@@ -647,7 +646,7 @@ object StringContextMacro {
      *  @param maxArgumentIndex an Option containing the maximum argument index possible, None if no args are specified
      *  @return a list with all the elements of the conversion per formatting string
      */
-    def checkPart(part : String, start : Int, argument : Option[(Int, Expr[Any])], maxArgumentIndex : Option[Int]) : List[(Option[(Type, Int)], Char, List[(Char, Int)])] = {
+    def checkPart(part : String, start : Int, argument : Option[(Int, Tree)], maxArgumentIndex : Option[Int]) : List[(Option[(Type, Int)], Char, List[(Char, Int)])] = {
       reporter.resetReported()
       val hasFormattingSubstring = getFormattingSubstring(part, part.size, start)
       if (hasFormattingSubstring.nonEmpty) {
@@ -658,7 +657,7 @@ object StringContextMacro {
           case Some(argIndex, arg) => {
             val (hasArgumentIndex, argumentIndex, flags, hasWidth, width, hasPrecision, precision, hasRelative, relativeIndex, conversion) = getFormatSpecifiers(part, argIndex, argIndex + 1, false, formattingStart)
             if (!reporter.hasReported()){
-              val conversionWithType = checkFormatSpecifiers(argIndex + 1, hasArgumentIndex, argumentIndex, Some(argIndex + 1), start == 0, maxArgumentIndex, hasRelative, hasWidth, width, hasPrecision, precision, flags, conversion, Some(arg.unseal.tpe), part)
+              val conversionWithType = checkFormatSpecifiers(argIndex + 1, hasArgumentIndex, argumentIndex, Some(argIndex + 1), start == 0, maxArgumentIndex, hasRelative, hasWidth, width, hasPrecision, precision, flags, conversion, Some(arg.tpe), part)
               nextStart = conversion + 1
               conversionWithType :: checkPart(part, nextStart, argument, maxArgumentIndex)
             } else checkPart(part, conversion + 1, argument, maxArgumentIndex)
@@ -710,7 +709,6 @@ object StringContextMacro {
       }
     }
 
-    // macro expansion
-    '{(${Expr(parts.mkString)}).format(${argsExpr}: _*)}
+    parts.mkString
   }
 }

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

@@ -7,8 +7,9 @@ import dotty.tools.dotc.core.Decorators._
 import dotty.tools.dotc.core.Constants.Constant
 import dotty.tools.dotc.core.Contexts._
 import dotty.tools.dotc.core.StdNames._
+import dotty.tools.dotc.core.NameKinds._
 import dotty.tools.dotc.core.Symbols._
-import dotty.tools.dotc.core.Types.MethodType
+import dotty.tools.dotc.core.Types._
 import dotty.tools.dotc.transform.MegaPhase.MiniPhase
 
 /**
@@ -116,6 +117,7 @@ class StringInterpolatorOpt extends MiniPhase {
     val sym = tree.symbol
     val isInterpolatedMethod = // Test names first to avoid loading scala.StringContext if not used
       (sym.name == nme.raw_ && sym.eq(defn.StringContext_raw)) ||
+      (sym.name == nme.f && sym.eq(defn.StringContext_f)) ||
       (sym.name == nme.s && sym.eq(defn.StringContext_s))
     if (isInterpolatedMethod)
       tree match {
@@ -132,6 +134,11 @@ class StringInterpolatorOpt extends MiniPhase {
             if (!str.const.stringValue.isEmpty) concat(str)
           }
           result
+        case Apply(intp, args :: Nil) if sym.eq(defn.StringContext_f) =>
+          val partsStr = StringContextChecker.checkedParts(intp, args).mkString
+          resolveConstructor(defn.StringOps.typeRef, List(Literal(Constant(partsStr))))
+            .select(nme.format)
+            .appliedTo(args)
         // Starting with Scala 2.13, s and raw are macros in the standard
         // library, so we need to expand them manually.
         // sc.s(args)    -->   standardInterpolator(processEscapes, args, sc.parts)

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

@@ -3257,21 +3257,10 @@ class Typer extends Namer
         if ((inlined ne tree) && errorCount == ctx.reporter.errorCount) readaptSimplified(inlined)
         else inlined
       }
-      else if tree.symbol.name == nme.f && tree.symbol == defn.StringContext_f then
-        // To avoid forcing StringContext_f when compiling StingContex
-        // we test the name before accession symbol StringContext_f.
-
-        // As scala.StringContext.f is defined in the standard library which
-        // we currently do not bootstrap we cannot implement the macro in the library.
-        // To overcome the current limitation we intercept the call and rewrite it into
-        // a call to dotty.internal.StringContext.f which we can implement using the new macros.
-        // As the macro is implemented in the bootstrapped library, it can only be used from the bootstrapped compiler.
-        val Apply(TypeApply(Select(sc, _), _), args) = tree
-        val newCall = ref(defn.InternalStringContextMacroModule_f).appliedTo(sc).appliedToArgs(args).withSpan(tree.span)
-        readaptSimplified(Inliner.inlineCall(newCall))
       else if (tree.symbol.isScala2Macro &&
-               // raw and s are eliminated by the StringInterpolatorOpt phase
+               // `raw`, `f` and `s` are eliminated by the StringInterpolatorOpt phase
               tree.symbol != defn.StringContext_raw &&
+              tree.symbol != defn.StringContext_f &&
               tree.symbol != defn.StringContext_s)
         if (ctx.settings.XignoreScala2Macros.value) {
           report.warning("Scala 2 macro cannot be used in Dotty, this call will crash at runtime. See https://dotty.epfl.ch/docs/reference/dropped-features/macros.html", tree.srcPos.startPos)

library/src-non-bootstrapped/dotty/internal/StringContextMacro.scala

@@ -0,0 +1,83 @@
+object Test {
+
+  def numberArgumentsTests(s : String, d : Int) = {
+    new StringContext().f() // error
+    new StringContext("", " is ", "%2d years old").f(s) // error
+    new StringContext("", " is ", "%2d years old").f(s, d, d) // error
+    new StringContext("", "").f() // error
+  }
+
+  def interpolationMismatches(s : String, f : Double, b : Boolean) = {
+    f"$s%b" // error
+    f"$s%c" // error
+    f"$f%c" // error
+    f"$s%x" // error
+    f"$b%d" // error
+    f"$s%d" // error
+    f"$f%o" // error
+    f"$s%e" // error
+    f"$b%f" // error
+    f"$s%i" // error
+  }
+
+  def flagMismatches(s : String, c : Char, d : Int, f : Double, t : java.util.Date) = {
+    f"$s%+ 0,(s" // error
+    f"$c%#+ 0,(c" // error
+    f"$d%#d" // error
+    f"$d%,x" // error
+    f"$d%+ (x" // error
+    f"$f%,(a" // error
+    f"$t%#+ 0,(tT" // error
+    f"%-#+ 0,(n" // error
+    f"%#+ 0,(%" // error
+  }
+
+  def badPrecisions(c : Char, d : Int, f : Double, t : java.util.Date) = {
+    f"$c%.2c" // error
+    f"$d%.2d" // error
+    f"%.2%" // error
+    f"%.2n" // error
+    f"$f%.2a" // error
+    f"$t%.2tT" // error
+  }
+
+  def badIndexes() = {
+    f"%<s" // error
+    f"%<c" // error
+    f"%<tT" // error
+    f"${8}%d ${9}%d %3$$d" // error
+    f"${8}%d ${9}%d%0$$d" // error
+  }
+
+  def warnings(s : String) = {
+    f"${8}%d ${9}%1$$d"
+    f"$s%s $s%s %1$$<s"
+    f"$s%s $s%1$$s"
+  }
+
+  def badArgTypes(s : String) = {
+    f"$s%#s" // error
+  }
+
+  def misunderstoodConversions(t : java.util.Date, s : String) = {
+    f"$t%tG" // error
+    f"$t%t" // error
+    f"$s%10.5" // error
+  }
+
+  def otherBrainFailures(d : Int) = {
+    f"${d}random-leading-junk%d" // error
+    f"%1$$n"
+    f"%1$$d" // error
+    f"blablablabla %% %.2d" // error
+    f"blablablabla %.2b %%" // error
+
+    f"ana${3}%.2f%2${true}%bb" // error
+    f"ac{2c{2{c.ca "
+
+    f"b%c.%2ii%iin" // error
+    f"b}22%2.c<{%{"  // error
+    f"%%bci.2${'i'}%..2c2" // error
+  }
+
+}