Remove obsolete constants and backticks

Author: som-snytt

library/src/scala/collection/StringOps.scala

@@ -26,9 +26,7 @@ import scala.util.matching.Regex
 object StringOps {
  // just statics for companion class.
  private final val LF = 0x0A
- private final val FF = 0x0C
  private final val CR = 0x0D
- private final val SU = 0x1A
 
  private class StringIterator(private[this] val s: String) extends AbstractIterator[Char] {
  private[this] var pos = 0
@@ -180,14 +178,14 @@ object StringOps {
 final class StringOps(private val s: String) extends AnyVal {
  import StringOps._
 
- @`inline` def view: StringView = new StringView(s)
+ @inline def view: StringView = new StringView(s)
 
- @`inline` def size: Int = s.length
+ @inline def size: Int = s.length
 
- @`inline` def knownSize: Int = s.length
+ @inline def knownSize: Int = s.length
 
  /** Get the char at the specified index. */
- @`inline` def apply(i: Int): Char = s.charAt(i)
+ @inline def apply(i: Int): Char = s.charAt(i)
 
  def sizeCompare(otherSize: Int): Int = Integer.compare(s.length, otherSize)
 
@@ -344,13 +342,13 @@ final class StringOps(private val s: String) extends AnyVal {
  * @return a new string which contains all chars
  * of this string followed by all chars of `suffix`.
  */
- @`inline` def concat(suffix: String): String = s + suffix
+ @inline def concat(suffix: String): String = s + suffix
 
  /** Alias for `concat` */
- @`inline` def ++[B >: Char](suffix: Iterable[B]): immutable.IndexedSeq[B] = concat(suffix)
+ @inline def ++[B >: Char](suffix: Iterable[B]): immutable.IndexedSeq[B] = concat(suffix)
 
  /** Alias for `concat` */
- @`inline` def ++(suffix: IterableOnce[Char]): String = concat(suffix)
+ @inline def ++(suffix: IterableOnce[Char]): String = concat(suffix)
 
  /** Alias for `concat` */
  def ++(xs: String): String = concat(xs)
@@ -412,14 +410,14 @@ final class StringOps(private val s: String) extends AnyVal {
  }
 
  /** Alias for `prepended` */
- @`inline` def +: [B >: Char] (elem: B): immutable.IndexedSeq[B] = prepended(elem)
+ @inline def +: [B >: Char] (elem: B): immutable.IndexedSeq[B] = prepended(elem)
 
  /** A copy of the string with an char prepended */
  def prepended(c: Char): String =
  new JStringBuilder(s.length + 1).append(c).append(s).toString
 
  /** Alias for `prepended` */
- @`inline` def +: (c: Char): String = prepended(c)
+ @inline def +: (c: Char): String = prepended(c)
 
  /** A copy of the string with all elements from a collection prepended */
  def prependedAll[B >: Char](prefix: IterableOnce[B]): immutable.IndexedSeq[B] = {
@@ -432,13 +430,13 @@ final class StringOps(private val s: String) extends AnyVal {
  }
 
  /** Alias for `prependedAll` */
- @`inline` def ++: [B >: Char] (prefix: IterableOnce[B]): immutable.IndexedSeq[B] = prependedAll(prefix)
+ @inline def ++: [B >: Char] (prefix: IterableOnce[B]): immutable.IndexedSeq[B] = prependedAll(prefix)
 
  /** A copy of the string with another string prepended */
  def prependedAll(prefix: String): String = prefix + s
 
  /** Alias for `prependedAll` */
- @`inline` def ++: (prefix: String): String = prependedAll(prefix)
+ @inline def ++: (prefix: String): String = prependedAll(prefix)
 
  /** A copy of the string with an element appended */
  def appended[B >: Char](elem: B): immutable.IndexedSeq[B] = {
@@ -450,28 +448,28 @@ final class StringOps(private val s: String) extends AnyVal {
  }
 
  /** Alias for `appended` */
- @`inline` def :+ [B >: Char](elem: B): immutable.IndexedSeq[B] = appended(elem)
+ @inline def :+ [B >: Char](elem: B): immutable.IndexedSeq[B] = appended(elem)
 
  /** A copy of the string with an element appended */
  def appended(c: Char): String =
  new JStringBuilder(s.length + 1).append(s).append(c).toString
 
  /** Alias for `appended` */
- @`inline` def :+ (c: Char): String = appended(c)
+ @inline def :+ (c: Char): String = appended(c)
 
  /** A copy of the string with all elements from a collection appended */
- @`inline` def appendedAll[B >: Char](suffix: IterableOnce[B]): immutable.IndexedSeq[B] =
+ @inline def appendedAll[B >: Char](suffix: IterableOnce[B]): immutable.IndexedSeq[B] =
  concat(suffix)
 
  /** Alias for `appendedAll` */
- @`inline` def :++ [B >: Char](suffix: IterableOnce[B]): immutable.IndexedSeq[B] =
+ @inline def :++ [B >: Char](suffix: IterableOnce[B]): immutable.IndexedSeq[B] =
  concat(suffix)
 
  /** A copy of the string with another string appended */
- @`inline` def appendedAll(suffix: String): String = s + suffix
+ @inline def appendedAll(suffix: String): String = s + suffix
 
  /** Alias for `appendedAll` */
- @`inline` def :++ (suffix: String): String = s + suffix
+ @inline def :++ (suffix: String): String = s + suffix
 
  /** Produces a new collection where a slice of characters in this string is replaced by another collection.
  *
@@ -488,7 +486,7 @@ final class StringOps(private val s: String) extends AnyVal {
  */
  def patch[B >: Char](from: Int, other: IterableOnce[B], replaced: Int): immutable.IndexedSeq[B] = {
  val len = s.length
- @`inline` def slc(off: Int, length: Int): WrappedString =
+ @inline def slc(off: Int, length: Int): WrappedString =
  new WrappedString(s.substring(off, off+length))
  val b = immutable.IndexedSeq.newBuilder[B]
  val k = other.knownSize
@@ -645,8 +643,8 @@ final class StringOps(private val s: String) extends AnyVal {
 
  // Note: String.repeat is added in JDK 11.
  /** Return the current string concatenated `n` times.
-  */
- def *(n: Int): String = {
+ */
+ def *(n: Int): String =
  if (n <= 0) {
  ""
  } else {
@@ -658,10 +656,9 @@ final class StringOps(private val s: String) extends AnyVal {
  }
  sb.toString
  }
- }
 
- @`inline` private[this] def isLineBreak(c: Char) = c == CR || c == LF
- @`inline` private[this] def isLineBreak2(c0: Char, c: Char) = c0 == CR && c == LF
+ @inline private def isLineBreak(c: Char) = c == CR || c == LF
+ @inline private def isLineBreak2(c0: Char, c: Char) = c0 == CR && c == LF
 
  /** Strip the trailing line separator from this string if there is one.
  * The line separator is taken as `"\n"`, `"\r"`, or `"\r\n"`.
@@ -698,7 +695,7 @@ final class StringOps(private val s: String) extends AnyVal {
 
  private[this] val len = s.length
  private[this] var index = 0
- @`inline` private def done = index >= len
+ @inline private def done = index >= len
  private def advance(): String = {
  val start = index
  while (!done && !isLineBreak(apply(index))) index += 1
@@ -1118,7 +1115,7 @@ final class StringOps(private val s: String) extends AnyVal {
  * @return The result of applying `op` to `z` and all chars in this string,
  * going left to right. Returns `z` if this string is empty.
  */
- @`inline` def fold[A1 >: Char](z: A1)(op: (A1, A1) => A1): A1 = foldLeft(z)(op)
+ @inline def fold[A1 >: Char](z: A1)(op: (A1, A1) => A1): A1 = foldLeft(z)(op)
 
  /** Selects the first char of this string.
  * @return the first char of this string.
@@ -1158,19 +1155,19 @@ final class StringOps(private val s: String) extends AnyVal {
  /** Stepper can be used with Java 8 Streams. This method is equivalent to a call to
  * [[charStepper]]. See also [[codePointStepper]].
  */
- @`inline` def stepper: IntStepper with EfficientSplit = charStepper
+ @inline def stepper: IntStepper with EfficientSplit = charStepper
 
  /** Steps over characters in this string. Values are packed in `Int` for efficiency
  * and compatibility with Java 8 Streams which have an efficient specialization for `Int`.
  */
- @`inline` def charStepper: IntStepper with EfficientSplit = new CharStringStepper(s, 0, s.length)
+ @inline def charStepper: IntStepper with EfficientSplit = new CharStringStepper(s, 0, s.length)
 
  /** Steps over code points in this string.
  */
- @`inline` def codePointStepper: IntStepper with EfficientSplit = new CodePointStringStepper(s, 0, s.length)
+ @inline def codePointStepper: IntStepper with EfficientSplit = new CodePointStringStepper(s, 0, s.length)
 
  /** Tests whether the string is not empty. */
- @`inline` def nonEmpty: Boolean = !s.isEmpty
+ @inline def nonEmpty: Boolean = !s.isEmpty
 
  /** Returns new sequence with elements in reversed order.
  * @note $unicodeunaware
@@ -1268,7 +1265,7 @@ final class StringOps(private val s: String) extends AnyVal {
  }
 
  /** Selects all chars of this string which do not satisfy a predicate. */
- @`inline` def filterNot(pred: Char => Boolean): String = filter(c => !pred(c))
+ @inline def filterNot(pred: Char => Boolean): String = filter(c => !pred(c))
 
  /** Copy chars of this string to an array.
  * Fills the given array `xs` starting at index 0.
@@ -1277,7 +1274,7 @@ final class StringOps(private val s: String) extends AnyVal {
  *
  * @param xs the array to fill.
  */
- @`inline` def copyToArray(xs: Array[Char]): Int =
+ @inline def copyToArray(xs: Array[Char]): Int =
  copyToArray(xs, 0, Int.MaxValue)
 
  /** Copy chars of this string to an array.
@@ -1288,7 +1285,7 @@ final class StringOps(private val s: String) extends AnyVal {
  * @param xs the array to fill.
  * @param start the starting index.
  */
- @`inline` def copyToArray(xs: Array[Char], start: Int): Int =
+ @inline def copyToArray(xs: Array[Char], start: Int): Int =
  copyToArray(xs, start, Int.MaxValue)
 
  /** Copy chars of this string to an array.