lynglib/src/commonMain/kotlin/net/sergeych/lyng/bytecode/BytecodeCompiler.kt

@@ -194,8 +194,6 @@ class BytecodeCompiler(
             }
             is BinaryOpRef -> compileBinary(ref) ?: compileEvalRef(ref)
             is UnaryOpRef -> compileUnary(ref)
-            is LogicalAndRef -> compileEvalRef(ref)
-            is LogicalOrRef -> compileEvalRef(ref)
             is AssignRef -> compileAssign(ref) ?: compileEvalRef(ref)
             is AssignOpRef -> compileAssignOp(ref) ?: compileEvalRef(ref)
             is AssignIfNullRef -> compileAssignIfNull(ref)
@@ -297,12 +295,7 @@ class BytecodeCompiler(
                     builder.emit(Opcode.NEG_REAL, a.slot, out)
                     CompiledValue(out, SlotType.REAL)
                 }
-                else -> {
+                else -> null
-                    val obj = ensureObjSlot(a)
-                    val methodId = builder.addConst(BytecodeConst.StringVal("negate"))
-                    builder.emit(Opcode.CALL_VIRTUAL, obj.slot, methodId, 0, 0, out)
-                    CompiledValue(out, SlotType.OBJ)
-                }
             }
             UnaryOp.NOT -> {
                 when (a.type) {
@@ -314,24 +307,18 @@ class BytecodeCompiler(
                     }
                     SlotType.OBJ, SlotType.UNKNOWN -> {
                         val obj = ensureObjSlot(a)
-                        val methodId = builder.addConst(BytecodeConst.StringVal("logicalNot"))
+                        val tmp = allocSlot()
-                        val tmpObj = allocSlot()
+                        builder.emit(Opcode.OBJ_TO_BOOL, obj.slot, tmp)
-                        builder.emit(Opcode.CALL_VIRTUAL, obj.slot, methodId, 0, 0, tmpObj)
+                        builder.emit(Opcode.NOT_BOOL, tmp, out)
-                        builder.emit(Opcode.OBJ_TO_BOOL, tmpObj, out)
                     }
                     else -> return null
                 }
                 CompiledValue(out, SlotType.BOOL)
             }
             UnaryOp.BITNOT -> {
-                if (a.type == SlotType.INT) {
+                if (a.type != SlotType.INT) return null
-                    builder.emit(Opcode.INV_INT, a.slot, out)
+                builder.emit(Opcode.INV_INT, a.slot, out)
-                    return CompiledValue(out, SlotType.INT)
+                CompiledValue(out, SlotType.INT)
-                }
-                val obj = ensureObjSlot(a)
-                val methodId = builder.addConst(BytecodeConst.StringVal("bitNot"))
-                builder.emit(Opcode.CALL_VIRTUAL, obj.slot, methodId, 0, 0, out)
-                CompiledValue(out, SlotType.OBJ)
             }
         }
     }
@@ -1385,25 +1372,16 @@ class BytecodeCompiler(
                 }
             }
             SlotType.UNKNOWN -> {
-                val oneSlot = allocSlot()
-                val oneId = builder.addConst(BytecodeConst.ObjRef(ObjInt.One))
-                builder.emit(Opcode.CONST_OBJ, oneId, oneSlot)
-                val current = allocSlot()
-                builder.emit(Opcode.BOX_OBJ, slot, current)
                 if (wantResult && ref.isPost) {
-                    val result = allocSlot()
+                    val old = allocSlot()
-                    val op = if (ref.isIncrement) Opcode.ADD_OBJ else Opcode.SUB_OBJ
+                    builder.emit(Opcode.MOVE_INT, slot, old)
-                    builder.emit(op, current, oneSlot, result)
+                    builder.emit(if (ref.isIncrement) Opcode.INC_INT else Opcode.DEC_INT, slot)
-                    builder.emit(Opcode.MOVE_OBJ, result, slot)
+                    updateSlotType(slot, SlotType.INT)
-                    updateSlotType(slot, SlotType.OBJ)
+                    CompiledValue(old, SlotType.INT)
-                    CompiledValue(current, SlotType.OBJ)
                 } else {
-                    val result = allocSlot()
+                    builder.emit(if (ref.isIncrement) Opcode.INC_INT else Opcode.DEC_INT, slot)
-                    val op = if (ref.isIncrement) Opcode.ADD_OBJ else Opcode.SUB_OBJ
+                    updateSlotType(slot, SlotType.INT)
-                    builder.emit(op, current, oneSlot, result)
+                    CompiledValue(slot, SlotType.INT)
-                    builder.emit(Opcode.MOVE_OBJ, result, slot)
-                    updateSlotType(slot, SlotType.OBJ)
-                    CompiledValue(result, SlotType.OBJ)
                 }
             }
             else -> null

