Expand mixed-slot stress tests

lynglib/src/commonTest/kotlin/NumericSlotMixTest.kt

@@ -69,4 +69,120 @@ class NumericSlotMixTest {
             """.trimIndent()
         )
     }
+
+    @Test
+    fun testOptionalCallsWithCapturedLocals() = runTest {
+        eval(
+            """
+            class Box(val b) {
+                fun bump(x) = x + b
+            }
+
+            fun makeScale(k, offset) {
+                return { x -> x * k + offset }
+            }
+
+            fun run() {
+                var sum = 0.0
+                for (i in 1..12) {
+                    val scale = makeScale(1.5, i)
+                    val base = i + 0.25
+                    val left = scale(base)
+                    var inner = 0.0
+                    for (j in 1..3) {
+                        val maybeBox: Box? = if ((i + j) % 3 == 0) Box(0.5) else null
+                        val right = maybeBox?.bump(j) ?: (j + 1.0)
+                        when (j) {
+                            1 -> inner += right / 2.0
+                            2 -> inner += right
+                            else -> inner += right + 0.25
+                        }
+                    }
+                    when (i % 3) {
+                        0 -> sum += left + inner
+                        1 -> sum += left - inner / 2.0
+                        else -> sum += (left + inner) / 2.0
+                    }
+                }
+                sum
+            }
+
+            val result = run()
+            assert(result is Real)
+            assert(abs(result - 197.75) < 1.0e-9)
+            """.trimIndent()
+        )
+    }
+
+    @Test
+    fun testDelegatedVarsAndBoxingMix() = runTest {
+        eval(
+            """
+            class NumDelegate(val map) : Delegate {
+                override fun getValue(thisRef: Object, name: String): Object = map[name]
+                override fun setValue(thisRef: Object, name: String, value: Object) { map[name] = value }
+            }
+
+            fun run() {
+                val store = { "r": 0.5, "i": 1 }
+                var r by NumDelegate(store)
+                var i by NumDelegate(store)
+                var acc = 0.0
+                for (n in 1..8) {
+                    val local = n
+                    val bump = { x -> x + local }
+                    r = (r as Real) + n * 0.25
+                    i = (i as Int) + n
+                    var inner = 0.0
+                    for (j in 1..2) {
+                        val mixed = bump(n) + (i as Int) + j
+                        when (j) {
+                            1 -> inner += mixed / 2.0
+                            else -> inner += mixed + (r as Real)
+                        }
+                    }
+                    if (n % 2 == 0)
+                        acc += inner + (r as Real)
+                    else
+                        acc += inner / 2.0
+                }
+                acc + (r as Real) + (i as Int)
+            }
+
+            val result = run()
+            assert(result is Real)
+            assert(abs(result - 343.25) < 1.0e-9)
+            """.trimIndent()
+        )
+    }
+
+    @Test
+    fun testIteratorLoopsWithOptionalIndex() = runTest {
+        eval(
+            """
+            fun run() {
+                val list = [1, 2.0, 3, 4.0]
+                val inner = [1, 2, 3]
+                var acc = 0.0
+                for (v in list) {
+                    val maybe = if (v is Real) list else null
+                    val pick = maybe?[1] ?: 0
+                    for (w in inner) {
+                        val t = v * w
+                        when (w) {
+                            1 -> acc += t + pick
+                            2 -> acc += t + 0.5
+                            else -> acc += t - 1
+                        }
+                    }
+                }
+                acc
+            }
+
+            val result = run()
+            assert(result is Real)
+            assert(abs(result - 62.0) < 1.0e-9)
+            """.trimIndent()
+        )
+    }
 }