Greatly improved script assembly performance.

core/src/commonMain/kotlin/world/phantasmal/core/unsafe/UnsafeCast.kt

@@ -1,4 +1,4 @@
-package world.phantasmal.core
+package world.phantasmal.core.unsafe
 
 /**
  * Asserts that T is not null. No runtime check happens in KJS. Should only be used when absolutely

core/src/commonMain/kotlin/world/phantasmal/core/unsafe/UnsafeMap.kt

@@ -0,0 +1,14 @@
+package world.phantasmal.core.unsafe
+
+/**
+ * Map optimized for JS (it compiles to the built-in Map).
+ * In JS, keys are compared by reference, equals and hashCode are NOT invoked. On JVM, equals and
+ * hashCode ARE used.
+ */
+expect class UnsafeMap<K, V>() {
+    fun get(key: K): V?
+    fun has(key: K): Boolean
+    fun forEach(callback: (value: V, key: K) -> Unit)
+    fun set(key: K, value: V)
+    fun delete(key: K): Boolean
+}

core/src/jsMain/kotlin/world/phantasmal/core/Js.kt

@@ -43,10 +43,6 @@ inline val <T> JsPair<*, T>.second: T get() = asDynamic()[1].unsafeCast<T>()
 inline operator fun <T> JsPair<T, *>.component1(): T = first
 inline operator fun <T> JsPair<*, T>.component2(): T = second
 
-@Suppress("FunctionName", "UNUSED_PARAMETER")
-inline fun <A, B> JsPair(first: A, second: B): JsPair<A, B> =
-    js("[first, second]").unsafeCast<JsPair<A, B>>()
-
 @Suppress("UNUSED_PARAMETER")
 inline fun objectEntries(jsObject: dynamic): Array<JsPair<String, dynamic>> =
     js("Object.entries(jsObject)").unsafeCast<Array<JsPair<String, dynamic>>>()
@@ -67,21 +63,3 @@ inline fun <T> emptyJsSet(): JsSet<T> =
 @Suppress("UNUSED_PARAMETER")
 inline fun <T> jsSetOf(vararg values: T): JsSet<T> =
     js("new Set(values)").unsafeCast<JsSet<T>>()
-
-external interface JsMap<K, V> {
-    val size: Int
-
-    fun clear()
-    fun delete(key: K): Boolean
-    fun forEach(callback: (value: V, key: K) -> Unit)
-    fun get(key: K): V?
-    fun has(key: K): Boolean
-    fun set(key: K, value: V): JsMap<K, V>
-}
-
-@Suppress("UNUSED_PARAMETER")
-inline fun <K, V> jsMapOf(vararg pairs: JsPair<K, V>): JsMap<K, V> =
-    js("new Map(pairs)").unsafeCast<JsMap<K, V>>()
-
-inline fun <K, V> emptyJsMap(): JsMap<K, V> =
-    js("new Map()").unsafeCast<JsMap<K, V>>()

core/src/jsMain/kotlin/world/phantasmal/core/unsafe/UnsafeCast.kt

@@ -1,4 +1,4 @@
-package world.phantasmal.core
+package world.phantasmal.core.unsafe
 
 @Suppress("NOTHING_TO_INLINE")
 actual inline fun <T> T?.unsafeAssertNotNull(): T = unsafeCast<T>()

core/src/jsMain/kotlin/world/phantasmal/core/unsafe/UnsafeMap.kt

@@ -0,0 +1,10 @@
+package world.phantasmal.core.unsafe
+
+@JsName("Map")
+actual external class UnsafeMap<K, V> {
+    actual fun get(key: K): V?
+    actual fun has(key: K): Boolean
+    actual fun forEach(callback: (value: V, key: K) -> Unit)
+    actual fun set(key: K, value: V)
+    actual fun delete(key: K): Boolean
+}

core/src/jvmMain/kotlin/world/phantasmal/core/unsafe/UnsafeCast.kt

@@ -1,4 +1,4 @@
-package world.phantasmal.core
+package world.phantasmal.core.unsafe
 
 @Suppress("UNCHECKED_CAST", "NOTHING_TO_INLINE")
 actual inline fun <T> T?.unsafeAssertNotNull(): T = this as T

core/src/jvmMain/kotlin/world/phantasmal/core/unsafe/UnsafeMap.kt

@@ -0,0 +1,19 @@
+package world.phantasmal.core.unsafe
+
+actual class UnsafeMap<K, V> {
+    private val map = HashMap<K, V>()
+
+    actual fun get(key: K): V? = map[key]
+
+    actual fun has(key: K): Boolean = key in map
+
+    actual fun forEach(callback: (value: V, key: K) -> Unit) {
+        map.forEach { (k, v) -> callback(v, k) }
+    }
+
+    actual fun set(key: K, value: V) {
+        map[key] = value
+    }
+
+    actual fun delete(key: K): Boolean = map.remove(key) != null
+}

lib/build.gradle.kts

