Merge pull request scala#6757 from szeiger/issue/10932

Remove reflection-based class name computation for collections

Author: lrytz

src/library/scala/collection/ArrayOps.scala

@@ -39,7 +39,7 @@ object ArrayOps {
   private class ArrayView[A](xs: Array[A]) extends IndexedSeqView[A] {
     def length = xs.length
     def apply(n: Int) = xs(n)
-    override def className = "ArrayView"
+    override protected[this] def className = "ArrayView"
   }
 
   /** A lazy filtered array. No filtering is applied until one of `foreach`, `map` or `flatMap` is called. */

src/library/scala/collection/BitSet.scala

@@ -23,6 +23,7 @@ trait BitSet extends SortedSet[Int] with BitSetOps[BitSet] {
   override protected def fromSpecificIterable(coll: Iterable[Int]): BitSetC = bitSetFactory.fromSpecific(coll)
   override protected def newSpecificBuilder: Builder[Int, BitSetC] = bitSetFactory.newBuilder
   override def empty: BitSetC = bitSetFactory.empty
+  override protected[this] def stringPrefix = "BitSet"
 }
 
 @SerialVersionUID(3L)

src/library/scala/collection/IndexedSeq.scala

@@ -7,7 +7,9 @@ import scala.math.Ordering
 import Searching.{SearchResult, Found, InsertionPoint}
 
 /** Base trait for indexed sequences that have efficient `apply` and `length` */
-trait IndexedSeq[+A] extends Seq[A] with IndexedSeqOps[A, IndexedSeq, IndexedSeq[A]]
+trait IndexedSeq[+A] extends Seq[A] with IndexedSeqOps[A, IndexedSeq, IndexedSeq[A]] {
+  override protected[this] def stringPrefix: String = "IndexedSeq"
+}
 
 @SerialVersionUID(3L)
 object IndexedSeq extends SeqFactory.Delegate[IndexedSeq](immutable.IndexedSeq)

src/library/scala/collection/Iterable.scala

@@ -46,6 +46,43 @@ trait Iterable[+A] extends IterableOnce[A] with IterableOps[A, Iterable, Iterabl
     * to be preserved or a more efficient implementation is available. Override to return `this` in order to
     * use self-serialization instead of a proxy. */
   protected[this] def writeReplace(): AnyRef = new DefaultSerializationProxy(iterableFactory.iterableFactory, this)
+
+  /** Defines the prefix of this object's `toString` representation.
+    *
+    * It is recommended to return the name of the concrete collection type, but
+    * not implementation subclasses. For example, for `ListMap` this method should
+    * return `"ListMap"`, not `"Map"` (the supertype) or `"Node"` (an implementation
+    * subclass).
+    *
+    * The default implementation returns "Iterable". It is overridden for the basic
+    * collection kinds "Seq", "IndexedSeq", "LinearSeq", "Buffer", "Set", "Map",
+    * "SortedSet", "SortedMap" and "View".
+    *
+    *  @return  a string representation which starts the result of `toString`
+    *           applied to this $coll. By default the string prefix is the
+    *           simple name of the collection class $coll.
+    */
+  protected[this] def className: String = stringPrefix
+
+  /** Forwarder to `className` for use in `scala.runtime.ScalaRunTime`.
+    *
+    * This allows the proper visibility for `className` to be
+    * published, but provides the exclusive access needed by
+    * `scala.runtime.ScalaRunTime.stringOf` (and a few tests in
+    * the test suite).
+    */
+  private[scala] final def collectionClassName: String = className
+
+  @deprecatedOverriding("Override className instead", "2.13.0")
+  protected[this] def stringPrefix: String = "Iterable"
+
+  /** Converts this $coll to a string.
+    *
+    *  @return   a string representation of this collection. By default this
+    *            string consists of the `className` of this $coll, followed
+    *            by all elements separated by commas and enclosed in parentheses.
+    */
+  override def toString = mkString(className + "(", ", ", ")")
 }
 
 /** Base trait for Iterable operations
@@ -187,105 +224,6 @@ trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] with Iterable
   @deprecated("Use .view.slice(from, until) instead of .view(from, until)", "2.13.0")
   @`inline` final def view(from: Int, until: Int): View[A] = view.slice(from, until)
 
-  /** Defines the prefix of this object's `toString` representation.
-    *
-    * It is recommended to return the name of the concrete collection type, but
-    * not implementation subclasses. For example, for `ListMap` this method should
-    * return `"ListMap"`, not `"Map"` (the supertype) or `"Node"` (an implementation
-    * subclass).
-    *
-    * It is recommended to overwrite this method even if the default implementation
-    * returns the correct name, to avoid the implementation using reflection.
-    *
-    *  @return  a string representation which starts the result of `toString`
-    *           applied to this $coll. By default the string prefix is the
-    *           simple name of the collection class $coll.
-    */
-  @`inline` protected[this] def className: String = stringPrefix
-
-  /** Forwarder to `className` for use in `scala.runtime.ScalaRunTime`.
-    * 
-    * This allows the proper visibility for `className` to be
-    * published, but provides the exclusive access needed by
-    * `scala.runtime.ScalaRunTime.stringOf` (and a few tests in
-    * the test suite).
-    */
-  private[scala] final def collectionClassName: String = className
-
-  @deprecatedOverriding("Override className instead", "2.13.0")
-  protected[this] def stringPrefix: String = {
-    /* This method is written in a style that avoids calling `String.split()`
-     * as well as methods of java.lang.Character that require the Unicode
-     * database information. This is mostly important for Scala.js, so that
-     * using the collection library does automatically bring java.util.regex.*
-     * and the Unicode database in the generated code.
-     *
-     * This algorithm has the additional benefit that it won't allocate
-     * anything except the result String in the common case, where the class
-     * is not an inner class (i.e., when the result contains no '.').
-     */
-    val fqn = toIterable.getClass.getName
-    var pos: Int = fqn.length - 1
-
-    // Skip trailing $'s
-    while (pos != -1 && fqn.charAt(pos) == '$') {
-      pos -= 1
-    }
-    if (pos == -1 || fqn.charAt(pos) == '.') {
-      return ""
-    }
-
-    var result: String = ""
-    while (true) {
-      // Invariant: if we enter the loop, there is a non-empty part
-
-      // Look for the beginning of the part, remembering where was the last non-digit
-      val partEnd = pos + 1
-      while (pos != -1 && fqn.charAt(pos) <= '9' && fqn.charAt(pos) >= '0') {
-        pos -= 1
-      }
-      val lastNonDigit = pos
-      while (pos != -1 && fqn.charAt(pos) != '$' && fqn.charAt(pos) != '.') {
-        pos -= 1
-      }
-      val partStart = pos + 1
-
-      // A non-last part which contains only digits marks a method-local part -> drop the prefix
-      if (pos == lastNonDigit && partEnd != fqn.length) {
-        return result
-      }
-
-      // Skip to the next part, and determine whether we are the end
-      while (pos != -1 && fqn.charAt(pos) == '$') {
-        pos -= 1
-      }
-      val atEnd = pos == -1 || fqn.charAt(pos) == '.'
-
-      // Handle the actual content of the part (we ignore parts that are likely synthetic)
-      def isPartLikelySynthetic = {
-        val firstChar = fqn.charAt(partStart)
-        (firstChar > 'Z' && firstChar < 0x7f) || (firstChar < 'A')
-      }
-      if (atEnd || !isPartLikelySynthetic) {
-        val part = fqn.substring(partStart, partEnd)
-        result = if (result.isEmpty) part else part + '.' + result
-        if (atEnd)
-          return result
-      }
-    }
-
-    // dead code
-    result
-  }
-
-  /** Converts this $coll to a string.
-    *
-    *  @return   a string representation of this collection. By default this
-    *            string consists of the `className` of this $coll, followed
-    *            by all elements separated by commas and enclosed in parentheses.
-    */
-  override def toString = mkString(className + "(", ", ", ")")
-
   //TODO Can there be a useful lazy implementation of this method? Otherwise mark it as being always strict
   /** Transposes this $coll of iterable collections into
     *  a $coll of ${coll}s.

src/library/scala/collection/LinearSeq.scala

@@ -8,7 +8,9 @@ import scala.language.higherKinds
   *  `tail` operations.
   *  Known subclasses: List, LazyList
   */
-trait LinearSeq[+A] extends Seq[A] with LinearSeqOps[A, LinearSeq, LinearSeq[A]]
+trait LinearSeq[+A] extends Seq[A] with LinearSeqOps[A, LinearSeq, LinearSeq[A]] {
+  override protected[this] def stringPrefix: String = "LinearSeq"
+}
 
 @SerialVersionUID(3L)
 object LinearSeq extends SeqFactory.Delegate[LinearSeq](immutable.List)

src/library/scala/collection/Map.scala

@@ -54,6 +54,10 @@ trait Map[K, +V]
   def - (key: K): Map[K, V]
   @deprecated("Use -- or removeAll on an immutable Map", "2.13.0")
   def - (key1: K, key2: K, keys: K*): Map[K, V]
+
+  override protected[this] def stringPrefix: String = "Map"
+
+  override def toString(): String = super[Iterable].toString() // Because `Function1` overrides `toString` too
 }
 
 /** Base Map implementation type
@@ -278,8 +282,6 @@ trait MapOps[K, +V, +CC[_, _] <: IterableOps[_, AnyConstr, _], +C]
   /** Alias for `concat` */
   /*@`inline` final*/ def ++ [V2 >: V](xs: collection.Iterable[(K, V2)]): CC[K, V2] = concat(xs)
 
