Merge branch '2.11.x' into 2.12.x

3 files changed, 57 insertions, 55 deletions

diff --git a/src/library/scala/StringContext.scala b/src/library/scala/StringContext.scala
index cd928a2b61..c0468e8b02 100644
--- a/src/library/scala/StringContext.scala
+++ b/src/library/scala/StringContext.scala
@@ -8,6 +8,9 @@
 
 package scala
 
+import java.lang.{ StringBuilder => JLSBuilder }
+import scala.annotation.tailrec
+
 /** This class provides the basic mechanism to do String Interpolation.
  * String Interpolation allows users
  * to embed variable references directly in *processed* string literals.
@@ -41,7 +44,7 @@ package scala
  *    val x: JSONObject = json"{ a: $a }"
  * }}}
  *
- *  Here the `JsonHelper` extenion class implicitly adds the `json` method to
+ *  Here the `JsonHelper` extension class implicitly adds the `json` method to
  *  `StringContext` which can be used for `json` string literals.
  *
  *  @since 2.10.0
@@ -118,7 +121,7 @@ case class StringContext(parts: String*) {
     checkLengths(args)
     val pi = parts.iterator
     val ai = args.iterator
-    val bldr = new java.lang.StringBuilder(process(pi.next()))
+    val bldr = new JLSBuilder(process(pi.next()))
     while (ai.hasNext) {
       bldr append ai.next
       bldr append process(pi.next())
@@ -186,60 +189,60 @@ object StringContext {
    */
   def treatEscapes(str: String): String = treatEscapes0(str, strict = false)
 
+  /** Treats escapes, but disallows octal escape sequences. */
   def processEscapes(str: String): String = treatEscapes0(str, strict = true)
 
   private def treatEscapes0(str: String, strict: Boolean): String = {
-    lazy val bldr = new java.lang.StringBuilder
     val len = str.length
-    var start = 0
-    var cur = 0
-    var idx = 0
-    def output(ch: Char) = {
-      bldr.append(str, start, cur)
-      bldr append ch
-      start = idx
-    }
-    while (idx < len) {
-      cur = idx
-      if (str(idx) == '\\') {
-        idx += 1
-        if (idx >= len) throw new InvalidEscapeException(str, cur)
-        if ('0' <= str(idx) && str(idx) <= '7') {
-          if (strict) throw new InvalidEscapeException(str, cur)
-          val leadch = str(idx)
-          var oct = leadch - '0'
-          idx += 1
-          if (idx < len && '0' <= str(idx) && str(idx) <= '7') {
-            oct = oct * 8 + str(idx) - '0'
-            idx += 1
-            if (idx < len && leadch <= '3' && '0' <= str(idx) && str(idx) <= '7') {
-              oct = oct * 8 + str(idx) - '0'
+    // replace escapes with given first escape
+    def replace(first: Int): String = {
+      val b = new JLSBuilder
+      // append replacement starting at index `i`, with `next` backslash
+      @tailrec def loop(i: Int, next: Int): String = {
+        if (next >= 0) {
+          //require(str(next) == '\\')
+          if (next > i) b.append(str, i, next)
+          var idx = next + 1
+          if (idx >= len) throw new InvalidEscapeException(str, next)
+          val c = str(idx) match {
+            case 'b'  => '\b'
+            case 't'  => '\t'
+            case 'n'  => '\n'
+            case 'f'  => '\f'
+            case 'r'  => '\r'
+            case '"'  => '"'
+            case '\'' => '\''
+            case '\\' => '\\'
+            case o if '0' <= o && o <= '7' =>
+              if (strict) throw new InvalidEscapeException(str, next)
+              val leadch = str(idx)
+              var oct = leadch - '0'
               idx += 1
-            }
+              if (idx < len && '0' <= str(idx) && str(idx) <= '7') {
+                oct = oct * 8 + str(idx) - '0'
+                idx += 1
+                if (idx < len && leadch <= '3' && '0' <= str(idx) && str(idx) <= '7') {
+                  oct = oct * 8 + str(idx) - '0'
+                  idx += 1
+                }
+              }
+              idx -= 1   // retreat
+              oct.toChar
+            case _    => throw new InvalidEscapeException(str, next)
           }
-          output(oct.toChar)
+          idx += 1       // advance
+          b append c
+          loop(idx, str.indexOf('\\', idx))
         } else {
-          val ch = str(idx)
-          idx += 1
-          output {
-            ch match {
-              case 'b'  => '\b'
-              case 't'  => '\t'
-              case 'n'  => '\n'
-              case 'f'  => '\f'
-              case 'r'  => '\r'
-              case '\"' => '\"'
-              case '\'' => '\''
-              case '\\' => '\\'
-              case _    => throw new InvalidEscapeException(str, cur)
-            }
-          }
+          if (i < len) b.append(str, i, len)
+          b.toString
         }
-      } else  {
-        idx += 1
       }
+      loop(0, first)
+    }
+    str indexOf '\\' match {
+      case -1 => str
+      case  i => replace(i)
     }
-    if (start == 0) str
-    else bldr.append(str, start, idx).toString
   }
 }
diff --git a/src/library/scala/collection/TraversableLike.scala b/src/library/scala/collection/TraversableLike.scala
index b60ea86ab0..d3a7db6968 100644
--- a/src/library/scala/collection/TraversableLike.scala
+++ b/src/library/scala/collection/TraversableLike.scala
@@ -345,8 +345,8 @@ trait TraversableLike[+A, +Repr] extends Any
    *  $mayNotTerminateInf
    *
    *  @param   p     the predicate used to test elements.
-   *  @return        `true` if the given predicate `p` holds for all elements
-   *                 of this $coll, otherwise `false`.
+   *  @return        `true`  if this $coll is empty, otherwise `true` if the given predicate `p`
+    *                holds for all elements of this $coll, otherwise `false`.
    */
   def forall(p: A => Boolean): Boolean = {
     var result = true
@@ -362,8 +362,8 @@ trait TraversableLike[+A, +Repr] extends Any
    *  $mayNotTerminateInf
    *
    *  @param   p     the predicate used to test elements.
-   *  @return        `true` if the given predicate `p` holds for some of the
-   *                 elements of this $coll, otherwise `false`.
+   *  @return        `false` if this $coll is empty, otherwise `true` if the given predicate `p`
+    *                holds for some of the elements of this $coll, otherwise `false`
    */
   def exists(p: A => Boolean): Boolean = {
     var result = false
diff --git a/src/library/scala/collection/TraversableOnce.scala b/src/library/scala/collection/TraversableOnce.scala
index 072fd3da44..a8c4e047ab 100644
--- a/src/library/scala/collection/TraversableOnce.scala
+++ b/src/library/scala/collection/TraversableOnce.scala
@@ -85,10 +85,9 @@ trait TraversableOnce[+A] extends Any with GenTraversableOnce[A] {
    */
   def seq: TraversableOnce[A]
 
-  /** Presently these are abstract because the Traversable versions use
-   *  breakable/break, and I wasn't sure enough of how that's supposed to
-   *  function to consolidate them with the Iterator versions.
-   */
+  // Presently these are abstract because the Traversable versions use
+  // breakable/break, and I wasn't sure enough of how that's supposed to
+  // function to consolidate them with the Iterator versions.
   def forall(p: A => Boolean): Boolean
   def exists(p: A => Boolean): Boolean
   def find(p: A => Boolean): Option[A]