increase parser perf by a lot

src/main/kotlin/blitz/collections/RefVec.kt

@@ -1,75 +1,73 @@
 package blitz.collections
 
-import kotlin.system.measureTimeMillis
-
 @Suppress("UNCHECKED_CAST")
 class RefVec<T>(private val initCap: Int = 0): Vec<T> {
     override var size = 0
-    private var cap = initCap
-    private var array: Array<Any?>? = if (initCap > 0) arrayOfNulls(initCap) else null
+    @JvmField var _cap = initCap
+    @JvmField var _array: Array<Any?>? = if (initCap > 0) arrayOfNulls(initCap) else null
 
     override fun clear() {
         size = 0
-        if (array == null) return
-        if (array!!.size <= initCap) {
-            cap = array!!.size
+        if (_array == null) return
+        if (_array!!.size <= initCap) {
+            _cap = _array!!.size
         } else {
-            cap = 0
-            array = null
+            _cap = 0
+            _array = null
         }
     }
 
-    fun copyAsArray(): Array<Any?> =
-        array?.copyOfRange(0, size) ?: emptyArray()
+    inline fun copyAsArray(): Array<Any?> =
+        _array?.copyOfRange(0, size) ?: emptyArray()
 
-    fun copyIntoArray(arr: Array<Any?>, destOff: Int = 0, startOff: Int = 0) =
-        array?.copyInto(arr, destOff, startOff, size)
+    inline fun copyIntoArray(arr: Array<Any?>, destOff: Int = 0, startOff: Int = 0) =
+        _array?.copyInto(arr, destOff, startOff, size)
 
-    override fun copy(): RefVec<T> =
+    override inline fun copy(): RefVec<T> =
         RefVec<T>(size).also {
-            it.array?.let { copyIntoArray(it) }
+            it._array?.let { copyIntoArray(it) }
         }
 
     override fun reserve(amount: Int)  {
-        if (amount > 0 && cap - size >= amount)
+        if (amount > 0 && _cap - size >= amount)
             return
-        if (array == null) {
-            cap = size + amount
-            array = arrayOfNulls(cap)
+        if (_array == null) {
+            _cap = size + amount
+            _array = arrayOfNulls(_cap)
         } else {
-            array = array!!.copyOf(size + amount)
-            cap = size + amount
+            _array = _array!!.copyOf(size + amount)
+            _cap = size + amount
         }
     }
 
     override fun reserve(need: Int, totalIfRealloc: Int)  {
-        if (need > 0 && cap - size >= need)
+        if (need > 0 && _cap - size >= need)
             return
-        if (array == null) {
-            cap = size + totalIfRealloc
-            array = arrayOfNulls(cap)
+        if (_array == null) {
+            _cap = size + totalIfRealloc
+            _array = arrayOfNulls(_cap)
         } else {
-            array = array!!.copyOf(size + totalIfRealloc)
-            cap = size + totalIfRealloc
+            _array = _array!!.copyOf(size + totalIfRealloc)
+            _cap = size + totalIfRealloc
         }
     }
 
     override fun popBack(): T =
-        array!![size - 1].also {
+        _array!![size - 1].also {
             reserve(-1)
             size --
         } as T
 
-    override fun get(index: Int): T =
-        array!![index] as T
+    override inline fun get(index: Int): T =
+        (_array as Array<Any?>)[index] as T
 
     override fun flip() {
-        array = array?.reversedArray()
+        _array = _array?.reversedArray()
     }
 
     override fun pushBack(elem: T) {
         reserve(1, 8)
-        array!![size] = elem
+        this[size] = elem
         size ++
     }
 
@@ -80,7 +78,7 @@ class RefVec<T>(private val initCap: Int = 0): Vec<T> {
             override fun next(): T {
                 if (!hasNext())
                     throw NoSuchElementException()
-                return array!![index++] as T
+                return _array!![index++] as T
             }
         }
 
@@ -88,13 +86,13 @@ class RefVec<T>(private val initCap: Int = 0): Vec<T> {
         joinToString(prefix = "[", postfix = "]") { it.toString() }
 
     override fun set(index: Int, value: T) {
-        array!![index] = value
+        (_array as Array<Any?>)[index] = value
     }
 
     companion object {
         fun <T> from(data: Array<T>) =
             RefVec<T>(data.size).also {
-                it.array?.let { data.copyInto(it) }
+                it._array?.let { data.copyInto(it) }
                 it.size += data.size
             }
 
@@ -103,9 +101,9 @@ class RefVec<T>(private val initCap: Int = 0): Vec<T> {
                 data.forEach(bv::pushBack)
             }
 
-        fun <T> of(vararg elements: T): RefVec<T> =
-            RefVec<T>(elements.size).also {
-                it.array?.let { elements.copyInto(it) }
+        inline fun <T> of(vararg elements: T): RefVec<T> =
+            RefVec<T>(elements.size shl 2).also {
+                it._array?.let { elements.copyInto(it) }
             }
     }
 }