Inline extractors to avoid indirection to sym checks

Author: nicolasstucki

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

@@ -41,62 +41,45 @@ class StringInterpolatorOpt extends MiniPhase {
     }
   }
 
-  /** Matches an s or raw string interpolator */
-  private object SOrRawInterpolator {
-    def unapply(tree: Tree)(implicit ctx: Context): Option[(List[Literal], List[Tree])] = {
-      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 =>
-            Some(strs, elems)
-          case _ => None
-        }
-      } else None
-    }
-  }
-
-  /**
-    * 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.
-    */
-  private object StringContextIntrinsic {
-    def unapply(tree: Apply)(implicit ctx: Context): Option[(List[Literal], List[Tree])] = {
+  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 SOrRawInterpolator(strs, elems) =>
-          if (tree.symbol == defn.StringContextRaw) Some(strs, elems)
+        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))
               }
-              Some(escapedStrs, elems)
+              interpolate(escapedStrs, elems)
             } catch {
-              case _: StringContext.InvalidEscapeException => None
+              case _: StringContext.InvalidEscapeException => tree
             }
           }
-        case _ => None
+        case _ => tree
       }
-    }
+    } else tree
   }
 
-  override def transformApply(tree: Apply)(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
+  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
   }
 }