Merge all VC prototypes into single file

10 files changed, 474 insertions, 540 deletions

diff --git a/src/dotty/runtime/vc/VCBooleanPrototype.scala b/src/dotty/runtime/vc/VCBooleanPrototype.scala
deleted file mode 100644
index 9c90fb304..000000000
--- a/src/dotty/runtime/vc/VCBooleanPrototype.scala
+++ /dev/null
@@ -1,60 +0,0 @@
-package dotty.runtime.vc
-
-import scala.reflect.ClassTag
-
-import scala.runtime.Statics
-
-abstract class VCBooleanPrototype(val underlying: Boolean) extends VCPrototype {}
-
-abstract class VCBooleanCasePrototype(underlying: Boolean) extends VCBooleanPrototype(underlying) with Product1[Boolean] {
-
-  final def _1: Boolean = underlying
-
-  override final def hashCode(): Int = {
-    underlying.hashCode()
-  }
-
-  override final def toString: String = {
-    s"$productPrefix($underlying)"
-  }
-
-  // subclasses are expected to implement equals, productPrefix, and canEqual
-}
-
-abstract class VCBooleanCompanion[T <: VCBooleanPrototype] extends ClassTag[T] {
-  def box(underlying: Boolean): T
-  final def unbox(boxed: T) = boxed.underlying
-
-  implicit def classTag: this.type = this
-  override def newArray(len: Int): Array[T] =
-    new VCBooleanArray(this, len).asInstanceOf[Array[T]]
-
-
-  final def _1$extension(underlying: Boolean)       = underlying
-  final def hashCode$extension(underlying: Boolean) = underlying.hashCode()
-  final def toString$extension(underlying: Boolean) = s"${productPrefix$extension(underlying)}($underlying)"
-  def productPrefix$extension(underlying: Boolean): String
-}
-
-final class VCBooleanArray[T <: VCBooleanPrototype] private (val arr: Array[Boolean], val ct: VCBooleanCompanion[T])
-  extends VCArrayPrototype[T] {
-  def this(ct: VCBooleanCompanion[T], sz: Int) =
-    this(new Array[Boolean](sz), ct)
-
-  def apply(idx: Int) =
-    ct.box(arr(idx))
-  def update(idx: Int, elem: T) =
-    arr(idx) = ct.unbox(elem)
-  def length: Int = arr.length
-
-  override def clone(): VCBooleanArray[T] = {
-    new VCBooleanArray[T](arr.clone(), ct)
-  }
-
-  override def toString: String = {
-    "[" + ct.runtimeClass
-  }
-
-  // Todo: what was the reason for 255 classes in my original proposal? arr.toString!
-  // todo: need to discuss do we want to be compatible with ugly format of jvm here?
-}
diff --git a/src/dotty/runtime/vc/VCBytePrototype.scala b/src/dotty/runtime/vc/VCBytePrototype.scala
deleted file mode 100644
index a8a24dab0..000000000
--- a/src/dotty/runtime/vc/VCBytePrototype.scala
+++ /dev/null
@@ -1,60 +0,0 @@
-package dotty.runtime.vc
-
-import scala.reflect.ClassTag
-
-import scala.runtime.Statics
-
-abstract class VCBytePrototype(val underlying: Byte) extends VCPrototype {}
-
-abstract class VCByteCasePrototype(underlying: Byte) extends VCBytePrototype(underlying) with Product1[Byte] {
-
-  final def _1: Byte = underlying
-
-  override final def hashCode(): Int = {
-    underlying.hashCode()
-  }
-
-  override final def toString: String = {
-    s"$productPrefix($underlying)"
-  }
-
-  // subclasses are expected to implement equals, productPrefix, and canEqual
-}
-
-abstract class VCByteCompanion[T <: VCBytePrototype] extends ClassTag[T] {
-  def box(underlying: Byte): T
-  final def unbox(boxed: T) = boxed.underlying
-
-  implicit def classTag: this.type = this
-  override def newArray(len: Int): Array[T] =
-    new VCByteArray(this, len).asInstanceOf[Array[T]]
-
-
-  final def _1$extension(underlying: Byte)       = underlying
-  final def hashCode$extension(underlying: Byte) = underlying.hashCode()
-  final def toString$extension(underlying: Byte) = s"${productPrefix$extension(underlying)}($underlying)"
-  def productPrefix$extension(underlying: Byte): String
-}
-
-final class VCByteArray[T <: VCBytePrototype] private (val arr: Array[Byte], val ct: VCByteCompanion[T])
-  extends VCArrayPrototype[T] {
-  def this(ct: VCByteCompanion[T], sz: Int) =
-    this(new Array[Byte](sz), ct)
-
-  def apply(idx: Int) =
-    ct.box(arr(idx))
-  def update(idx: Int, elem: T) =
-    arr(idx) = ct.unbox(elem)
-  def length: Int = arr.length
-
-  override def clone(): VCByteArray[T] = {
-    new VCByteArray[T](arr.clone(), ct)
-  }
-
-  override def toString: String = {
-    "[" + ct.runtimeClass
-  }
-
-  // Todo: what was the reason for 255 classes in my original proposal? arr.toString!
-  // todo: need to discuss do we want to be compatible with ugly format of jvm here?
-}
diff --git a/src/dotty/runtime/vc/VCCharPrototype.scala b/src/dotty/runtime/vc/VCCharPrototype.scala
deleted file mode 100644
index 796821f56..000000000
--- a/src/dotty/runtime/vc/VCCharPrototype.scala
+++ /dev/null
@@ -1,60 +0,0 @@
-package dotty.runtime.vc
-
-import scala.reflect.ClassTag
-
-import scala.runtime.Statics
-
-abstract class VCCharPrototype(val underlying: Char) extends VCPrototype {}
-
-abstract class VCCharCasePrototype(underlying: Char) extends VCCharPrototype(underlying) with Product1[Char] {
-
-  final def _1: Char = underlying
-
-  override final def hashCode(): Int = {
-    underlying.hashCode()
-  }
-
-  override final def toString: String = {
-    s"$productPrefix($underlying)"
-  }
-
-  // subclasses are expected to implement equals, productPrefix, and canEqual
-}
-
-abstract class VCCharCompanion[T <: VCCharPrototype] extends ClassTag[T] {
-  def box(underlying: Char): T
-  final def unbox(boxed: T) = boxed.underlying
-
-  implicit def classTag: this.type = this
-  override def newArray(len: Int): Array[T] =
-    new VCCharArray(this, len).asInstanceOf[Array[T]]
-
-
-  final def _1$extension(underlying: Char)       = underlying
-  final def hashCode$extension(underlying: Char) = underlying.hashCode()
-  final def toString$extension(underlying: Char) = s"${productPrefix$extension(underlying)}($underlying)"
-  def productPrefix$extension(underlying: Char): String
-}
-
-final class VCCharArray[T <: VCCharPrototype] private (val arr: Array[Char], val ct: VCCharCompanion[T])
-  extends VCArrayPrototype[T] {
-  def this(ct: VCCharCompanion[T], sz: Int) =
-    this(new Array[Char](sz), ct)
-
-  def apply(idx: Int) =
-    ct.box(arr(idx))
-  def update(idx: Int, elem: T) =
-    arr(idx) = ct.unbox(elem)
-  def length: Int = arr.length
-
-  override def clone(): VCCharArray[T] = {
-    new VCCharArray[T](arr.clone(), ct)
-  }
-
-  override def toString: String = {
-    "[" + ct.runtimeClass
-  }
-
-  // Todo: what was the reason for 255 classes in my original proposal? arr.toString!
-  // todo: need to discuss do we want to be compatible with ugly format of jvm here?
-}
diff --git a/src/dotty/runtime/vc/VCDoublePrototype.scala b/src/dotty/runtime/vc/VCDoublePrototype.scala
deleted file mode 100644
index 2a3f90f07..000000000
--- a/src/dotty/runtime/vc/VCDoublePrototype.scala
+++ /dev/null
@@ -1,60 +0,0 @@
-package dotty.runtime.vc
-
-import scala.reflect.ClassTag
-
-import scala.runtime.Statics
-
-abstract class VCDoublePrototype(val underlying: Double) extends VCPrototype {}
-
-abstract class VCDoubleCasePrototype(underlying: Double) extends VCDoublePrototype(underlying) with Product1[Double] {
-
-  final def _1: Double = underlying
-
-  override final def hashCode(): Int = {
-    underlying.hashCode()
-  }
-
-  override final def toString: String = {
-    s"$productPrefix($underlying)"
-  }
-
-  // subclasses are expected to implement equals, productPrefix, and canEqual
-}
-
-abstract class VCDoubleCompanion[T <: VCDoublePrototype] extends ClassTag[T] {
-  def box(underlying: Double): T
-  final def unbox(boxed: T) = boxed.underlying
-
-  implicit def classTag: this.type = this
-  override def newArray(len: Int): Array[T] =
-    new VCDoubleArray(this, len).asInstanceOf[Array[T]]
-
-
-  final def _1$extension(underlying: Double)       = underlying
-  final def hashCode$extension(underlying: Double) = underlying.hashCode()
-  final def toString$extension(underlying: Double) = s"${productPrefix$extension(underlying)}($underlying)"
-  def productPrefix$extension(underlying: Double): String
-}
-
-final class VCDoubleArray[T <: VCDoublePrototype] private (val arr: Array[Double], val ct: VCDoubleCompanion[T])
-  extends VCArrayPrototype[T] {
-  def this(ct: VCDoubleCompanion[T], sz: Int) =
-    this(new Array[Double](sz), ct)
-
-  def apply(idx: Int) =
-    ct.box(arr(idx))
-  def update(idx: Int, elem: T) =
-    arr(idx) = ct.unbox(elem)
-  def length: Int = arr.length
-
-  override def clone(): VCDoubleArray[T] = {
-    new VCDoubleArray[T](arr.clone(), ct)
-  }
-
-  override def toString: String = {
-    "[" + ct.runtimeClass
-  }
-
-  // Todo: what was the reason for 255 classes in my original proposal? arr.toString!
-  // todo: need to discuss do we want to be compatible with ugly format of jvm here?
-}
diff --git a/src/dotty/runtime/vc/VCFloatPrototype.scala b/src/dotty/runtime/vc/VCFloatPrototype.scala
deleted file mode 100644
index c3e110110..000000000
--- a/src/dotty/runtime/vc/VCFloatPrototype.scala
+++ /dev/null
@@ -1,60 +0,0 @@
-package dotty.runtime.vc
-
-import scala.reflect.ClassTag
-
-import scala.runtime.Statics
-
-abstract class VCFloatPrototype(val underlying: Float) extends VCPrototype {}
-
-abstract class VCFloatCasePrototype(underlying: Float) extends VCFloatPrototype(underlying) with Product1[Float] {
-
-  final def _1: Float = underlying
-
-  override final def hashCode(): Int = {
-    underlying.hashCode()
-  }
-
-  override final def toString: String = {
-    s"$productPrefix($underlying)"
-  }
-
-  // subclasses are expected to implement equals, productPrefix, and canEqual
-}
-
-abstract class VCFloatCompanion[T <: VCFloatPrototype] extends ClassTag[T] {
-  def box(underlying: Float): T
-  final def unbox(boxed: T) = boxed.underlying
-
-  implicit def classTag: this.type = this
-  override def newArray(len: Int): Array[T] =
-    new VCFloatArray(this, len).asInstanceOf[Array[T]]
-
-
-  final def _1$extension(underlying: Float)       = underlying
-  final def hashCode$extension(underlying: Float) = underlying.hashCode()
-  final def toString$extension(underlying: Float) = s"${productPrefix$extension(underlying)}($underlying)"
-  def productPrefix$extension(underlying: Float): String
-}
-
-final class VCFloatArray[T <: VCFloatPrototype] private (val arr: Array[Float], val ct: VCFloatCompanion[T])
-  extends VCArrayPrototype[T] {
-  def this(ct: VCFloatCompanion[T], sz: Int) =
-    this(new Array[Float](sz), ct)
-
-  def apply(idx: Int) =
-    ct.box(arr(idx))
-  def update(idx: Int, elem: T) =
-    arr(idx) = ct.unbox(elem)
-  def length: Int = arr.length
-
-  override def clone(): VCFloatArray[T] = {
-    new VCFloatArray[T](arr.clone(), ct)
-  }
-
-  override def toString: String = {
-    "[" + ct.runtimeClass
-  }
-
-  // Todo: what was the reason for 255 classes in my original proposal? arr.toString!
-  // todo: need to discuss do we want to be compatible with ugly format of jvm here?
-}
diff --git a/src/dotty/runtime/vc/VCIntPrototype.scala b/src/dotty/runtime/vc/VCIntPrototype.scala
deleted file mode 100644
index 44f746ed4..000000000
--- a/src/dotty/runtime/vc/VCIntPrototype.scala
+++ /dev/null
@@ -1,60 +0,0 @@
-package dotty.runtime.vc
-
-import scala.reflect.ClassTag
-
-import scala.runtime.Statics
-
-abstract class VCIntPrototype(val underlying: Int) extends VCPrototype {}
-
-abstract class VCIntCasePrototype(underlying: Int) extends VCIntPrototype(underlying) with Product1[Int] {
-
-  final def _1: Int = underlying
-
-  override final def hashCode(): Int = {
-    underlying.hashCode()
-  }
-
-  override final def toString: String = {
-    s"$productPrefix($underlying)"
-  }
-
-  // subclasses are expected to implement equals, productPrefix, and canEqual
-}
-
-abstract class VCIntCompanion[T <: VCIntPrototype] extends ClassTag[T] {
-  def box(underlying: Int): T
-  final def unbox(boxed: T) = boxed.underlying
-
-  implicit def classTag: this.type = this
-  override def newArray(len: Int): Array[T] =
-    new VCIntArray(this, len).asInstanceOf[Array[T]]
-
-
-  final def _1$extension(underlying: Int)       = underlying
-  final def hashCode$extension(underlying: Int) = underlying.hashCode()
-  final def toString$extension(underlying: Int) = s"${productPrefix$extension(underlying)}($underlying)"
-  def productPrefix$extension(underlying: Int): String
-}
-
-final class VCIntArray[T <: VCIntPrototype] private (val arr: Array[Int], val ct: VCIntCompanion[T])
-  extends VCArrayPrototype[T] {
-  def this(ct: VCIntCompanion[T], sz: Int) =
-    this(new Array[Int](sz), ct)
-
-  def apply(idx: Int) =
-    ct.box(arr(idx))
-  def update(idx: Int, elem: T) =
-    arr(idx) = ct.unbox(elem)
-  def length: Int = arr.length
-
-  override def clone(): VCIntArray[T] = {
-    new VCIntArray[T](arr.clone(), ct)
-  }
-
-  override def toString: String = {
-    "[" + ct.runtimeClass
-  }
-
-  // Todo: what was the reason for 255 classes in my original proposal? arr.toString!
-  // todo: need to discuss do we want to be compatible with ugly format of jvm here?
-}
diff --git a/src/dotty/runtime/vc/VCLongPrototype.scala b/src/dotty/runtime/vc/VCLongPrototype.scala
deleted file mode 100644
index 83690bcfd..000000000
--- a/src/dotty/runtime/vc/VCLongPrototype.scala
+++ /dev/null
@@ -1,60 +0,0 @@
-package dotty.runtime.vc
-
-import scala.reflect.ClassTag
-
-import scala.runtime.Statics
-
-abstract class VCLongPrototype(val underlying: Long) extends VCPrototype {}
-
-abstract class VCLongCasePrototype(underlying: Long) extends VCLongPrototype(underlying) with Product1[Long] {
-
-  final def _1: Long = underlying
-
-  override final def hashCode(): Int = {
-    underlying.hashCode()
-  }
-
-  override final def toString: String = {
-    s"$productPrefix($underlying)"
-  }
-
-  // subclasses are expected to implement equals, productPrefix, and canEqual
-}
-
-abstract class VCLongCompanion[T <: VCLongPrototype] extends ClassTag[T] {
-  def box(underlying: Long): T
-  final def unbox(boxed: T) = boxed.underlying
-
-  implicit def classTag: this.type = this
-  override def newArray(len: Int): Array[T] =
-    new VCLongArray(this, len).asInstanceOf[Array[T]]
-
-
-  final def _1$extension(underlying: Long)       = underlying
-  final def hashCode$extension(underlying: Long) = underlying.hashCode()
-  final def toString$extension(underlying: Long) = s"${productPrefix$extension(underlying)}($underlying)"
-  def productPrefix$extension(underlying: Long): String
-}
-
-final class VCLongArray[T <: VCLongPrototype] private (val arr: Array[Long], val ct: VCLongCompanion[T])
-  extends VCArrayPrototype[T] {
-  def this(ct: VCLongCompanion[T], sz: Int) =
-    this(new Array[Long](sz), ct)
-
-  def apply(idx: Int) =
-    ct.box(arr(idx))
-  def update(idx: Int, elem: T) =
-    arr(idx) = ct.unbox(elem)
-  def length: Int = arr.length
-
-  override def clone(): VCLongArray[T] = {
-    new VCLongArray[T](arr.clone(), ct)
-  }
-
-  override def toString: String = {
-    "[" + ct.runtimeClass
-  }
-
-  // Todo: what was the reason for 255 classes in my original proposal? arr.toString!
-  // todo: need to discuss do we want to be compatible with ugly format of jvm here?
-}
diff --git a/src/dotty/runtime/vc/VCObjectPrototype.scala b/src/dotty/runtime/vc/VCObjectPrototype.scala
deleted file mode 100644
index fd0c8728a..000000000
--- a/src/dotty/runtime/vc/VCObjectPrototype.scala
+++ /dev/null
@@ -1,60 +0,0 @@
-package dotty.runtime.vc
-
-import scala.reflect.ClassTag
-
-import scala.runtime.Statics
-
-abstract class VCObjectPrototype(val underlying: Object) extends VCPrototype {}
-
-abstract class VCObjectCasePrototype(underlying: Object) extends VCObjectPrototype(underlying) with Product1[Object] {
-
-  final def _1: Object = underlying
-
-  override final def hashCode(): Int = {
-    underlying.hashCode()
-  }
-
-  override final def toString: String = {
-    s"$productPrefix($underlying)"
-  }
-
-  // subclasses are expected to implement equals, productPrefix, and canEqual
-}
-
-abstract class VCObjectCompanion[T <: VCObjectPrototype] extends ClassTag[T] {
-  def box(underlying: Object): T
-  final def unbox(boxed: T) = boxed.underlying
-
-  implicit def classTag: this.type = this
-  override def newArray(len: Int): Array[T] =
-    new VCObjectArray(this, len).asInstanceOf[Array[T]]
-
-
-  final def _1$extension(underlying: Object)       = underlying
-  final def hashCode$extension(underlying: Object) = underlying.hashCode()
-  final def toString$extension(underlying: Object) = s"${productPrefix$extension(underlying)}($underlying)"
-  def productPrefix$extension(underlying: Object): String
-}
-
-final class VCObjectArray[T <: VCObjectPrototype] private (val arr: Array[Object], val ct: VCObjectCompanion[T])
-  extends VCArrayPrototype[T] {
-  def this(ct: VCObjectCompanion[T], sz: Int) =
-    this(new Array[Object](sz), ct)
-
-  def apply(idx: Int) =
-    ct.box(arr(idx))
-  def update(idx: Int, elem: T) =
-    arr(idx) = ct.unbox(elem)
-  def length: Int = arr.length
-
-  override def clone(): VCObjectArray[T] = {
-    new VCObjectArray[T](arr.clone(), ct)
-  }
-
-  override def toString: String = {
-    "[" + ct.runtimeClass
-  }
-
-  // Todo: what was the reason for 255 classes in my original proposal? arr.toString!
-  // todo: need to discuss do we want to be compatible with ugly format of jvm here?
-}
diff --git a/src/dotty/runtime/vc/VCPrototype.scala b/src/dotty/runtime/vc/VCPrototype.scala
index 61ed93b92..0a3abe5a2 100644
--- a/src/dotty/runtime/vc/VCPrototype.scala
+++ b/src/dotty/runtime/vc/VCPrototype.scala
@@ -1,5 +1,7 @@
 package dotty.runtime.vc
 
