wip

Author: nicolasstucki

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

@@ -22,64 +22,67 @@ class StringInterpolatorOpt extends MiniPhase {
   override def phaseName: String = "stringInterpolatorOpt"
 
   /** Matches a list of constant literals */
-//  private object Literals {
-//    def unapply(tree: SeqLiteral)(implicit ctx: Context): Option[List[Literal]] = {
-//      tree.elems match {
-//        case literals if literals.forall(_.isInstanceOf[Literal]) =>
-//          Some(literals.map(_.asInstanceOf[Literal]))
-//        case _ => None
-//      }
-//    }
-//  }
-//
-//  private object StringContextApply {
-//    def unapply(tree: Select)(implicit ctx: Context): Boolean = {
-//      tree.symbol.eq(defn.StringContextModule_apply) && {
-//        val qualifier = tree.qualifier
-//        qualifier.isInstanceOf[Ident] && qualifier.symbol.eq(defn.StringContextModule)
-//      }
-//    }
-//  }
+  private object Literals {
+    def unapply(tree: SeqLiteral)(implicit ctx: Context): Option[List[Literal]] = {
+      tree.elems match {
+        case literals if literals.forall(_.isInstanceOf[Literal]) =>
+          Some(literals.map(_.asInstanceOf[Literal]))
+        case _ => None
+      }
+    }
+  }
 
-//  override def transformApply(tree: Apply)(implicit ctx: Context): Tree = {
-//    /** Matches an s or raw string interpolator */
-//    if (tree.symbol.eq(defn.StringContextRaw) || tree.symbol.eq(defn.StringContextS)) {
-//      tree match {
-//        case Apply(Select(Apply(StringContextApply(), List(Literals(strs))), _),
-//            List(SeqLiteral(elems, _))) if elems.length == strs.length - 1 =>
-//          /** Match trees that resemble s and raw string interpolations. In the case of the s
-//           *  interpolator, escapes the string constants. Exposes the string constants as well as
-//           *  the variable references.
-//           */
-//          if (tree.symbol == defn.StringContextRaw) interpolate(strs, elems)
-//          else { // tree.symbol == defn.StringContextS
-//            try {
-//              val escapedStrs = strs.map { str =>
-//                val escapedValue = StringContext.processEscapes(str.const.stringValue)
-//                cpy.Literal(str)(Constant(escapedValue))
-//              }
-//              interpolate(escapedStrs, elems)
-//            } catch {
-//              case _: StringContext.InvalidEscapeException => tree
-//            }
-//          }
-//        case _ => tree
-//      }
-//    } else tree
-//  }
+  private object StringContextApply {
+    def unapply(tree: Select)(implicit ctx: Context): Boolean = {
+      tree.symbol.eq(defn.StringContextModule_apply) && {
+        val qualifier = tree.qualifier
+        qualifier.isInstanceOf[Ident] && qualifier.symbol.eq(defn.StringContextModule)
+      }
+    }
+  }
 
-//  private def interpolate(strs: List[Literal], elems: List[Tree])(implicit ctx: Context): 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
-//  }
+  override def transformApply(tree: Apply)(implicit ctx: Context): Tree = {
+    val sym = tree.symbol
+    if (sym.ne(defn.StringContextS) && sym.ne(defn.StringContextRaw)) tree
+    else transformStringInterpolator(tree)
+  }
+
+  private def transformStringInterpolator(tree: Tree)(implicit ctx: Context): Tree = {
+    tree match {
+      case Apply(Select(Apply(StringContextApply(), List(Literals(strs))), _),
+      List(SeqLiteral(elems, _))) if elems.length == strs.length - 1 =>
+        /** Match trees that resemble s and raw string interpolations. In the case of the s
+          *  interpolator, escapes the string constants. Exposes the string constants as well as
+          *  the variable references.
+          */
+        if (tree.symbol == defn.StringContextRaw) interpolate(strs, elems)
+        else { // tree.symbol == defn.StringContextS
+          try {
+            val escapedStrs = strs.map { str =>
+              val escapedValue = StringContext.processEscapes(str.const.stringValue)
+              cpy.Literal(str)(Constant(escapedValue))
+            }
+            interpolate(escapedStrs, elems)
+          } catch {
+            case _: StringContext.InvalidEscapeException => tree
+          }
+        }
+      case _ => tree
+    }
+  }
+
+  private def interpolate(strs: List[Literal], elems: List[Tree])(implicit ctx: Context): 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
+  }
 }