@@ -40,7 +40,9 @@ kotlin {
 
     sourceSets {
         all {
+            languageSettings.useExperimentalAnnotation("kotlin.RequiresOptIn")
             languageSettings.useExperimentalAnnotation("kotlin.ExperimentalUnsignedTypes")
+            languageSettings.useExperimentalAnnotation("kotlin.time.ExperimentalTime")
         }
 
         commonMain {

lib/src/commonMain/kotlin/world/phantasmal/lib/asm/AsmTokenization.kt

@@ -2,12 +2,33 @@ package world.phantasmal.lib.asm
 
 import world.phantasmal.core.fastIsWhitespace
 import world.phantasmal.core.isDigit
+import kotlin.contracts.ExperimentalContracts
+import kotlin.contracts.contract
 
 private val HEX_INT_REGEX = Regex("""^0[xX][0-9a-fA-F]+$""")
 private val FLOAT_REGEX = Regex("""^-?\d+(\.\d+)?(e-?\d+)?$""")
 private val IDENT_REGEX = Regex("""^[a-z][a-z0-9_=<>!]*$""")
 
+const val TOKEN_INT32 = 1
+const val TOKEN_FLOAT32 = 2
+const val TOKEN_INVALID_NUMBER = 3
+const val TOKEN_REGISTER = 4
+const val TOKEN_LABEL = 5
+const val TOKEN_SECTION_CODE = 6
+const val TOKEN_SECTION_DATA = 7
+const val TOKEN_SECTION_STR = 8
+const val TOKEN_INVALID_SECTION = 9
+const val TOKEN_STR = 10
+const val TOKEN_UNTERMINATED_STR = 11
+const val TOKEN_IDENT = 12
+const val TOKEN_INVALID_IDENT = 13
+const val TOKEN_ARG_SEP = 14
+
 sealed class Token {
+    /**
+     * This property is used for increased perf type checks in JS.
+     */
+    abstract val type: Int
     abstract val col: Int
     abstract val len: Int
 
@@ -15,80 +36,143 @@ sealed class Token {
         override val col: Int,
         override val len: Int,
         val value: Int,
-    ) : Token()
+    ) : Token() {
+        override val type = TOKEN_INT32
+    }
 
     class Float32(
         override val col: Int,
         override val len: Int,
         val value: Float,
-    ) : Token()
+    ) : Token() {
+        override val type = TOKEN_FLOAT32
+    }
 
     class InvalidNumber(
         override val col: Int,
         override val len: Int,
-    ) : Token()
+    ) : Token() {
+        override val type = TOKEN_INVALID_NUMBER
+    }
 
     class Register(
         override val col: Int,
         override val len: Int,
         val value: Int,
-    ) : Token()
+    ) : Token() {
+        override val type = TOKEN_REGISTER
+    }
 
     class Label(
         override val col: Int,
         override val len: Int,
         val value: Int,
-    ) : Token()
+    ) : Token() {
+        override val type = TOKEN_LABEL
+    }
 
     sealed class Section : Token() {
         class Code(
             override val col: Int,
             override val len: Int,
-        ) : Section()
+        ) : Section() {
+            override val type = TOKEN_SECTION_CODE
+        }
 
         class Data(
             override val col: Int,
             override val len: Int,
-        ) : Section()
+        ) : Section() {
+            override val type = TOKEN_SECTION_DATA
+        }
 
         class Str(
             override val col: Int,
             override val len: Int,
-        ) : Section()
+        ) : Section() {
+            override val type = TOKEN_SECTION_STR
+        }
     }
 
     class InvalidSection(
         override val col: Int,
         override val len: Int,
-    ) : Token()
+    ) : Token() {
+        override val type = TOKEN_INVALID_SECTION
+    }
 
     class Str(
         override val col: Int,
         override val len: Int,
         val value: String,
-    ) : Token()
+    ) : Token() {
+        override val type = TOKEN_STR
+    }
 
     class UnterminatedString(
         override val col: Int,
         override val len: Int,
         val value: String,
-    ) : Token()
+    ) : Token() {
+        override val type = TOKEN_UNTERMINATED_STR
+    }
 
     class Ident(
         override val col: Int,
         override val len: Int,
         val value: String,
-    ) : Token()
+    ) : Token() {
+        override val type = TOKEN_IDENT
+    }
 
     class InvalidIdent(
         override val col: Int,
         override val len: Int,
-    ) : Token()
+    ) : Token() {
+        override val type = TOKEN_INVALID_IDENT
+    }
 
     class ArgSeparator(
         override val col: Int,
         override val len: Int,
-    ) : Token()
+    ) : Token() {
+        override val type = TOKEN_ARG_SEP
+    }
+
+    @OptIn(ExperimentalContracts::class)
+    @Suppress("NOTHING_TO_INLINE")
+    inline fun isInt32(): Boolean {
+        contract { returns(true) implies (this@Token is Int32) }
+        return type == TOKEN_INT32
+    }
+
+    @OptIn(ExperimentalContracts::class)
+    @Suppress("NOTHING_TO_INLINE")
+    inline fun isFloat32(): Boolean {
+        contract { returns(true) implies (this@Token is Float32) }
+        return type == TOKEN_FLOAT32
+    }
+
+    @OptIn(ExperimentalContracts::class)
+    @Suppress("NOTHING_TO_INLINE")
+    inline fun isRegister(): Boolean {
+        contract { returns(true) implies (this@Token is Register) }
+        return type == TOKEN_REGISTER
+    }
+
+    @OptIn(ExperimentalContracts::class)
+    @Suppress("NOTHING_TO_INLINE")
+    inline fun isStr(): Boolean {
+        contract { returns(true) implies (this@Token is Str) }
+        return type == TOKEN_STR
+    }
+
+    @OptIn(ExperimentalContracts::class)
+    @Suppress("NOTHING_TO_INLINE")
+    inline fun isArgSeparator(): Boolean {
+        contract { returns(true) implies (this@Token is ArgSeparator) }
+        return type == TOKEN_ARG_SEP
+    }
 }
 
 fun tokenizeLine(line: String): MutableList<Token> =

lib/src/commonMain/kotlin/world/phantasmal/lib/asm/Assembly.kt

@@ -5,6 +5,7 @@ import world.phantasmal.core.Problem
 import world.phantasmal.core.PwResult
 import world.phantasmal.core.Severity
 import world.phantasmal.lib.buffer.Buffer
+import kotlin.time.measureTimedValue
 
 private val logger = KotlinLogging.logger {}
 
@@ -28,13 +29,13 @@ fun assemble(
         }."
     }
 
-    val result = Assembler(asm, inlineStackArgs).assemble()
+    val (result, time) = measureTimedValue { Assembler(asm, inlineStackArgs).assemble() }
 
     logger.trace {
         val warnings = result.problems.count { it.severity == Severity.Warning }
         val errors = result.problems.count { it.severity == Severity.Error }
 
-        "Assembly finished with $warnings warnings and $errors errors."
+        "Assembly finished in ${time.inMilliseconds}ms with $warnings warnings and $errors errors."
     }
 
     return result