+import scala.reflect.ClassTag
+
 abstract class VCPrototype {
 }
 
@@ -10,3 +12,475 @@ abstract class VCArrayPrototype[T <: VCPrototype] extends Object with Cloneable
   def length: Int
   override def clone: Object = super.clone()
 }
+
+
+abstract class VCFloatPrototype(val underlying: Float) extends VCPrototype {}
+
+abstract class VCFloatCasePrototype(underlying: Float) extends VCFloatPrototype(underlying) with Product1[Float] {
+
+  final def _1: Float = underlying
+
+  override final def hashCode(): Int = {
+    underlying.hashCode()
+  }
+
+  override final def toString: String = {
+    s"$productPrefix($underlying)"
+  }
+}
+
+abstract class VCFloatCompanion[T <: VCFloatPrototype] extends ClassTag[T] {
+  def box(underlying: Float): T
+  final def unbox(boxed: T) = boxed.underlying
+
+  implicit def classTag: this.type = this
+  override def newArray(len: Int): Array[T] =
+    new VCFloatArray(this, len).asInstanceOf[Array[T]]
+
+
+  final def _1$extension(underlying: Float)       = underlying
+  final def hashCode$extension(underlying: Float) = underlying.hashCode()
+  final def toString$extension(underlying: Float) = s"${productPrefix$extension(underlying)}($underlying)"
+  def productPrefix$extension(underlying: Float): String
+}
+
+final class VCFloatArray[T <: VCFloatPrototype] private (val arr: Array[Float], val ct: VCFloatCompanion[T])
+  extends VCArrayPrototype[T] {
+  def this(ct: VCFloatCompanion[T], sz: Int) =
+    this(new Array[Float](sz), ct)
+
+  def apply(idx: Int) =
+    ct.box(arr(idx))
+  def update(idx: Int, elem: T) =
+    arr(idx) = ct.unbox(elem)
+  def length: Int = arr.length
+
+  override def clone(): VCFloatArray[T] = {
+    new VCFloatArray[T](arr.clone(), ct)
+  }
+
+  override def toString: String = {
+    "[" + ct.runtimeClass
+  }
+}
+
+
+abstract class VCObjectPrototype(val underlying: Object) extends VCPrototype {}
+
+abstract class VCObjectCasePrototype(underlying: Object) extends VCObjectPrototype(underlying) with Product1[Object] {
+
+  final def _1: Object = underlying
+
+  override final def hashCode(): Int = {
+    underlying.hashCode()
+  }
+
+  override final def toString: String = {
+    s"$productPrefix($underlying)"
+  }
+}
+
+abstract class VCObjectCompanion[T <: VCObjectPrototype] extends ClassTag[T] {
+  def box(underlying: Object): T
+  final def unbox(boxed: T) = boxed.underlying
+
+  implicit def classTag: this.type = this
+  override def newArray(len: Int): Array[T] =
+    new VCObjectArray(this, len).asInstanceOf[Array[T]]
+
+
+  final def _1$extension(underlying: Object)       = underlying
+  final def hashCode$extension(underlying: Object) = underlying.hashCode()
+  final def toString$extension(underlying: Object) = s"${productPrefix$extension(underlying)}($underlying)"
+  def productPrefix$extension(underlying: Object): String
+}
+
+final class VCObjectArray[T <: VCObjectPrototype] private (val arr: Array[Object], val ct: VCObjectCompanion[T])
+  extends VCArrayPrototype[T] {
+  def this(ct: VCObjectCompanion[T], sz: Int) =
+    this(new Array[Object](sz), ct)
+
+  def apply(idx: Int) =
+    ct.box(arr(idx))
+
+  def update(idx: Int, elem: T) =
+    arr(idx) = ct.unbox(elem)
+
+  def length: Int = arr.length
+
+  override def clone(): VCObjectArray[T] = {
+    new VCObjectArray[T](arr.clone(), ct)
+  }
+
+  override def toString: String = {
+    "[" + ct.runtimeClass
+  }
+}
+
+
+abstract class VCShortPrototype(val underlying: Short) extends VCPrototype {}
+
+abstract class VCShortCasePrototype(underlying: Short) extends VCShortPrototype(underlying) with Product1[Short] {
+
+  final def _1: Short = underlying
+
+  override final def hashCode(): Int = {
+    underlying.hashCode()
+  }
+
+  override final def toString: String = {
+    s"$productPrefix($underlying)"
+  }
+}
+
+abstract class VCShortCompanion[T <: VCShortPrototype] extends ClassTag[T] {
+  def box(underlying: Short): T
+  final def unbox(boxed: T) = boxed.underlying
+
+  implicit def classTag: this.type = this
+  override def newArray(len: Int): Array[T] =
+    new VCShortArray(this, len).asInstanceOf[Array[T]]
+
+
+  final def _1$extension(underlying: Short)       = underlying
+  final def hashCode$extension(underlying: Short) = underlying.hashCode()
+  final def toString$extension(underlying: Short) = s"${productPrefix$extension(underlying)}($underlying)"
+  def productPrefix$extension(underlying: Short): String
+}
+
+final class VCShortArray[T <: VCShortPrototype] private (val arr: Array[Short], val ct: VCShortCompanion[T])
+  extends VCArrayPrototype[T] {
+  def this(ct: VCShortCompanion[T], sz: Int) =
+    this(new Array[Short](sz), ct)
+
+  def apply(idx: Int) =
+    ct.box(arr(idx))
+
+  def update(idx: Int, elem: T) =
+    arr(idx) = ct.unbox(elem)
+
+  def length: Int = arr.length
+
+  override def clone(): VCShortArray[T] = {
+    new VCShortArray[T](arr.clone(), ct)
+  }
+
+  override def toString: String = {
+    "[" + ct.runtimeClass
+  }
+
+}
+
+
+abstract class VCLongPrototype(val underlying: Long) extends VCPrototype {}
+
+abstract class VCLongCasePrototype(underlying: Long) extends VCLongPrototype(underlying) with Product1[Long] {
+
+  final def _1: Long = underlying
+
+  override final def hashCode(): Int = {
+    underlying.hashCode()
+  }
+
+  override final def toString: String = {
+    s"$productPrefix($underlying)"
+  }
+}
+
+abstract class VCLongCompanion[T <: VCLongPrototype] extends ClassTag[T] {
+  def box(underlying: Long): T
+  final def unbox(boxed: T) = boxed.underlying
+
+  implicit def classTag: this.type = this
+  override def newArray(len: Int): Array[T] =
+    new VCLongArray(this, len).asInstanceOf[Array[T]]
+
+
+  final def _1$extension(underlying: Long)       = underlying
+  final def hashCode$extension(underlying: Long) = underlying.hashCode()
+  final def toString$extension(underlying: Long) = s"${productPrefix$extension(underlying)}($underlying)"
+  def productPrefix$extension(underlying: Long): String
+}
+
+final class VCLongArray[T <: VCLongPrototype] private (val arr: Array[Long], val ct: VCLongCompanion[T])
+  extends VCArrayPrototype[T] {
+  def this(ct: VCLongCompanion[T], sz: Int) =
+    this(new Array[Long](sz), ct)
+
+  def apply(idx: Int) =
+    ct.box(arr(idx))
+
+  def update(idx: Int, elem: T) =
+    arr(idx) = ct.unbox(elem)
+
+  def length: Int = arr.length
+
+  override def clone(): VCLongArray[T] = {
+    new VCLongArray[T](arr.clone(), ct)
+  }
+
+  override def toString: String = {
+    "[" + ct.runtimeClass
+  }
+}
+
+
+abstract class VCIntPrototype(val underlying: Int) extends VCPrototype {}
+
+abstract class VCIntCasePrototype(underlying: Int) extends VCIntPrototype(underlying) with Product1[Int] {
+
+  final def _1: Int = underlying
+
+  override final def hashCode(): Int = {
+    underlying.hashCode()
+  }
+
+  override final def toString: String = {
+    s"$productPrefix($underlying)"
+  }
+}
+
+abstract class VCIntCompanion[T <: VCIntPrototype] extends ClassTag[T] {
+  def box(underlying: Int): T
+  final def unbox(boxed: T) = boxed.underlying
+
+  implicit def classTag: this.type = this
+  override def newArray(len: Int): Array[T] =
+    new VCIntArray(this, len).asInstanceOf[Array[T]]
+
+
+  final def _1$extension(underlying: Int)       = underlying
+  final def hashCode$extension(underlying: Int) = underlying.hashCode()
+  final def toString$extension(underlying: Int) = s"${productPrefix$extension(underlying)}($underlying)"
+  def productPrefix$extension(underlying: Int): String
+}
+
+final class VCIntArray[T <: VCIntPrototype] private (val arr: Array[Int], val ct: VCIntCompanion[T])
+  extends VCArrayPrototype[T] {
+  def this(ct: VCIntCompanion[T], sz: Int) =
+    this(new Array[Int](sz), ct)
+
+  def apply(idx: Int) =
+    ct.box(arr(idx))
+  def update(idx: Int, elem: T) =
+    arr(idx) = ct.unbox(elem)
+  def length: Int = arr.length
+
+  override def clone(): VCIntArray[T] = {
+    new VCIntArray[T](arr.clone(), ct)
+  }
+
+  override def toString: String = {
+    "[" + ct.runtimeClass
+  }
+}
+
+
+abstract class VCDoublePrototype(val underlying: Double) extends VCPrototype {}
+
+abstract class VCDoubleCasePrototype(underlying: Double) extends VCDoublePrototype(underlying) with Product1[Double] {
+
+  final def _1: Double = underlying
+
+  override final def hashCode(): Int = {
+    underlying.hashCode()
+  }
+
+  override final def toString: String = {
+    s"$productPrefix($underlying)"
+  }
+}
+
+abstract class VCDoubleCompanion[T <: VCDoublePrototype] extends ClassTag[T] {
+  def box(underlying: Double): T
+  final def unbox(boxed: T) = boxed.underlying
+
+  implicit def classTag: this.type = this
+  override def newArray(len: Int): Array[T] =
+    new VCDoubleArray(this, len).asInstanceOf[Array[T]]
+
+
+  final def _1$extension(underlying: Double)       = underlying
+  final def hashCode$extension(underlying: Double) = underlying.hashCode()
+  final def toString$extension(underlying: Double) = s"${productPrefix$extension(underlying)}($underlying)"
+  def productPrefix$extension(underlying: Double): String
+}
+
+final class VCDoubleArray[T <: VCDoublePrototype] private (val arr: Array[Double], val ct: VCDoubleCompanion[T])
+  extends VCArrayPrototype[T] {
+  def this(ct: VCDoubleCompanion[T], sz: Int) =
+    this(new Array[Double](sz), ct)
+
+  def apply(idx: Int) =
+    ct.box(arr(idx))
+  def update(idx: Int, elem: T) =
+    arr(idx) = ct.unbox(elem)
+  def length: Int = arr.length
+
+  override def clone(): VCDoubleArray[T] = {
+    new VCDoubleArray[T](arr.clone(), ct)
+  }
+
+  override def toString: String = {
+    "[" + ct.runtimeClass
+  }
+}
+
+
+abstract class VCBooleanPrototype(val underlying: Boolean) extends VCPrototype {}
+
+abstract class VCBooleanCasePrototype(underlying: Boolean) extends VCBooleanPrototype(underlying) with Product1[Boolean] {
+
+  final def _1: Boolean = underlying
+
+  override final def hashCode(): Int = {
+    underlying.hashCode()
+  }
+
+  override final def toString: String = {
+    s"$productPrefix($underlying)"
+  }
+}
+
+abstract class VCBooleanCompanion[T <: VCBooleanPrototype] extends ClassTag[T] {
+  def box(underlying: Boolean): T
+  final def unbox(boxed: T) = boxed.underlying
+
+  implicit def classTag: this.type = this
+  override def newArray(len: Int): Array[T] =
+    new VCBooleanArray(this, len).asInstanceOf[Array[T]]
+
+
+  final def _1$extension(underlying: Boolean)       = underlying
+  final def hashCode$extension(underlying: Boolean) = underlying.hashCode()
+  final def toString$extension(underlying: Boolean) = s"${productPrefix$extension(underlying)}($underlying)"
+  def productPrefix$extension(underlying: Boolean): String
+}
+
+final class VCBooleanArray[T <: VCBooleanPrototype] private (val arr: Array[Boolean], val ct: VCBooleanCompanion[T])
+  extends VCArrayPrototype[T] {
+  def this(ct: VCBooleanCompanion[T], sz: Int) =
+    this(new Array[Boolean](sz), ct)
+
+  def apply(idx: Int) =
+    ct.box(arr(idx))
+
+  def update(idx: Int, elem: T) =
+    arr(idx) = ct.unbox(elem)
+
+  def length: Int = arr.length
+
+  override def clone(): VCBooleanArray[T] = {
+    new VCBooleanArray[T](arr.clone(), ct)
+  }
+
+  override def toString: String = {
+    "[" + ct.runtimeClass
+  }
+}
+
+
+abstract class VCCharPrototype(val underlying: Char) extends VCPrototype {}
+
+abstract class VCCharCasePrototype(underlying: Char) extends VCCharPrototype(underlying) with Product1[Char] {
+
+  final def _1: Char = underlying
+
+  override final def hashCode(): Int = {
+    underlying.hashCode()
+  }
+
+  override final def toString: String = {
+    s"$productPrefix($underlying)"
+  }
+
+  // subclasses are expected to implement equals, productPrefix, and canEqual
+}
+
+abstract class VCCharCompanion[T <: VCCharPrototype] extends ClassTag[T] {
+  def box(underlying: Char): T
+  final def unbox(boxed: T) = boxed.underlying
+
+  implicit def classTag: this.type = this
+  override def newArray(len: Int): Array[T] =
+    new VCCharArray(this, len).asInstanceOf[Array[T]]
+
+
+  final def _1$extension(underlying: Char)       = underlying
+  final def hashCode$extension(underlying: Char) = underlying.hashCode()
+  final def toString$extension(underlying: Char) = s"${productPrefix$extension(underlying)}($underlying)"
+  def productPrefix$extension(underlying: Char): String
+}
+
+final class VCCharArray[T <: VCCharPrototype] private (val arr: Array[Char], val ct: VCCharCompanion[T])
+  extends VCArrayPrototype[T] {
+  def this(ct: VCCharCompanion[T], sz: Int) =
+    this(new Array[Char](sz), ct)
+
+  def apply(idx: Int) =
+    ct.box(arr(idx))
+  def update(idx: Int, elem: T) =
+    arr(idx) = ct.unbox(elem)
+  def length: Int = arr.length
+
+  override def clone(): VCCharArray[T] = {
+    new VCCharArray[T](arr.clone(), ct)
+  }
+
+  override def toString: String = {
+    "[" + ct.runtimeClass
+  }
+}
+
+
+abstract class VCBytePrototype(val underlying: Byte) extends VCPrototype {}
+
+abstract class VCByteCasePrototype(underlying: Byte) extends VCBytePrototype(underlying) with Product1[Byte] {
+
+  final def _1: Byte = underlying
+
+  override final def hashCode(): Int = {
+    underlying.hashCode()
+  }
+
+  override final def toString: String = {
+    s"$productPrefix($underlying)"
+  }
+}
+
+abstract class VCByteCompanion[T <: VCBytePrototype] extends ClassTag[T] {
+  def box(underlying: Byte): T
+  final def unbox(boxed: T) = boxed.underlying
+
+  implicit def classTag: this.type = this
+  override def newArray(len: Int): Array[T] =
+    new VCByteArray(this, len).asInstanceOf[Array[T]]
+
+
+  final def _1$extension(underlying: Byte)       = underlying
+  final def hashCode$extension(underlying: Byte) = underlying.hashCode()
+  final def toString$extension(underlying: Byte) = s"${productPrefix$extension(underlying)}($underlying)"
+  def productPrefix$extension(underlying: Byte): String
+}
+
+final class VCByteArray[T <: VCBytePrototype] private (val arr: Array[Byte], val ct: VCByteCompanion[T])
+  extends VCArrayPrototype[T] {
+  def this(ct: VCByteCompanion[T], sz: Int) =
+    this(new Array[Byte](sz), ct)
+
+  def apply(idx: Int) =
+    ct.box(arr(idx))
+  def update(idx: Int, elem: T) =
+    arr(idx) = ct.unbox(elem)
+  def length: Int = arr.length
+
+  override def clone(): VCByteArray[T] = {
+    new VCByteArray[T](arr.clone(), ct)
+  }
+
+  override def toString: String = {
+    "[" + ct.runtimeClass
+  }
+
+}
+
diff --git a/src/dotty/runtime/vc/VCShortPrototype.scala b/src/dotty/runtime/vc/VCShortPrototype.scala
deleted file mode 100644
index 519e6d5c8..000000000
--- a/src/dotty/runtime/vc/VCShortPrototype.scala
+++ /dev/null
@@ -1,60 +0,0 @@
-package dotty.runtime.vc
-
-import scala.reflect.ClassTag
-
-import scala.runtime.Statics
-
-abstract class VCShortPrototype(val underlying: Short) extends VCPrototype {}
-
-abstract class VCShortCasePrototype(underlying: Short) extends VCShortPrototype(underlying) with Product1[Short] {
-
-  final def _1: Short = underlying
-
-  override final def hashCode(): Int = {
-    underlying.hashCode()
-  }
-
-  override final def toString: String = {
-    s"$productPrefix($underlying)"
-  }
-
-  // subclasses are expected to implement equals, productPrefix, and canEqual
-}
-
-abstract class VCShortCompanion[T <: VCShortPrototype] extends ClassTag[T] {
-  def box(underlying: Short): T
-  final def unbox(boxed: T) = boxed.underlying
-
-  implicit def classTag: this.type = this
-  override def newArray(len: Int): Array[T] =
-    new VCShortArray(this, len).asInstanceOf[Array[T]]
-
-
-  final def _1$extension(underlying: Short)       = underlying
-  final def hashCode$extension(underlying: Short) = underlying.hashCode()
-  final def toString$extension(underlying: Short) = s"${productPrefix$extension(underlying)}($underlying)"
-  def productPrefix$extension(underlying: Short): String
-}
-
-final class VCShortArray[T <: VCShortPrototype] private (val arr: Array[Short], val ct: VCShortCompanion[T])
-  extends VCArrayPrototype[T] {
-  def this(ct: VCShortCompanion[T], sz: Int) =
-    this(new Array[Short](sz), ct)
-
-  def apply(idx: Int) =
-    ct.box(arr(idx))
-  def update(idx: Int, elem: T) =
-    arr(idx) = ct.unbox(elem)
-  def length: Int = arr.length
-
-  override def clone(): VCShortArray[T] = {
-    new VCShortArray[T](arr.clone(), ct)
-  }
-
-  override def toString: String = {
-    "[" + ct.runtimeClass
-  }
-
-  // Todo: what was the reason for 255 classes in my original proposal? arr.toString!
-  // todo: need to discuss do we want to be compatible with ugly format of jvm here?
-}