Use Abstract* base classes consistently to save on classfile size

- Mark some methods non-final due to scala/bug#10853
- Add immutable.AbstractMap, use AbstractMap consistently
- Add immutable.AbstractSet, use AbstractSet consistently
- Use AbstractIterable consistently
- Add AbstractView
- Use AbstractSeq consistently

Author: lrytz

src/compiler/scala/tools/nsc/io/Jar.scala

@@ -7,12 +7,14 @@ package scala.tools.nsc
 package io
 
 import scala.language.postfixOps
-
-import java.io.{ InputStream, OutputStream, DataOutputStream }
+import java.io.{DataOutputStream, InputStream, OutputStream}
 import java.util.jar._
+
 import scala.collection.JavaConverters._
 import Attributes.Name
 
+import scala.collection.AbstractIterable
+
 // Attributes.Name instances:
 //
 // static Attributes.Name   CLASS_PATH
@@ -33,7 +35,7 @@ import Attributes.Name
 // static Attributes.Name   SPECIFICATION_VENDOR
 // static Attributes.Name   SPECIFICATION_VERSION
 
-class Jar(file: File) extends Iterable[JarEntry] {
+class Jar(file: File) extends AbstractIterable[JarEntry] {
   def this(jfile: JFile) = this(File(jfile))
   def this(path: String) = this(File(path))
 

src/library/scala/Enumeration.scala

@@ -266,7 +266,8 @@ abstract class Enumeration (initial: Int) extends Serializable {
    *  @define Coll `collection.immutable.SortedSet`
    */
   class ValueSet private[ValueSet] (private[this] var nnIds: immutable.BitSet)
-    extends immutable.SortedSet[Value]
+    extends immutable.AbstractSet[Value]
+      with immutable.SortedSet[Value]
       with immutable.SetOps[Value, immutable.Set, ValueSet]
       with StrictOptimizedIterableOps[Value, immutable.Set, ValueSet]
       with Serializable {

src/library/scala/collection/IndexedView.scala

@@ -42,7 +42,7 @@ object IndexedView {
   class Take[A](underlying: SomeIndexedSeqOps[A], n: Int)
     extends SeqView.Take(underlying, n) with IndexedView[A]
 
-  class TakeRight[A](underlying: SomeIndexedSeqOps[A], n: Int) extends IndexedView[A] {
+  class TakeRight[A](underlying: SomeIndexedSeqOps[A], n: Int) extends AbstractIndexedView[A] {
     private[this] val delta = (underlying.size - (n max 0)) max 0
     def length = underlying.size - delta
     @throws[IndexOutOfBoundsException]
@@ -55,7 +55,7 @@ object IndexedView {
     def apply(i: Int) = underlying.apply(i + normN)
   }
 
-  class DropRight[A](underlying: SomeIndexedSeqOps[A], n: Int) extends IndexedView[A] {
+  class DropRight[A](underlying: SomeIndexedSeqOps[A], n: Int) extends AbstractIndexedView[A] {
     private[this] val len = (underlying.size - (n max 0)) max 0
     def length = len
     @throws[IndexOutOfBoundsException]
@@ -65,13 +65,13 @@ object IndexedView {
   class Map[A, B](underlying: SomeIndexedSeqOps[A], f: A => B)
     extends SeqView.Map(underlying, f) with IndexedView[B]
 
-  class Reverse[A](underlying: SomeIndexedSeqOps[A]) extends IndexedView[A] {
+  class Reverse[A](underlying: SomeIndexedSeqOps[A]) extends AbstractIndexedView[A] {
     def length = underlying.size
     @throws[IndexOutOfBoundsException]
     def apply(i: Int) = underlying.apply(size - 1 - i)
   }
 
-  class Slice[A](underlying: SomeIndexedSeqOps[A], from: Int, until: Int) extends IndexedView[A] {
+  class Slice[A](underlying: SomeIndexedSeqOps[A], from: Int, until: Int) extends AbstractIndexedView[A] {
     protected val lo = from max 0
     protected val hi = (until max 0) min underlying.length
     protected val len = (hi - lo) max 0
@@ -80,3 +80,6 @@ object IndexedView {
     def length: Int = len
   }
 }
+
+/** Explicit instantiation of the `IndexedView` trait to reduce class file size in subclasses. */
+abstract class AbstractIndexedView[+A] extends AbstractSeqView[A] with IndexedView[A]

src/library/scala/collection/Iterable.scala

@@ -752,4 +752,5 @@ object Iterable extends IterableFactory.Delegate[Iterable](immutable.Iterable) {
   implicit def toLazyZipOps[A, CC[X] <: Iterable[X]](that: CC[A]): LazyZipOps[A, CC[A]] = new LazyZipOps(that)
 }
 
+/** Explicit instantiation of the `Iterable` trait to reduce class file size in subclasses. */
 abstract class AbstractIterable[+A] extends Iterable[A]

src/library/scala/collection/LazyZipOps.scala

@@ -38,7 +38,7 @@ final class LazyZip2[El1, El2, C1 <: Iterable[El1]] private[collection](coll1: C
   def lazyZip[B](that: Iterable[B]): LazyZip3[El1, El2, B, C1] = new LazyZip3(coll1, coll2, that)
 
   def map[B, C](f: (El1, El2) => B)(implicit bf: BuildFrom[C1, B, C]): C = {
-    bf.fromSpecificIterable(coll1)(new View[B] {
+    bf.fromSpecificIterable(coll1)(new AbstractView[B] {
       def iterator() = new Iterator[B] {
         private val elems1 = coll1.iterator()
         private val elems2 = coll2.iterator()
@@ -50,7 +50,7 @@ final class LazyZip2[El1, El2, C1 <: Iterable[El1]] private[collection](coll1: C
   }
 
   def flatMap[B, C](f: (El1, El2) => Iterable[B])(implicit bf: BuildFrom[C1, B, C]): C = {
-    bf.fromSpecificIterable(coll1)(new View[B] {
+    bf.fromSpecificIterable(coll1)(new AbstractView[B] {
       def iterator() = new Iterator[B] {
         private val elems1 = coll1.iterator()
         private val elems2 = coll2.iterator()
@@ -67,7 +67,7 @@ final class LazyZip2[El1, El2, C1 <: Iterable[El1]] private[collection](coll1: C
   }
 
   def filter[C](p: (El1, El2) => Boolean)(implicit bf: BuildFrom[C1, (El1, El2), C]): C = {
-    bf.fromSpecificIterable(coll1)(new View[(El1, El2)] {
+    bf.fromSpecificIterable(coll1)(new AbstractView[(El1, El2)] {
       def iterator() = new Iterator[(El1, El2)] {
         private val elems1 = coll1.iterator()
         private val elems2 = coll2.iterator()
@@ -111,7 +111,7 @@ final class LazyZip2[El1, El2, C1 <: Iterable[El1]] private[collection](coll1: C
     while (elems1.hasNext && elems2.hasNext) f(elems1.next(), elems2.next())
   }
 
-  private def toIterable = new View[(El1, El2)] {
+  private def toIterable: View[(El1, El2)] = new AbstractView[(El1, El2)] {
     def iterator() = new Iterator[(El1, El2)] {
       private val elems1 = coll1.iterator()
       private val elems2 = coll2.iterator()
@@ -145,7 +145,7 @@ final class LazyZip3[El1, El2, El3, C1 <: Iterable[El1]] private[collection](col
   def lazyZip[B](that: Iterable[B]): LazyZip4[El1, El2, El3, B, C1] = new LazyZip4(coll1, coll2, coll3, that)
 
   def map[B, C](f: (El1, El2, El3) => B)(implicit bf: BuildFrom[C1, B, C]): C = {
-    bf.fromSpecificIterable(coll1)(new View[B] {
+    bf.fromSpecificIterable(coll1)(new AbstractView[B] {
       def iterator() = new Iterator[B] {
         private val elems1 = coll1.iterator()
         private val elems2 = coll2.iterator()
@@ -158,7 +158,7 @@ final class LazyZip3[El1, El2, El3, C1 <: Iterable[El1]] private[collection](col
   }
 
   def flatMap[B, C](f: (El1, El2, El3) => Iterable[B])(implicit bf: BuildFrom[C1, B, C]): C = {
-    bf.fromSpecificIterable(coll1)(new View[B] {
+    bf.fromSpecificIterable(coll1)(new AbstractView[B] {
       def iterator() = new Iterator[B] {
         private val elems1 = coll1.iterator()
         private val elems2 = coll2.iterator()
@@ -176,7 +176,7 @@ final class LazyZip3[El1, El2, El3, C1 <: Iterable[El1]] private[collection](col
   }
 
   def filter[C](p: (El1, El2, El3) => Boolean)(implicit bf: BuildFrom[C1, (El1, El2, El3), C]): C = {
-    bf.fromSpecificIterable(coll1)(new View[(El1, El2, El3)] {
+    bf.fromSpecificIterable(coll1)(new AbstractView[(El1, El2, El3)] {
       def iterator() = new Iterator[(El1, El2, El3)] {
         private val elems1 = coll1.iterator()
         private val elems2 = coll2.iterator()
@@ -226,7 +226,7 @@ final class LazyZip3[El1, El2, El3, C1 <: Iterable[El1]] private[collection](col
       f(elems1.next(), elems2.next(), elems3.next())
   }
 
-  private def toIterable = new View[(El1, El2, El3)] {
+  private def toIterable: View[(El1, El2, El3)] = new AbstractView[(El1, El2, El3)] {
     def iterator() = new Iterator[(El1, El2, El3)] {
       private val elems1 = coll1.iterator()
       private val elems2 = coll2.iterator()
@@ -253,7 +253,7 @@ final class LazyZip4[El1, El2, El3, El4, C1 <: Iterable[El1]] private[collection
                                                                                   coll4: Iterable[El4]) {
 
   def map[B, C](f: (El1, El2, El3, El4) => B)(implicit bf: BuildFrom[C1, B, C]): C = {
-    bf.fromSpecificIterable(coll1)(new View[B] {
+    bf.fromSpecificIterable(coll1)(new AbstractView[B] {
       def iterator() = new Iterator[B] {
         private val elems1 = coll1.iterator()
         private val elems2 = coll2.iterator()
@@ -267,7 +267,7 @@ final class LazyZip4[El1, El2, El3, El4, C1 <: Iterable[El1]] private[collection
   }
 
   def flatMap[B, C](f: (El1, El2, El3, El4) => Iterable[B])(implicit bf: BuildFrom[C1, B, C]): C = {
-    bf.fromSpecificIterable(coll1)(new View[B] {
+    bf.fromSpecificIterable(coll1)(new AbstractView[B] {
       def iterator() = new Iterator[B] {
         private val elems1 = coll1.iterator()
         private val elems2 = coll2.iterator()
@@ -286,7 +286,7 @@ final class LazyZip4[El1, El2, El3, El4, C1 <: Iterable[El1]] private[collection
   }
 
   def filter[C](p: (El1, El2, El3, El4) => Boolean)(implicit bf: BuildFrom[C1, (El1, El2, El3, El4), C]): C = {
-    bf.fromSpecificIterable(coll1)(new View[(El1, El2, El3, El4)] {
+    bf.fromSpecificIterable(coll1)(new AbstractView[(El1, El2, El3, El4)] {
       def iterator() = new Iterator[(El1, El2, El3, El4)] {
         private val elems1 = coll1.iterator()
         private val elems2 = coll2.iterator()
@@ -340,7 +340,7 @@ final class LazyZip4[El1, El2, El3, El4, C1 <: Iterable[El1]] private[collection
       f(elems1.next(), elems2.next(), elems3.next(), elems4.next())
   }
 
-  private def toIterable = new View[(El1, El2, El3, El4)] {
+  private def toIterable: View[(El1, El2, El3, El4)] = new AbstractView[(El1, El2, El3, El4)] {
     def iterator() = new Iterator[(El1, El2, El3, El4)] {
       private val elems1 = coll1.iterator()
       private val elems2 = coll2.iterator()

src/library/scala/collection/Map.scala

@@ -133,7 +133,7 @@ trait MapOps[K, +V, +CC[_, _] <: IterableOps[_, AnyConstr, _], +C]
   /** The implementation class of the set returned by `keySet`.
     */
   @SerialVersionUID(3L)
-  protected class KeySet extends Set[K] with GenKeySet {
+  protected class KeySet extends AbstractSet[K] with GenKeySet {
     def diff(that: Set[K]): Set[K] = fromSpecificIterable(view.filterNot(that))
   }
 
@@ -315,4 +315,4 @@ object Map extends MapFactory.Delegate[Map](immutable.Map) {
 }
 
 /** Explicit instantiation of the `Map` trait to reduce class file size in subclasses. */
-abstract class AbstractMap[A, +B] extends AbstractIterable[(A, B)] with Map[A, B]
+abstract class AbstractMap[K, +V] extends AbstractIterable[(K, V)] with Map[K, V]

src/library/scala/collection/MapView.scala

@@ -27,21 +27,23 @@ object MapView {
   /** A `MapOps` whose collection type and collection type constructor are (mostly) unknown */
   type SomeMapOps[K, +V] = MapOps[K, V, SomeIterableConstr, _]
 
-  class Id[K, +V](underlying: SomeMapOps[K, V]) extends MapView[K, V] {
+  class Id[K, +V](underlying: SomeMapOps[K, V]) extends AbstractMapView[K, V] {
     def get(key: K): Option[V] = underlying.get(key)
     def iterator(): Iterator[(K, V)] = underlying.iterator()
     override def knownSize: Int = underlying.knownSize
   }
 
-  class MapValues[K, +V, +W](underlying: SomeMapOps[K, V], f: V => W) extends MapView[K, W] {
+  class MapValues[K, +V, +W](underlying: SomeMapOps[K, V], f: V => W) extends AbstractMapView[K, W] {
     def iterator(): Iterator[(K, W)] = underlying.iterator().map(kv => (kv._1, f(kv._2)))
     def get(key: K): Option[W] = underlying.get(key).map(f)
     override def knownSize: Int = underlying.knownSize
   }
 
-  class FilterKeys[K, +V](underlying: SomeMapOps[K, V], p: K => Boolean) extends MapView[K, V] {
+  class FilterKeys[K, +V](underlying: SomeMapOps[K, V], p: K => Boolean) extends AbstractMapView[K, V] {
     def iterator(): Iterator[(K, V)] = underlying.iterator().filter { case (k, _) => p(k) }
     def get(key: K): Option[V] = if (p(key)) underlying.get(key) else None
   }
-
 }
+
+/** Explicit instantiation of the `MapView` trait to reduce class file size in subclasses. */
+abstract class AbstractMapView[K, +V] extends AbstractView[(K, V)] with MapView[K, V]

src/library/scala/collection/Seq.scala

@@ -84,7 +84,7 @@ trait SeqOps[+A, +CC[_], +C] extends Any
   /**
     * @return This collection as a `Seq[A]`. This is equivalent to `to(Seq)` but might be faster.
     */
-  def toSeq: Seq[A]
+  def toSeq: immutable.Seq[A]
 
   /** A copy of the $coll with an element prepended.
     *
@@ -939,18 +939,18 @@ object SeqOps {
     case iso: IndexedSeq[B] =>
       // Already optimized for indexing--use original (or custom view of original)
       if (forward && n0==0 && n1==W.length) iso.view
-      else if (forward) new IndexedView[B] {
+      else if (forward) new AbstractIndexedView[B] {
         val length = n1 - n0
         def apply(x: Int) = iso(n0 + x)
       }
-      else new IndexedView[B] {
+      else new AbstractIndexedView[B] {
         def length = n1 - n0
         def apply(x: Int) = iso(n1 - 1 - x)
       }
     case _ =>
       // W is probably bad at indexing.  Pack in array (in correct orientation)
       // Would be marginally faster to special-case each direction
-      new IndexedView[B] {
+      new AbstractIndexedView[B] {
         private[this] val Warr = new Array[AnyRef](n1-n0)
         private[this] val delta = if (forward) 1 else -1
         private[this] val done = if (forward) n1-n0 else -1

src/library/scala/collection/SeqView.scala

@@ -20,7 +20,7 @@ object SeqView {
   type SomeSeqOps[+A] = SeqOps[A, AnyConstr, _]
 
   /** A view that doesn’t apply any transformation to an underlying sequence */
-  class Id[+A](underlying: SeqOps[A, AnyConstr, _]) extends SeqView[A] {
+  class Id[+A](underlying: SeqOps[A, AnyConstr, _]) extends AbstractSeqView[A] {
     def apply(idx: Int): A = underlying.apply(idx)
     def length: Int = underlying.length
     def iterator(): Iterator[A] = underlying.iterator()
@@ -41,5 +41,7 @@ object SeqView {
     def apply(idx: Int): A = if (idx < n) underlying(idx) else throw new IndexOutOfBoundsException(idx.toString)
     def length: Int = underlying.length min normN
   }
-
 }
+
+/** Explicit instantiation of the `SeqView` trait to reduce class file size in subclasses. */
+abstract class AbstractSeqView[+A] extends AbstractView[A] with SeqView[A]

src/library/scala/collection/Set.scala

@@ -49,7 +49,8 @@ trait SetOps[A, +CC[_], +C <: SetOps[A, CC, C]]
     *  @param elem the element to test for membership.
     *  @return  `true` if `elem` is contained in this set, `false` otherwise.
     */
-  @`inline` final def apply(elem: A): Boolean = this.contains(elem)
+  @deprecatedOverriding("This method should be final, but is not due to scala/bug#10853", "2.13.0")
+  /*@`inline` final*/ def apply(elem: A): Boolean = this.contains(elem)
 
   /** Tests whether this set is a subset of another set.
     *
@@ -199,3 +200,6 @@ trait SetOps[A, +CC[_], +C <: SetOps[A, CC, C]]
   * @define Coll `Set`
   */
 object Set extends IterableFactory.Delegate[Set](immutable.Set)
+
+/** Explicit instantiation of the `Set` trait to reduce class file size in subclasses. */
+abstract class AbstractSet[A] extends AbstractIterable[A] with Set[A]