-  override def toString(): String = super[IterableOps].toString()
-
   override def mkString(start: String, sep: String, end: String): String =
     iterator.map { case (k, v) => s"$k -> $v" }.mkString(start, sep, end)
 

src/library/scala/collection/Seq.scala

@@ -39,6 +39,7 @@ trait Seq[+A]
 
   override def toString(): String = super[Iterable].toString()
 
+  override protected[this] def stringPrefix: String = "Seq"
 }
 
 /**

src/library/scala/collection/Set.scala

@@ -30,6 +30,10 @@ trait Set[A]
   override def iterableFactory: IterableFactory[IterableCC] = Set
 
   def empty: IterableCC[A] = iterableFactory.empty
+
+  override protected[this] def stringPrefix: String = "Set"
+
+  override def toString(): String = super[Iterable].toString() // Because `Function1` overrides `toString` too
 }
 
 /** Base trait for set operations
@@ -128,8 +132,6 @@ trait SetOps[A, +CC[_], +C <: SetOps[A, CC, C]]
     }
   }
 
-  override def toString(): String = super[IterableOps].toString() // Because `Function1` overrides `toString` too
-
   /** Computes the intersection between this set and another set.
     *
     *  @param   that  the set to intersect with.

src/library/scala/collection/SortedMap.scala

@@ -30,6 +30,8 @@ trait SortedMap[K, +V]
   override def empty: SortedMapCC[K, V] @uncheckedVariance = sortedMapFactory.empty
 
   override protected[this] def writeReplace(): AnyRef = new DefaultSerializationProxy(sortedMapFactory.sortedMapFactory[K, V], this)
+
+  override protected[this] def stringPrefix: String = "SortedMap"
 }
 
 trait SortedMapOps[K, +V, +CC[X, Y] <: Map[X, Y] with SortedMapOps[X, Y, CC, _], +C <: SortedMapOps[K, V, CC, C]]
@@ -181,7 +183,6 @@ trait SortedMapOps[K, +V, +CC[X, Y] <: Map[X, Y] with SortedMapOps[X, Y, CC, _],
   override def + [V1 >: V](elem1: (K, V1), elem2: (K, V1), elems: (K, V1)*): CC[K, V1] = sortedMapFactory.from(new View.Concat(new View.Appended(new View.Appended(toIterable, elem1), elem2), elems))
 
   // TODO Also override mapValues
-
 }
 
 object SortedMapOps {

src/library/scala/collection/SortedSet.scala

@@ -24,6 +24,8 @@ trait SortedSet[A] extends Set[A] with SortedSetOps[A, SortedSet, SortedSet[A]]
   override def empty: SortedIterableCC[A] = sortedIterableFactory.empty
 
   override protected[this] def writeReplace(): AnyRef = new DefaultSerializationProxy(sortedIterableFactory.evidenceIterableFactory[A], this)
+
+  override protected[this] def stringPrefix: String = "SortedSet"
 }
 
 trait SortedSetOps[A, +CC[X] <: SortedSet[X], +C <: SortedSetOps[A, CC, C]]

src/library/scala/collection/StringOps.scala

@@ -1409,5 +1409,5 @@ case class StringView(s: String) extends AbstractIndexedSeqView[Char] {
   def length = s.length
   @throws[StringIndexOutOfBoundsException]
   def apply(n: Int) = s.charAt(n)
-  override def className = "StringView"
+  override protected[this] def className = "StringView"
 }

src/library/scala/collection/View.scala

@@ -18,9 +18,9 @@ trait View[+A] extends Iterable[A] with IterableOps[A, View, View[A]] {
 
   override def iterableFactory = View
 
-  override def toString = "View(?)"
+  override def toString = stringPrefix + "(?)"
 
-  override def className = "View"
+  override protected[this] def stringPrefix = "View"
 
   @deprecated("Views no longer know about their underlying collection type; .force always returns an IndexedSeq", "2.13.0")
   @`inline` def force: IndexedSeq[A] = toIndexedSeq

src/library/scala/collection/concurrent/TrieMap.scala

@@ -971,7 +971,7 @@ final class TrieMap[K, V] private (r: AnyRef, rtupd: AtomicReferenceFieldUpdater
     if (nonReadOnly) readOnlySnapshot().size
     else cachedSize()
 
-  override def className = "TrieMap"
+  override protected[this] def className = "TrieMap"
 
 }
 

src/library/scala/collection/immutable/ArraySeq.scala

@@ -131,7 +131,7 @@ sealed abstract class ArraySeq[+A]
 
   override def reverse: ArraySeq[A] = ArraySeq.unsafeWrapArray(new ArrayOps(unsafeArray).reverse).asInstanceOf[ArraySeq[A]]
 
-  override def className = "ArraySeq"
+  override protected[this] def className = "ArraySeq"
 
   override def copyToArray[B >: A](xs: Array[B], start: Int = 0): xs.type = copyToArray[B](xs, start, length)
 

src/library/scala/collection/immutable/BitSet.scala

@@ -24,8 +24,6 @@ sealed abstract class BitSet
     with collection.BitSetOps[BitSet]
     with StrictOptimizedIterableOps[Int, Set, BitSet] {
 
-  override def className: String = "BitSet"
-
   def bitSetFactory = BitSet
 
   protected[collection] def fromBitMaskNoCopy(elems: Array[Long]): BitSet = BitSet.fromBitMaskNoCopy(elems)

src/library/scala/collection/immutable/ChampHashMap.scala

@@ -102,6 +102,8 @@ final class ChampHashMap[K, +V] private[immutable] (val rootNode: MapNode[K, V],
       case _ => super.equals(that)
     }
 
+
+  override protected[this] def className = "ChampHashMap"
 }
 
 private[immutable] object MapNode {

src/library/scala/collection/immutable/ChampHashSet.scala

@@ -84,6 +84,7 @@ final class ChampHashSet[A] private[immutable] (val rootNode: SetNode[A], val ca
       case _ => super.equals(that)
     }
 
+  override protected[this] def className = "ChampHashSet"
 }
 
 private[immutable] final object SetNode {

src/library/scala/collection/immutable/HashMap.scala

@@ -90,7 +90,7 @@ sealed abstract class HashMap[K, +V]
     nullToEmpty(filter0(pred, negate = true, 0, buffer, 0))
   }
 
-  override def className: String = "HashMap"
+  override protected[this] def className: String = "HashMap"
 
 }
 

src/library/scala/collection/immutable/HashSet.scala

@@ -30,7 +30,7 @@ sealed abstract class HashSet[A]
 
   import HashSet.{bufferSize, LeafHashSet, nullToEmpty}
 
-  override def className: String = "HashSet"
+  override protected[this] def className: String = "HashSet"
 
   override def iterableFactory = HashSet
 

src/library/scala/collection/immutable/IntMap.scala

@@ -258,7 +258,7 @@ sealed abstract class IntMap[+T] extends AbstractMap[Int, T]
     case IntMap.Nil =>
   }
 
-  override def className = "IntMap"
+  override protected[this] def className = "IntMap"
 
   override def isEmpty = this == IntMap.Nil
 

src/library/scala/collection/immutable/LazyList.scala

@@ -225,6 +225,8 @@ sealed abstract class LazyList[+A] extends AbstractSeq[A] with LinearSeq[A] with
 
   override protected[this] def writeReplace(): AnyRef =
     if(headDefined && tailDefined) new LazyListOps.SerializationProxy[A, LazyList](this) else this
+
+  override protected[this] def className = "LazyList"
 }
 
 sealed private[immutable] trait LazyListOps[+A, +CC[+X] <: LinearSeq[X] with LazyListOps[X, CC, CC[X]], +C <: CC[A] with LazyListOps[A, CC, C]]
@@ -255,8 +257,6 @@ sealed private[immutable] trait LazyListOps[+A, +CC[+X] <: LinearSeq[X] with Laz
   def lazyAppendedAll[B >: A](suffix: => collection.IterableOnce[B]): CC[B] =
     if (isEmpty) iterableFactory.from(suffix) else cons[B](head, tail.lazyAppendedAll(suffix))
 
-  override def className = "LazyList"
-
   override def equals(that: Any): Boolean =
     if (this eq that.asInstanceOf[AnyRef]) true else super.equals(that)
 
@@ -454,6 +454,8 @@ sealed private[immutable] trait LazyListOps[+A, +CC[+X] <: LinearSeq[X] with Laz
   override def mkString(sep: String): String = super.mkString(sep)
   override def mkString: String = super.mkString
 
+  protected[this] def className: String
+
   /**
     * @return a string representation of this collection. Undefined elements are
     *         represented with `"_"`, an undefined tail is represented with `"?"`,
@@ -714,7 +716,7 @@ object LazyList extends LazyListFactory[LazyList] {
 sealed abstract class Stream[+A] extends AbstractSeq[A] with LinearSeq[A] with LazyListOps[A, Stream, Stream[A]] {
   override def iterableFactory: LazyListFactory[Stream] = Stream
 
-  override def className: String = "Stream"
+  override protected[this] def className: String = "Stream"
 
   protected def cons[T](hd: => T, tl: => Stream[T]): Stream[T] = new Stream.Cons(hd, tl)
 

src/library/scala/collection/immutable/List.scala

@@ -382,7 +382,7 @@ sealed abstract class List[+A]
     None
   }
 
-  override def className = "List"
+  override protected[this] def className = "List"
 
   /** Builds a new list by applying a function to all elements of this list.
     *  Like `xs map f`, but returns `xs` unchanged if function