String interpolation optimization miniphase

Author: Wojtechnology

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -7,16 +7,15 @@ import Periods._
 import Symbols._
 import Types._
 import Scopes._
-import typer.{FrontEnd, Typer, ImportInfo, RefChecks}
-import reporting.{Reporter, ConsoleReporter}
+import typer.{FrontEnd, ImportInfo, RefChecks, Typer}
+import reporting.{ConsoleReporter, Reporter}
 import Phases.Phase
 import transform._
 import util.FreshNameCreator
 import core.DenotTransformers.DenotTransformer
 import core.Denotations.SingleDenotation
-
-import dotty.tools.backend.jvm.{LabelDefs, GenBCode, CollectSuperCalls}
-import dotty.tools.dotc.transform.localopt.Simplify
+import dotty.tools.backend.jvm.{CollectSuperCalls, GenBCode, LabelDefs}
+import dotty.tools.dotc.transform.localopt.{Simplify, StringInterpolatorOpt}
 
 /** The central class of the dotc compiler. The job of a compiler is to create
  *  runs, which process given `phases` in a given `rootContext`.
@@ -78,6 +77,7 @@ class Compiler {
          new ExplicitOuter,          // Add accessors to outer classes from nested ones.
          new ExplicitSelf,           // Make references to non-trivial self types explicit as casts
          new ShortcutImplicits,      // Allow implicit functions without creating closures
+         new StringInterpolatorOpt,  // Optimizes raw and s string interpolators by rewriting them to string concatentations
          new CrossCastAnd,           // Normalize selections involving intersection types.
          new Splitter) ::            // Expand selections involving union types into conditionals
     List(new PhantomArgLift,         // Extracts the evaluation of phantom arguments placing them before the call.

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

@@ -483,6 +483,7 @@ object StdNames {
     val productElement: N       = "productElement"
     val productIterator: N      = "productIterator"
     val productPrefix: N        = "productPrefix"
+    val raw_ : N                = "raw"
     val readResolve: N          = "readResolve"
     val reflect : N             = "reflect"
     val reify : N               = "reify"
@@ -492,6 +493,7 @@ object StdNames {
     val runtime: N              = "runtime"
     val runtimeClass: N         = "runtimeClass"
     val runtimeMirror: N        = "runtimeMirror"
+    val s: N                    = "s"
     val sameElements: N         = "sameElements"
     val scala_ : N              = "scala"
     val scalaShadowing : N      = "scalaShadowing"

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

@@ -0,0 +1,59 @@
+package dotty.tools.dotc.transform.localopt
+
+import dotty.tools.dotc.ast.Trees._
+import dotty.tools.dotc.ast.tpd
+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.transform.MegaPhase.MiniPhase
+
+/**
+  * Created by wojtekswiderski on 2018-01-24.
+  */
+class StringInterpolatorOpt extends MiniPhase {
+  import tpd._
+
+  override def phaseName: String = "stringInterpolatorOpt"
+
+  private object StringContextIntrinsic {
+    def unapply(tree: Apply)(implicit ctx: Context): Option[(List[Tree], List[Tree])] = {
+      tree match {
+        case Apply(Select(Apply(Select(Ident(nme.StringContext), nme.apply),
+                   List(SeqLiteral(strs, _))), id), List(SeqLiteral(elems, _))) =>
+          if (id == nme.raw_) Some(strs, elems)
+          else if (id == nme.s) {
+            try {
+              val escapedStrs = strs.mapConserve { str =>
+                val strValue = str.asInstanceOf[Literal].const.stringValue
+                val escapedValue = StringContext.processEscapes(strValue)
+                cpy.Literal(str)(Constant(escapedValue))
+              }
+              Some(escapedStrs, elems)
+            } catch {
+              case _: StringContext.InvalidEscapeException => None
+            }
+          } else None
+        case _ => None
+      }
+    }
+  }
+
+  override def transformApply(tree: Apply)(implicit ctx: Context): Tree = {
+    tree match {
+      case StringContextIntrinsic(strs: List[Tree], elems: List[Tree]) =>
+        val numLits = strs.length
+        strs.tail.foldLeft((0, strs.head)) { (acc: (Int, Tree), str: Tree) =>
+          val (i, result) = acc
+          val resultWithElem =
+            if (i < numLits - 1) result.select(defn.String_+).appliedTo(elems(i))
+            else result
+          val resultWithStr =
+            if (str.asInstanceOf[Literal].const.stringValue.isEmpty) resultWithElem
+            else resultWithElem.select(defn.String_+).appliedTo(str)
+          (i + 1, resultWithStr)
+        }._2
+      case _ => tree
+    }
+  }
+}

tests/run/interpolation-opt.check

@@ -0,0 +1,5 @@
+1 plus two\nis 3.0
+1 plus two
+is 3.0
+a1two3.0b
+a1two3.0b

tests/run/interpolation-opt.scala

@@ -0,0 +1,14 @@
+object Test extends App {
+
+  val one = 1
+  val two = "two"
+  val three = 3.0
+
+  // Test escaping
+  println(raw"$one plus $two\nis $three")
+  println(s"$one plus $two\nis $three")
+
+  // Test empty strings between elements
+  println(raw"a$one$two${three}b")
+  println(s"a$one$two${three}b")
+}