Handle s and raw interpolator with 2.13 stdlib

These methods are now macros, so we always need to expand them.

Author: smarter

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

@@ -347,6 +347,7 @@ class Definitions {
   @tu lazy val ScalaPredefModule: Symbol = ctx.requiredModule("scala.Predef")
     @tu lazy val Predef_conforms : Symbol = ScalaPredefModule.requiredMethod(nme.conforms_)
     @tu lazy val Predef_classOf  : Symbol = ScalaPredefModule.requiredMethod(nme.classOf)
+    @tu lazy val Predef_identity : Symbol = ScalaPredefModule.requiredMethod(nme.identity)
     @tu lazy val Predef_undefined: Symbol = ScalaPredefModule.requiredMethod(nme.???)
 
   def SubTypeClass(implicit ctx: Context): ClassSymbol = ctx.requiredClass("scala.<:<")
@@ -564,11 +565,14 @@ class Definitions {
     @tu lazy val StringAdd_+ : Symbol = StringAddClass.requiredMethod(nme.raw.PLUS)
 
   @tu lazy val StringContextClass: ClassSymbol = ctx.requiredClass("scala.StringContext")
-    @tu lazy val StringContextS  : Symbol = StringContextClass.requiredMethod(nme.s)
-    @tu lazy val StringContextRaw: Symbol = StringContextClass.requiredMethod(nme.raw_)
-    @tu lazy val StringContext_f : Symbol = StringContextClass.requiredMethod(nme.f)
+    @tu lazy val StringContext_s  : Symbol = StringContextClass.requiredMethod(nme.s)
+    @tu lazy val StringContext_raw: Symbol = StringContextClass.requiredMethod(nme.raw_)
+    @tu lazy val StringContext_f  : Symbol = StringContextClass.requiredMethod(nme.f)
+    @tu lazy val StringContext_parts: Symbol = StringContextClass.requiredMethod(nme.parts)
   @tu lazy val StringContextModule: Symbol = StringContextClass.companionModule
     @tu lazy val StringContextModule_apply: Symbol = StringContextModule.requiredMethod(nme.apply)
+    @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 = ctx.requiredModule("dotty.internal.StringContextMacro")
     @tu lazy val InternalStringContextMacroModule_f: Symbol = InternalStringContextMacroModule.requiredMethod(nme.f)

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

@@ -504,7 +504,9 @@ object StdNames {
     val ordinalDollar: N        = "$ordinal"
     val ordinalDollar_ : N      = "_$ordinal"
     val origin: N               = "origin"
+    val parts: N                = "parts"
     val prefix : N              = "prefix"
+    val processEscapes: N       = "processEscapes"
     val productArity: N         = "productArity"
     val productElement: N       = "productElement"
     val productElementName: N   = "productElementName"
@@ -536,6 +538,7 @@ object StdNames {
     val setType: N              = "setType"
     val setTypeSignature: N     = "setTypeSignature"
     val splice: N               = "$splice"
+    val standardInterpolator: N = "standardInterpolator"
     val staticClass : N         = "staticClass"
     val staticModule : N        = "staticModule"
     val staticPackage : N       = "staticPackage"

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

@@ -2,10 +2,12 @@ package dotty.tools.dotc.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.Context
 import dotty.tools.dotc.core.StdNames._
 import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.core.Types.MethodType
 import dotty.tools.dotc.transform.MegaPhase.MiniPhase
 
 /**
@@ -21,6 +23,16 @@ class StringInterpolatorOpt extends MiniPhase {
 
   override def phaseName: String = "stringInterpolatorOpt"
 
+  override def checkPostCondition(tree: tpd.Tree)(implicit ctx: Context): Unit = {
+    tree match {
+      case tree: RefTree =>
+        val sym = tree.symbol
+        assert(sym != defn.StringContext_raw && sym != defn.StringContext_s,
+          i"$tree in ${ctx.owner.showLocated} should have been rewritten by phase $phaseName")
+      case _ =>
+    }
+  }
+
   /** Matches a list of constant literals */
   private object Literals {
     def unapply(tree: SeqLiteral)(implicit ctx: Context): Option[List[Literal]] = {
@@ -60,7 +72,7 @@ class StringInterpolatorOpt extends MiniPhase {
     def unapply(tree: Apply)(implicit ctx: Context): Option[(List[Literal], List[Tree])] = {
       tree match {
         case SOrRawInterpolator(strs, elems) =>
-          if (tree.symbol == defn.StringContextRaw) Some(strs, elems)
+          if (tree.symbol == defn.StringContext_raw) Some(strs, elems)
           else { // tree.symbol == defn.StringContextS
             try {
               val escapedStrs = strs.map { str =>
@@ -80,28 +92,46 @@ class StringInterpolatorOpt extends MiniPhase {
   override def transformApply(tree: Apply)(implicit ctx: Context): Tree = {
     val sym = tree.symbol
     val isInterpolatedMethod = // Test names first to avoid loading scala.StringContext if not used
-      (sym.name == nme.raw_ && sym.eq(defn.StringContextRaw)) ||
-      (sym.name == nme.s && sym.eq(defn.StringContextS))
-    if (isInterpolatedMethod) transformInterpolator(tree)
-    else tree
-  }
+      (sym.name == nme.raw_ && sym.eq(defn.StringContext_raw)) ||
+      (sym.name == nme.s && sym.eq(defn.StringContext_s))
+    if (isInterpolatedMethod)
+      tree match {
+        case StringContextIntrinsic(strs: List[Literal], elems: List[Tree]) =>
+          val stri = strs.iterator
+          val elemi = elems.iterator
+          var result: Tree = stri.next
+          def concat(tree: Tree): Unit = {
+            result = result.select(defn.String_+).appliedTo(tree)
+          }
+          while (elemi.hasNext) {
+            concat(elemi.next)
+            val str = stri.next
+            if (!str.const.stringValue.isEmpty) concat(str)
+          }
+          result
+        // 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)
+        // sc.raw(args)  -->   standardInterpolator(x => x,         args, sc.parts)
+        case Apply(intp, args :: Nil) =>
+          val pre = intp match {
+            case Select(pre, _) => pre
+            case intp: Ident => tpd.desugarIdentPrefix(intp)
+          }
+          val isRaw = sym eq defn.StringContext_raw
+          val stringToString = defn.StringContextModule_processEscapes.info.asInstanceOf[MethodType]
 
-  private def transformInterpolator(tree: Tree)(implicit ctx: Context): Tree = {
-    tree match {
-      case StringContextIntrinsic(strs: List[Literal], elems: List[Tree]) =>
-        val stri = strs.iterator
-        val elemi = elems.iterator
-        var result: Tree = stri.next
-        def concat(tree: Tree): Unit = {
-          result = result.select(defn.String_+).appliedTo(tree)
-        }
-        while (elemi.hasNext) {
-          concat(elemi.next)
-          val str = stri.next
-          if (!str.const.stringValue.isEmpty) concat(str)
-        }
-        result
-      case _ => tree
-    }
+          val process = tpd.Lambda(stringToString, args =>
+            if (isRaw) args.head else ref(defn.StringContextModule_processEscapes).appliedToArgs(args))
+
+          evalOnce(pre) { sc =>
+            val parts = sc.select(defn.StringContext_parts)
+
+            ref(defn.StringContextModule_standardInterpolator)
+              .appliedToArgs(List(process, args, parts))
+          }
+      }
+    else
+      tree
   }
 }

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

@@ -2688,7 +2688,10 @@ class Typer extends Namer
         tree.tpe <:< wildApprox(pt)
         readaptSimplified(Inliner.inlineCall(tree))
       }
-      else if (tree.symbol.isScala2Macro) {
+      else if (tree.symbol.isScala2Macro &&
+               // raw and s are eliminated by the StringInterpolatorOpt phase
+              tree.symbol != defn.StringContext_raw &&
+              tree.symbol != defn.StringContext_s) {
         if (tree.symbol eq defn.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.