@@ -69,7 +70,16 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
                 val token = tokens.removeFirst()
                 var hasLabel = false
 
+                // Token type checks are ordered from most frequent to least frequent for increased
+                // perf.
                 when (token) {
+                    is Token.Ident -> {
+                        if (section === SegmentType.Instructions) {
+                            parseInstruction(token)
+                        } else {
+                            addUnexpectedTokenError(token)
+                        }
+                    }
                     is Token.Label -> {
                         parseLabel(token)
                         hasLabel = true
@@ -78,26 +88,19 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
                         parseSection(token)
                     }
                     is Token.Int32 -> {
-                        if (section == SegmentType.Data) {
+                        if (section === SegmentType.Data) {
                             parseBytes(token)
                         } else {
                             addUnexpectedTokenError(token)
                         }
                     }
                     is Token.Str -> {
-                        if (section == SegmentType.String) {
+                        if (section === SegmentType.String) {
                             parseString(token)
                         } else {
                             addUnexpectedTokenError(token)
                         }
                     }
-                    is Token.Ident -> {
-                        if (section === SegmentType.Instructions) {
-                            parseInstruction(token)
-                        } else {
-                            addUnexpectedTokenError(token)
-                        }
-                    }
                     is Token.InvalidSection -> {
                         addError(token, "Invalid section type.")
                     }
@@ -146,11 +149,13 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
                             mnemonic = token?.let {
                                 SrcLoc(lineNo, token.col, token.len)
                             },
-                            args = argTokens.map {
+                            // Use mapTo with ArrayList for better perf in JS.
+                            args = argTokens.mapTo(ArrayList(argTokens.size)) {
                                 SrcLoc(lineNo, it.col, it.len)
                             },
-                            stackArgs = stackArgTokens.map { sat ->
+                            // Use mapTo with ArrayList for better perf in JS.
-                                SrcLoc(lineNo, sat.col, sat.len)
+                            stackArgs = stackArgTokens.mapTo(ArrayList(argTokens.size)) {
+                                SrcLoc(lineNo, it.col, it.len)
                             },
                         )
                     )
@@ -356,15 +361,19 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
         if (opcode == null) {
             addError(identToken, "Unknown opcode.")
         } else {
-            val varargs = opcode.params.any {
+            // Use find instead of any for better JS perf.
-                it.type is ILabelVarType || it.type is RegRefVarType
+            val varargs = opcode.params.find {
-            }
+                it.type === ILabelVarType || it.type === RegRefVarType
+            } != null
 
             val paramCount =
-                if (!inlineStackArgs && opcode.stack == StackInteraction.Pop) 0
+                if (!inlineStackArgs && opcode.stack === StackInteraction.Pop) 0
                 else opcode.params.size
 
-            val argCount = tokens.count { it !is Token.ArgSeparator }
+            // Use fold instead of count for better JS perf.
+            val argCount = tokens.fold(0) { sum, token ->
+                if (token.isArgSeparator()) sum else sum + 1
+            }
 
             val lastToken = tokens.lastOrNull()
             val errorLength = lastToken?.let { it.col + it.len - identToken.col } ?: 0
@@ -413,7 +422,7 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
                     val arg = stackArgs.getOrNull(i) ?: continue
                     val argToken = stackTokens.getOrNull(i) ?: continue
 
-                    if (argToken is Token.Register) {
+                    if (argToken.isRegister()) {
                         if (param.type is RegTupRefType) {
                             addInstruction(
                                 OP_ARG_PUSHB,
@@ -433,8 +442,8 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
                         }
                     } else {
                         when (param.type) {
-                            is ByteType,
+                            ByteType,
-                            is RegRefType,
+                            RegRefType,
                             is RegTupRefType,
                             -> {
                                 addInstruction(
@@ -446,11 +455,8 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
                                 )
                             }
 
-                            is ShortType,
+                            ShortType,
                             is LabelType,
-                            is ILabelType,
-                            is DLabelType,
-                            is SLabelType,
                             -> {
                                 addInstruction(
                                     OP_ARG_PUSHW,
@@ -461,7 +467,7 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
                                 )
                             }
 
-                            is IntType -> {
+                            IntType -> {
                                 addInstruction(
                                     OP_ARG_PUSHL,
                                     listOf(arg),
@@ -471,7 +477,7 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
                                 )
                             }
 
-                            is FloatType -> {
+                            FloatType -> {
                                 addInstruction(
                                     OP_ARG_PUSHL,
                                     listOf(Arg((arg.value as Float).toRawBits())),
@@ -481,7 +487,7 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
                                 )
                             }
 
-                            is StringType -> {
+                            StringType -> {
                                 addInstruction(
                                     OP_ARG_PUSHS,
                                     listOf(arg),
@@ -528,12 +534,12 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
             val token = tokens[i]
             val param = params[paramI]
 
-            if (token is Token.ArgSeparator) {
+            if (token.isArgSeparator()) {
                 if (shouldBeArg) {
                     addError(token, "Expected an argument.")
                 } else if (
-                    param.type !is ILabelVarType &&
+                    param.type !== ILabelVarType &&
-                    param.type !is RegRefVarType
+                    param.type !== RegRefVarType
                 ) {
                     paramI++
                 }
@@ -551,28 +557,24 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
 
                 var match: Boolean
 
-                when (token) {
+                when {
-                    is Token.Int32 -> {
+                    token.isInt32() -> {
                         when (param.type) {
-                            is ByteType -> {
+                            ByteType -> {
                                 match = true
                                 parseInt(1, token, args, argTokens)
                             }
-                            is ShortType,
+                            ShortType,
                             is LabelType,
-                            is ILabelType,
-                            is DLabelType,
-                            is SLabelType,
-                            is ILabelVarType,
                             -> {
                                 match = true
                                 parseInt(2, token, args, argTokens)
                             }
-                            is IntType -> {
+                            IntType -> {
                                 match = true
                                 parseInt(4, token, args, argTokens)
                             }
-                            is FloatType -> {
+                            FloatType -> {
                                 match = true
                                 args.add(Arg(token.value))
                                 argTokens.add(token)
@@ -583,8 +585,8 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
                         }
                     }
 
-                    is Token.Float32 -> {
+                    token.isFloat32() -> {
-                        match = param.type == FloatType
+                        match = param.type === FloatType
 
                         if (match) {
                             args.add(Arg(token.value))
@@ -592,17 +594,17 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
                         }
                     }
 
-                    is Token.Register -> {
+                    token.isRegister() -> {
                         match = stack ||
-                                param.type is RegRefType ||
+                                param.type === RegRefType ||
-                                param.type is RegRefVarType ||
+                                param.type === RegRefVarType ||
                                 param.type is RegTupRefType
 
                         parseRegister(token, args, argTokens)
                     }
 
-                    is Token.Str -> {
+                    token.isStr() -> {
-                        match = param.type is StringType
+                        match = param.type === StringType
 
                         if (match) {
                             args.add(Arg(token.value))
@@ -619,22 +621,24 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
                     semiValid = false
 
                     val typeStr: String? = when (param.type) {
-                        is ByteType -> "an 8-bit integer"
+                        ByteType -> "an 8-bit integer"
-                        is ShortType -> "a 16-bit integer"
+                        ShortType -> "a 16-bit integer"
-                        is IntType -> "a 32-bit integer"
+                        IntType -> "a 32-bit integer"
-                        is FloatType -> "a float"
+                        FloatType -> "a float"
-                        is LabelType -> "a label"
 
-                        is ILabelType,
+                        ILabelType,
-                        is ILabelVarType,
+                        ILabelVarType,
                         -> "an instruction label"
 
-                        is DLabelType -> "a data label"
+                        DLabelType -> "a data label"
-                        is SLabelType -> "a string label"
+                        SLabelType -> "a string label"
-                        is StringType -> "a string"
 
-                        is RegRefType,
+                        is LabelType -> "a label"
-                        is RegRefVarType,
+
+                        StringType -> "a string"
+
+                        RegRefType,
+                        RegRefVarType,
                         is RegTupRefType,
                         -> "a register reference"
 
@@ -660,22 +664,30 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
         argTokens: MutableList<Token>,
     ) {
         val value = token.value
-        val bitSize = 8 * size
-        // Minimum of the signed version of this integer type.
-        val minValue = -(1 shl (bitSize - 1))
-        // Maximum of the unsigned version of this integer type.
-        val maxValue = (1L shl (bitSize)) - 1L
 
-        when {
+        // Fast-path 32-bit ints for improved JS perf. Otherwise maxValue would have to be a Long
-            value < minValue -> {
+        // or UInt, which incurs a perf hit in JS.
-                addError(token, "${bitSize}-Bit integer can't be less than ${minValue}.")
+        if (size == 4) {
-            }
+            args.add(Arg(value))
-            value > maxValue -> {
+            argTokens.add(token)
-                addError(token, "${bitSize}-Bit integer can't be greater than ${maxValue}.")
+        } else {
-            }
+            val bitSize = 8 * size
-            else -> {
+            // Minimum of the signed version of this integer type.
-                args.add(Arg(value))
+            val minValue = -(1 shl (bitSize - 1))
-                argTokens.add(token)
+            // Maximum of the unsigned version of this integer type.
+            val maxValue = (1 shl (bitSize)) - 1
+
+            when {
+                value < minValue -> {
+                    addError(token, "${bitSize}-Bit integer can't be less than ${minValue}.")
+                }
+                value > maxValue -> {
+                    addError(token, "${bitSize}-Bit integer can't be greater than ${maxValue}.")
+                }
+                else -> {
+                    args.add(Arg(value))
+                    argTokens.add(token)
+                }
             }
         }
     }

lib/src/commonMain/kotlin/world/phantasmal/lib/asm/BytecodeIr.kt

@@ -1,5 +1,6 @@
 package world.phantasmal.lib.asm
 
+import world.phantasmal.core.unsafe.unsafeAssertNotNull
 import world.phantasmal.lib.buffer.Buffer
 import kotlin.math.ceil
 
@@ -47,7 +48,7 @@ class InstructionSegment(
     override fun copy(): InstructionSegment =
         InstructionSegment(
             ArrayList(labels),
-            instructions.mapTo(mutableListOf()) { it.copy() },
+            instructions.mapTo(ArrayList(instructions.size)) { it.copy() },
             srcLoc.copy(),
         )
 }
@@ -101,43 +102,46 @@ class Instruction(
     /**
      * Immediate arguments for the opcode.
      */
-    val args: List<Arg> = emptyList(),
+    val args: List<Arg>,
-    val srcLoc: InstructionSrcLoc? = null,
+    val srcLoc: InstructionSrcLoc?,
 ) {
     /**
      * Maps each parameter by index to its immediate arguments.
      */
-    private val paramToArgs: List<List<Arg>>
+    // Avoid using lazy to keep GC pressure low.
-
+    private var paramToArgs: List<List<Arg>>? = null
-    init {
-        val paramToArgs: MutableList<MutableList<Arg>> = mutableListOf()
-        this.paramToArgs = paramToArgs
-
-        if (opcode.stack != StackInteraction.Pop) {
-            for (i in opcode.params.indices) {
-                val type = opcode.params[i].type
-                val pArgs = mutableListOf<Arg>()
-                paramToArgs.add(pArgs)
-
-                // Variable length arguments are always last, so we can just gobble up all arguments
-                // from this point.
-                if (type is ILabelVarType || type is RegRefVarType) {
-                    check(i == opcode.params.lastIndex)
-
-                    for (j in i until args.size) {
-                        pArgs.add(args[j])
-                    }
-                } else {
-                    pArgs.add(args[i])
-                }
-            }
-        }
-    }
 
     /**
      * Returns the immediate arguments for the parameter at the given index.
      */
-    fun getArgs(paramIndex: Int): List<Arg> = paramToArgs[paramIndex]
+    fun getArgs(paramIndex: Int): List<Arg> {
+        if (paramToArgs == null) {
+            val paramToArgs: MutableList<MutableList<Arg>> = mutableListOf()
+            this.paramToArgs = paramToArgs
+
+            if (opcode.stack !== StackInteraction.Pop) {
+                for (i in opcode.params.indices) {
+                    val type = opcode.params[i].type
+                    val pArgs = mutableListOf<Arg>()
+                    paramToArgs.add(pArgs)
+
+                    // Variable length arguments are always last, so we can just gobble up all arguments
+                    // from this point.
+                    if (type === ILabelVarType || type === RegRefVarType) {
+                        check(i == opcode.params.lastIndex)
+
+                        for (j in i until args.size) {
+                            pArgs.add(args[j])
+                        }
+                    } else {
+                        pArgs.add(args[i])
+                    }
+                }
+            }
+        }
+
+        return paramToArgs.unsafeAssertNotNull()[paramIndex]
+    }
 
     /**
      * Returns the source locations of the immediate arguments for the parameter at the given index.
@@ -150,7 +154,7 @@ class Instruction(
 
         // Variable length arguments are always last, so we can just gobble up all SrcLocs from
         // paramIndex onward.
-        return if (type is ILabelVarType || type is RegRefVarType) {
+        return if (type === ILabelVarType || type === RegRefVarType) {
             argSrcLocs.drop(paramIndex)
         } else {
             listOf(argSrcLocs[paramIndex])
@@ -171,7 +175,7 @@ class Instruction(
 
         // Variable length arguments are always last, so we can just gobble up all SrcLocs from
         // paramIndex onward.
-        return if (type is ILabelVarType || type is RegRefVarType) {
+        return if (type === ILabelVarType || type === RegRefVarType) {
             argSrcLocs.drop(paramIndex)
         } else {
             listOf(argSrcLocs[paramIndex])
@@ -185,31 +189,28 @@ class Instruction(
     fun getSize(dcGcFormat: Boolean): Int {
         var size = opcode.size
 
-        if (opcode.stack == StackInteraction.Pop) return size
+        if (opcode.stack === StackInteraction.Pop) return size
 
         for (i in opcode.params.indices) {
             val type = opcode.params[i].type
             val args = getArgs(i)
 
             size += when (type) {
-                is ByteType,
+                ByteType,
-                is RegRefType,
+                RegRefType,
-                is RegTupRefType,
                 -> 1
 
                 // Ensure this case is before the LabelType case because ILabelVarType extends
                 // LabelType.
-                is ILabelVarType -> 1 + 2 * args.size
+                ILabelVarType -> 1 + 2 * args.size
 
-                is ShortType,
+                ShortType -> 2
-                is LabelType,
-                -> 2
 
-                is IntType,
+                IntType,
-                is FloatType,
+                FloatType,
                 -> 4
 
-                is StringType -> {
+                StringType -> {
                     if (dcGcFormat) {
                         (args[0].value as String).length + 1
                     } else {
@@ -217,7 +218,12 @@ class Instruction(
                     }
                 }
 
-                is RegRefVarType -> 1 + args.size
+                RegRefVarType -> 1 + args.size
+
+                // Check RegTupRefType and LabelType last, because "is" checks are very slow in JS.
+                is RegTupRefType -> 1
+
+                is LabelType -> 2
 
                 else -> error("Parameter type ${type::class} not implemented.")
             }

lib/src/commonMain/kotlin/world/phantasmal/lib/asm/Opcode.kt

@@ -1,11 +1,13 @@
 package world.phantasmal.lib.asm
 
-private val MNEMONIC_TO_OPCODES: MutableMap<String, Opcode> by lazy {
+import world.phantasmal.core.unsafe.UnsafeMap
-    val map = mutableMapOf<String, Opcode>()
 
-    OPCODES.forEach { if (it != null) map[it.mnemonic] = it }
+private val MNEMONIC_TO_OPCODES: UnsafeMap<String, Opcode> by lazy {
-    OPCODES_F8.forEach { if (it != null) map[it.mnemonic] = it }
+    val map = UnsafeMap<String, Opcode>()
-    OPCODES_F9.forEach { if (it != null) map[it.mnemonic] = it }
+
+    OPCODES.forEach { if (it != null) map.set(it.mnemonic, it) }
+    OPCODES_F8.forEach { if (it != null) map.set(it.mnemonic, it) }
+    OPCODES_F9.forEach { if (it != null) map.set(it.mnemonic, it) }
 
     map
 }
@@ -170,13 +172,13 @@ fun codeToOpcode(code: Int): Opcode =
     }
 
 fun mnemonicToOpcode(mnemonic: String): Opcode? {
-    var opcode = MNEMONIC_TO_OPCODES[mnemonic]
+    var opcode = MNEMONIC_TO_OPCODES.get(mnemonic)
 
     if (opcode == null) {
         UNKNOWN_OPCODE_MNEMONIC_REGEX.matchEntire(mnemonic)?.destructured?.let { (codeStr) ->
             val code = codeStr.toInt(16)
             opcode = codeToOpcode(code)
-            MNEMONIC_TO_OPCODES[mnemonic] = opcode!!
+            MNEMONIC_TO_OPCODES.set(mnemonic, opcode!!)
         }
     }
 

lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/Bytecode.kt

@@ -466,13 +466,13 @@ private fun parseInstructionsSegment(
         // Parse the arguments.
         try {
             val args = parseInstructionArguments(cursor, opcode, dcGcFormat)
-            instructions.add(Instruction(opcode, args))
+            instructions.add(Instruction(opcode, args, srcLoc = null))
         } catch (e: Exception) {
             if (lenient) {
                 logger.error(e) {
                     "Exception occurred while parsing arguments for instruction ${opcode.mnemonic}."
                 }
-                instructions.add(Instruction(opcode, emptyList()))
+                instructions.add(Instruction(opcode, emptyList(), srcLoc = null))
             } else {
                 throw e
             }
@@ -590,21 +590,23 @@ private fun parseInstructionArguments(
 
                 is StringType -> {
                     val maxBytes = min(4096, cursor.bytesLeft)
-                    args.add(Arg(
+                    args.add(
-                        if (dcGcFormat) {
+                        Arg(
-                            cursor.stringAscii(
+                            if (dcGcFormat) {
-                                maxBytes,
+                                cursor.stringAscii(
-                                nullTerminated = true,
+                                    maxBytes,
-                                dropRemaining = false
+                                    nullTerminated = true,
-                            )
+                                    dropRemaining = false
-                        } else {
+                                )
-                            cursor.stringUtf16(
+                            } else {
-                                maxBytes,
+                                cursor.stringUtf16(
-                                nullTerminated = true,
+                                    maxBytes,
-                                dropRemaining = false
+                                    nullTerminated = true,
-                            )
+                                    dropRemaining = false
-                        },
+                                )
-                    ))
+                            },
+                        )
+                    )
                 }
 
                 is RegRefType,

lib/src/commonTest/kotlin/world/phantasmal/lib/asm/DisassemblyTests.kt

@@ -7,26 +7,30 @@ import kotlin.test.assertEquals
 class DisassemblyTests : LibTestSuite {
     @Test
     fun vararg_instructions() {
-        val ir = BytecodeIr(listOf(
+        val ir = BytecodeIr(
-            InstructionSegment(
+            listOf(
-                labels = mutableListOf(0),
+                InstructionSegment(
-                instructions = mutableListOf(
+                    labels = mutableListOf(0),
-                    Instruction(
+                    instructions = mutableListOf(
-                        opcode = OP_SWITCH_JMP,
+                        Instruction(
-                        args = listOf(
+                            opcode = OP_SWITCH_JMP,
-                            Arg(90),
+                            args = listOf(
-                            Arg(100),
+                                Arg(90),
-                            Arg(101),
+                                Arg(100),
-                            Arg(102),
+                                Arg(101),
+                                Arg(102),
+                            ),
+                            srcLoc = null,
+                        ),
+                        Instruction(
+                            opcode = OP_RET,
+                            args = emptyList(),
+                            srcLoc = null,
                         ),
                     ),
-                    Instruction(
+                )
-                        opcode = OP_RET,
-                        args = emptyList()
-                    ),
-                ),
             )
-        ))
+        )
 
         val asm = """
             |.code
@@ -44,30 +48,40 @@ class DisassemblyTests : LibTestSuite {
     // arguments is on or off.
     @Test
     fun va_list_instructions() {
-        val ir = BytecodeIr(listOf(
+        val ir = BytecodeIr(
-            InstructionSegment(
+            listOf(
-                labels = mutableListOf(0),
+                InstructionSegment(
-                instructions = mutableListOf(
+                    labels = mutableListOf(0),
-                    Instruction(
+                    instructions = mutableListOf(
-                        opcode = OP_VA_START,
+                        Instruction(
+                            opcode = OP_VA_START,
+                            args = emptyList(),
+                            srcLoc = null,
+                        ),
+                        Instruction(
+                            opcode = OP_ARG_PUSHW,
+                            args = listOf(Arg(1337)),
+                            srcLoc = null,
+                        ),
+                        Instruction(
+                            opcode = OP_VA_CALL,
+                            args = listOf(Arg(100)),
+                            srcLoc = null,
+                        ),
+                        Instruction(
+                            opcode = OP_VA_END,
+                            args = emptyList(),
+                            srcLoc = null,
+                        ),
+                        Instruction(
+                            opcode = OP_RET,
+                            args = emptyList(),
+                            srcLoc = null,
+                        ),
                     ),
-                    Instruction(
+                )
-                        opcode = OP_ARG_PUSHW,
-                        args = listOf(Arg(1337)),
-                    ),
-                    Instruction(
-                        opcode = OP_VA_CALL,
-                        args = listOf(Arg(100)),
-                    ),
-                    Instruction(
-                        opcode = OP_VA_END,
-                    ),
-                    Instruction(
-                        opcode = OP_RET,
-                    ),
-                ),
             )
-        ))
+        )
 
         val asm = """
             |.code

observable/src/commonMain/kotlin/world/phantasmal/observable/value/AbstractDependentVal.kt

@@ -2,7 +2,7 @@ package world.phantasmal.observable.value
 
 import world.phantasmal.core.disposable.Disposable
 import world.phantasmal.core.disposable.disposable
-import world.phantasmal.core.unsafeAssertNotNull
+import world.phantasmal.core.unsafe.unsafeAssertNotNull
 import world.phantasmal.observable.Observer
 
 /**

observable/src/commonMain/kotlin/world/phantasmal/observable/value/FlatteningDependentVal.kt

@@ -2,7 +2,7 @@ package world.phantasmal.observable.value
 
 import world.phantasmal.core.disposable.Disposable
 import world.phantasmal.core.disposable.disposable
-import world.phantasmal.core.unsafeAssertNotNull
+import world.phantasmal.core.unsafe.unsafeAssertNotNull
 import world.phantasmal.observable.Observer
 
 /**

observable/src/commonMain/kotlin/world/phantasmal/observable/value/list/AbstractListVal.kt

@@ -2,7 +2,7 @@ package world.phantasmal.observable.value.list
 
 import world.phantasmal.core.disposable.Disposable
 import world.phantasmal.core.disposable.disposable
-import world.phantasmal.core.unsafeAssertNotNull
+import world.phantasmal.core.unsafe.unsafeAssertNotNull
 import world.phantasmal.observable.ChangeEvent
 import world.phantasmal.observable.Observable
 import world.phantasmal.observable.Observer

observable/src/commonMain/kotlin/world/phantasmal/observable/value/list/DependentListVal.kt

@@ -1,6 +1,6 @@
 package world.phantasmal.observable.value.list
 
-import world.phantasmal.core.unsafeAssertNotNull
+import world.phantasmal.core.unsafe.unsafeAssertNotNull
 import world.phantasmal.observable.value.Val
 
 /**

observable/src/commonMain/kotlin/world/phantasmal/observable/value/list/FlatteningDependentListVal.kt

@@ -1,7 +1,7 @@
 package world.phantasmal.observable.value.list
 
 import world.phantasmal.core.disposable.Disposable
-import world.phantasmal.core.unsafeAssertNotNull
+import world.phantasmal.core.unsafe.unsafeAssertNotNull
 import world.phantasmal.observable.value.Val
 
 /**

observable/src/commonMain/kotlin/world/phantasmal/observable/value/list/FoldedVal.kt

@@ -2,7 +2,7 @@ package world.phantasmal.observable.value.list
 
 import world.phantasmal.core.disposable.Disposable
 import world.phantasmal.core.disposable.disposable
-import world.phantasmal.core.unsafeAssertNotNull
+import world.phantasmal.core.unsafe.unsafeAssertNotNull
 import world.phantasmal.observable.Observer
 import world.phantasmal.observable.value.AbstractVal
 

web/src/main/kotlin/world/phantasmal/web/core/rendering/conversion/MeshBuilder.kt

@@ -3,17 +3,16 @@ package world.phantasmal.web.core.rendering.conversion
 import org.khronos.webgl.Float32Array
 import org.khronos.webgl.Uint16Array
 import org.khronos.webgl.set
-import world.phantasmal.core.JsMap
 import world.phantasmal.core.asArray
-import world.phantasmal.core.emptyJsMap
 import world.phantasmal.core.jsArrayOf
+import world.phantasmal.core.unsafe.UnsafeMap
 import world.phantasmal.lib.fileFormats.ninja.XvrTexture
 import world.phantasmal.web.externals.three.*
 import world.phantasmal.webui.obj
 
 class MeshBuilder(
     private val textures: List<XvrTexture?> = emptyList(),
-    private val textureCache: JsMap<Int, Texture?> = emptyJsMap(),
+    private val textureCache: UnsafeMap<Int, Texture?> = UnsafeMap(),
 ) {
     private val positions = mutableListOf<Vector3>()
     private val normals = mutableListOf<Vector3>()

web/src/main/kotlin/world/phantasmal/web/core/rendering/conversion/NinjaGeometryConversion.kt

@@ -4,6 +4,7 @@ import mu.KotlinLogging
 import org.khronos.webgl.Float32Array
 import org.khronos.webgl.Uint16Array
 import world.phantasmal.core.*
+import world.phantasmal.core.unsafe.UnsafeMap
 import world.phantasmal.lib.fileFormats.*
 import world.phantasmal.lib.fileFormats.ninja.*
 import world.phantasmal.web.core.dot
@@ -128,32 +129,36 @@ fun renderGeometryToGroup(
     processMesh: (AreaSection, AreaObject, Mesh) -> Unit = { _, _, _ -> },
 ): Group {
     val group = Group()
-    val textureCache = emptyJsMap<Int, Texture?>()
+    val textureCache = UnsafeMap<Int, Texture?>()
-    val meshCache = emptyJsMap<XjObject, Mesh>()
+    val meshCache = UnsafeMap<XjObject, Mesh>()
 
     for ((sectionIndex, section) in renderGeometry.sections.withIndex()) {
         for (areaObj in section.objects) {
-            group.add(areaObjectToMesh(
+            group.add(
-                textures,
+                areaObjectToMesh(
-                textureCache,
+                    textures,
-                meshCache,
+                    textureCache,
-                section,
+                    meshCache,
-                sectionIndex,
+                    section,
-                areaObj,
+                    sectionIndex,
-                processMesh,
+                    areaObj,
-            ))
+                    processMesh,
+                )
+            )
         }
 
         for (areaObj in section.animatedObjects) {
-            group.add(areaObjectToMesh(
+            group.add(
-                textures,
+                areaObjectToMesh(
-                textureCache,
+                    textures,
-                meshCache,
+                    textureCache,
-                section,
+                    meshCache,
-                sectionIndex,
+                    section,
-                areaObj,
+                    sectionIndex,
-                processMesh,
+                    areaObj,
-            ))
+                    processMesh,
+                )
+            )
         }
     }
 
@@ -200,8 +205,8 @@ fun AreaObject.fingerPrint(): String =
 
 private fun areaObjectToMesh(
     textures: List<XvrTexture?>,
-    textureCache: JsMap<Int, Texture?>,
+    textureCache: UnsafeMap<Int, Texture?>,
-    meshCache: JsMap<XjObject, Mesh>,
+    meshCache: UnsafeMap<XjObject, Mesh>,
     section: AreaSection,
     sectionIndex: Int,
     areaObj: AreaObject,

web/src/main/kotlin/world/phantasmal/web/core/stores/ItemDropStore.kt

@@ -1,7 +1,6 @@
 package world.phantasmal.web.core.stores
 
-import world.phantasmal.core.JsMap
+import world.phantasmal.core.unsafe.UnsafeMap
-import world.phantasmal.core.emptyJsMap
 import world.phantasmal.lib.fileFormats.quest.NpcType
 import world.phantasmal.web.core.loading.AssetLoader
 import world.phantasmal.web.core.models.Server
@@ -25,21 +24,21 @@ class ItemDropStore(
     private suspend fun loadEnemyDropTable(server: Server): EnemyDropTable {
         val drops = assetLoader.load<List<EnemyDrop>>("/enemy_drops.${server.slug}.json")
 
-        val table = emptyJsMap<Difficulty, JsMap<SectionId, JsMap<NpcType, EnemyDrop>>>()
+        val table = UnsafeMap<Difficulty, UnsafeMap<SectionId, UnsafeMap<NpcType, EnemyDrop>>>()
-        val itemTypeToDrops = emptyJsMap<Int, MutableList<EnemyDrop>>()
+        val itemTypeToDrops = UnsafeMap<Int, MutableList<EnemyDrop>>()
 
         for (drop in drops) {
             var diffTable = table.get(drop.difficulty)
 
             if (diffTable == null) {
-                diffTable = emptyJsMap()
+                diffTable = UnsafeMap()
                 table.set(drop.difficulty, diffTable)
             }
 
             var sectionIdTable = diffTable.get(drop.sectionId)
 
             if (sectionIdTable == null) {
-                sectionIdTable = emptyJsMap()
+                sectionIdTable = UnsafeMap()
                 diffTable.set(drop.sectionId, sectionIdTable)
             }
 
@@ -60,11 +59,11 @@ class ItemDropStore(
 }
 
 class EnemyDropTable(
-    private val table: JsMap<Difficulty, JsMap<SectionId, JsMap<NpcType, EnemyDrop>>>,
+    private val table: UnsafeMap<Difficulty, UnsafeMap<SectionId, UnsafeMap<NpcType, EnemyDrop>>>,
     /**
      * Mapping of [ItemType] ids to [EnemyDrop]s.
      */
-    private val itemTypeToDrops: JsMap<Int, MutableList<EnemyDrop>>,
+    private val itemTypeToDrops: UnsafeMap<Int, MutableList<EnemyDrop>>,
 ) {
     fun getDrop(difficulty: Difficulty, sectionId: SectionId, npcType: NpcType): EnemyDrop? =
         table.get(difficulty)?.get(sectionId)?.get(npcType)

web/src/main/kotlin/world/phantasmal/web/huntOptimizer/stores/HuntOptimizerStore.kt

@@ -5,6 +5,7 @@ import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import mu.KotlinLogging
 import world.phantasmal.core.*
+import world.phantasmal.core.unsafe.UnsafeMap
 import world.phantasmal.lib.fileFormats.quest.NpcType
 import world.phantasmal.observable.value.Val
 import world.phantasmal.observable.value.list.ListVal
@@ -134,7 +135,7 @@ class HuntOptimizerStore(
         // enemies that drop the item multiplied by the corresponding drop rate as its value.
         val variables: dynamic = obj {}
         // Each variable has a matching FullMethod.
-        val fullMethods = emptyJsMap<String, FullMethod>()
+        val fullMethods = UnsafeMap<String, FullMethod>()
 
         val wantedItemTypeIds = emptyJsSet<Int>()
 
@@ -148,7 +149,7 @@ class HuntOptimizerStore(
         for (method in methods) {
             // Calculate enemy counts including rare enemies
             // Counts include rare enemies, so they are fractional.
-            val counts = emptyJsMap<NpcType, Double>()
+            val counts = UnsafeMap<NpcType, Double>()
 
             for ((enemyType, count) in method.enemyCounts) {
                 val rareEnemyType = enemyType.rareType
@@ -191,15 +192,15 @@ class HuntOptimizerStore(
         dropTable: EnemyDropTable,
         wantedItemTypeIds: JsSet<Int>,
         method: HuntMethodModel,
-        defaultCounts: JsMap<NpcType, Double>,
+        defaultCounts: UnsafeMap<NpcType, Double>,
         splitPanArms: Boolean,
         variables: dynamic,
-        fullMethods: JsMap<String, FullMethod>,
+        fullMethods: UnsafeMap<String, FullMethod>,
     ) {
-        val counts: JsMap<NpcType, Double>?
+        val counts: UnsafeMap<NpcType, Double>?
 
         if (splitPanArms) {
-            var splitPanArmsCounts: JsMap<NpcType, Double>? = null
+            var splitPanArmsCounts: UnsafeMap<NpcType, Double>? = null
 
             // Create a secondary counts map if there are any pan arms that can be split
             // into migiums and hidooms.
@@ -207,7 +208,7 @@ class HuntOptimizerStore(
             val panArms2Count = defaultCounts.get(NpcType.PanArms2)
 
             if (panArmsCount != null || panArms2Count != null) {
-                splitPanArmsCounts = emptyJsMap()
+                splitPanArmsCounts = UnsafeMap()
 
                 if (panArmsCount != null) {
                     splitPanArmsCounts.delete(NpcType.PanArms)
@@ -262,7 +263,7 @@ class HuntOptimizerStore(
         wantedItemTypeIds: JsSet<Int>,
         constraints: dynamic,
         variables: dynamic,
-        fullMethods: JsMap<String, FullMethod>,
+        fullMethods: UnsafeMap<String, FullMethod>,
     ): List<OptimalMethodModel> {
         val result = Solver.Solve(obj {
             optimize = "time"

web/src/main/kotlin/world/phantasmal/web/questEditor/stores/AsmStore.kt

@@ -140,7 +140,7 @@ class AsmStore(
                 })
 
                 setBytecodeIrTimeout?.let(window::clearTimeout)
-                setBytecodeIrTimeout = window.setTimeout(::setBytecodeIr, 300)
+                setBytecodeIrTimeout = window.setTimeout(::setBytecodeIr, 1000)
 
                 // TODO: Update breakpoints.
             }

webui/src/main/kotlin/world/phantasmal/webui/dom/HTMLElementSizeVal.kt

@@ -3,7 +3,7 @@ package world.phantasmal.webui.dom
 import org.w3c.dom.HTMLElement
 import world.phantasmal.core.disposable.Disposable
 import world.phantasmal.core.disposable.disposable
-import world.phantasmal.core.unsafeAssertNotNull
+import world.phantasmal.core.unsafe.unsafeAssertNotNull
 import world.phantasmal.observable.Observer
 import world.phantasmal.observable.value.AbstractVal