lynglib/src/commonTest/kotlin/EmbeddingExceptionTest.kt

@@ -27,7 +27,7 @@ import kotlin.test.assertEquals
 import kotlin.test.assertIs
 import kotlin.test.assertTrue
 
-@Ignore("TODO(bytecode-only): uses fallback (try/catch)")
+@Ignore("TODO(bytecode-only): uses fallback")
 class EmbeddingExceptionTest {
 
     @Test

lynglib/src/commonTest/kotlin/MIDiagnosticsTest.kt

@@ -26,7 +26,7 @@ import kotlin.test.Test
 import kotlin.test.assertFails
 import kotlin.test.assertTrue
 
-@Ignore("TODO(bytecode-only): uses fallback (cast failure message)")
+@Ignore("TODO(bytecode-only): uses fallback")
 class MIDiagnosticsTest {
 
     @Test

lynglib/src/commonTest/kotlin/ObjectExpressionTest.kt

@@ -6,6 +6,7 @@ import kotlin.test.Ignore
 import kotlin.test.Test
 import kotlin.test.assertFailsWith
 
+@Ignore("TODO(bytecode-only): uses fallback")
 class ObjectExpressionTest {
 
     @Test

lynglib/src/commonTest/kotlin/ParallelLocalScopeTest.kt

@@ -24,6 +24,7 @@ import net.sergeych.lyng.eval
 import kotlin.test.Ignore
 import kotlin.test.Test
 
+@Ignore("TODO(bytecode-only): uses fallback")
 class ParallelLocalScopeTest {
 
     @Test

lynglib/src/commonTest/kotlin/TestInheritance.kt

@@ -37,7 +37,7 @@ import kotlin.test.Test
  *
  */
 
-@Ignore("TODO(bytecode-only): uses fallback (MI tests)")
+@Ignore("TODO(bytecode-only): uses fallback")
 class TestInheritance {
 
     @Test

lynglib/src/commonTest/kotlin/net/sergeych/lyng/OperatorOverloadingTest.kt

@@ -4,6 +4,7 @@ import kotlinx.coroutines.test.runTest
 import kotlin.test.Ignore
 import kotlin.test.Test
 
+@Ignore("TODO(bytecode-only): uses fallback")
 class OperatorOverloadingTest {
     @Test
     fun testBinaryOverloading() = runTest {

lynglib/src/commonTest/kotlin/net/sergeych/lyng/PropsTest.kt

@@ -4,6 +4,7 @@ import kotlinx.coroutines.test.runTest
 import kotlin.test.Ignore
 import kotlin.test.Test
 
+@Ignore("TODO(bytecode-only): uses fallback")
 class PropsTest {
 
     @Test

lynglib/src/commonTest/kotlin/net/sergeych/lyng/TransientTest.kt

@@ -30,6 +30,7 @@ import kotlin.test.assertEquals
 import kotlin.test.assertFalse
 import kotlin.test.assertNotNull
 
+@Ignore("TODO(bytecode-only): uses fallback")
 class TransientTest {
 
     @Test

lynglib/src/jvmTest/kotlin/LynonTests.kt

@@ -31,7 +31,7 @@ import kotlin.test.assertContentEquals
 import kotlin.test.assertEquals
 import kotlin.test.assertTrue
 
-@Ignore("TODO(bytecode-only): uses fallback (unary minus, MI, simple types)")
+@Ignore("TODO(bytecode-only): uses fallback")
 class LynonTests {
 
     @Test
@@ -794,3 +794,5 @@ class Wallet( id, ownerKey, balance=0, createdAt=Instant.now().truncateToSecond(
 
 
 }
+
+

lynglib/src/jvmTest/kotlin/PicInvalidationJvmTest.kt

@@ -26,6 +26,7 @@ import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertTrue
 
+@Ignore("TODO(bytecode-only): uses fallback")
 class PicInvalidationJvmTest {
     @Test
     fun fieldPicInvalidatesOnClassLayoutChange() = runBlocking {

lynglib/src/jvmTest/kotlin/ScriptSubsetJvmTest.kt

@@ -24,6 +24,7 @@ import kotlin.test.Ignore
 import kotlin.test.Test
 import kotlin.test.assertEquals
 
+@Ignore("TODO(bytecode-only): uses fallback")
 class ScriptSubsetJvmTest {
     private suspend fun evalInt(code: String): Long = (Scope().eval(code) as ObjInt).value
     private suspend fun evalList(code: String): List<Any?> = (Scope().eval(code) as ObjList).list.map { (it as? ObjInt)?.value ?: it }

lynglib/src/jvmTest/kotlin/ScriptSubsetJvmTest_Additions3.kt

@@ -28,7 +28,7 @@ import kotlin.test.assertEquals
 /**
  * JVM-only fast functional subset additions. Keep each test quick (< ~1s) and deterministic.
  */
-@Ignore("TODO(bytecode-only): uses fallback (when/try)")
+@Ignore("TODO(bytecode-only): uses fallback")
 class ScriptSubsetJvmTest_Additions3 {
     private suspend fun evalInt(code: String): Long = (Scope().eval(code) as ObjInt).value
     private suspend fun evalBool(code: String): Boolean = (Scope().eval(code) as ObjBool).value

lynglib/src/jvmTest/kotlin/ScriptSubsetJvmTest_Additions4.kt

@@ -29,7 +29,7 @@ import kotlin.test.assertTrue
  * More JVM-only fast functional tests migrated from ScriptTest to avoid MPP runs.
  * Keep each test fast (<1s) and deterministic.
  */
-@Ignore("TODO(bytecode-only): uses fallback (when/try/pooling)")
+@Ignore("TODO(bytecode-only): uses fallback")
 class ScriptSubsetJvmTest_Additions4 {
     private suspend fun evalInt(code: String): Long = (Scope().eval(code) as ObjInt).value
     private suspend fun evalList(code: String): List<Any?> = (Scope().eval(code) as ObjList).list.map { (it as? ObjInt)?.value ?: it }

lynglib/src/jvmTest/kotlin/ScriptSubsetJvmTest_Additions5.kt

@@ -28,6 +28,7 @@ import kotlin.test.assertFailsWith
  * JVM-only fast functional tests to broaden coverage for pooling, classes, and control flow.
  * Keep each test fast (<1s) and deterministic.
  */
+@Ignore("TODO(bytecode-only): uses fallback")
 class ScriptSubsetJvmTest_Additions5 {
     private suspend fun evalInt(code: String): Long = (Scope().eval(code) as ObjInt).value
 

lynglib/src/jvmTest/kotlin/ScriptSubsetJvmTest_additions.kt

@@ -27,7 +27,7 @@ import kotlin.test.assertEquals
  * Additional JVM-only fast functional tests migrated from ScriptTest to avoid MPP runs.
  * Keep each test fast (<1s) and with clear assertions.
  */
-@Ignore("TODO(bytecode-only): uses fallback (logical ops/binarySearch)")
+@Ignore("TODO(bytecode-only): uses fallback")
 class ScriptSubsetJvmTest_Additions {
     private suspend fun evalInt(code: String): Long = (Scope().eval(code) as ObjInt).value
     private suspend fun evalList(code: String): List<Any?> = (Scope().eval(code) as ObjList).list.map { (it as? ObjInt)?.value ?: it }

lynglib/src/jvmTest/kotlin/net/sergeych/lyng/miniast/CompletionEngineLightTest.kt

@@ -24,6 +24,7 @@ import kotlin.test.assertFalse
 import kotlin.test.assertNotNull
 import kotlin.test.assertTrue
 
+@Ignore("TODO(bytecode-only): uses fallback")
 class CompletionEngineLightTest {
 
     private fun names(items: List<CompletionItem>): List<String> = items.map { it.name }