Kotlin中Bad type on operand stack错误排查求助

Alright, let's figure out why you're hitting this java.lang.VerifyError and how to fix it. This error pops up when the JVM's bytecode validator spots an invalid type on the operand stack—here, it was expecting an Option instance but got a raw Object instead, which breaks type safety rules.

Root Cause #

The issue boils down to Kotlin generic type erasure combined with how the compiler generates bytecode for your sequence operations and Option sealed class. Let's look at the key problematic line:

val calculateVariables = Option.Some(request) map { mapPVRequestToPRVariables(it) }

When you call map on Option.Some(request), the result is an Option<PriceRequestVariables>, but due to type erasure, the JVM only sees a raw Option at runtime. Then, when you pass this variable to addInstallmentTypeToPRVariables inside the sequence map:

.map { installmentType -> addInstallmentTypeToPRVariables(installmentType, calculateVariables) }

The compiler doesn't retain enough type information in the generated bytecode, leading the JVM to treat calculateVariables as an Object instead of an Option when invoking the method. This type mismatch triggers the VerifyError.

Also, your current code creates a sequence but never uses it (you just return an empty list), which might contribute to odd bytecode generation, though that's secondary to the type erasure issue.

Fixes #

Here are actionable ways to resolve this:

1. Add Explicit Type Annotation #

The simplest fix is to explicitly declare the type of calculateVariables—this tells the compiler exactly what type it should be, avoiding any type erasure confusion:

val calculateVariables: Option<PriceRequestVariables> = Option.Some(request) map { mapPVRequestToPRVariables(it) }

This ensures the bytecode references the correct Option<PriceRequestVariables> type instead of falling back to a raw Object.

2. Refactor the Sequence to Use the Option Values #

Since you're working with Option, you'll want to handle both Some and None cases, and actually use the sequence to generate your PriceVariant list (replacing the placeholder empty list). Here's a revised version:

fun getPriceVariants(request: PriceVariantsRequest): List<PriceVariant> {
    val calculateVariables: Option<PriceRequestVariables> = Option.Some(request) map { mapPVRequestToPRVariables(it) }
    
    return InstallmentType.values()
        .asSequence()
        .map { installmentType -> addInstallmentTypeToPRVariables(installmentType, calculateVariables) }
        .filterIsInstance<Option.Some<PriceRequestVariables>>() // Filter out None results
        .map { it.value } // Extract the inner PriceRequestVariables
        .map { prVars -> 
            // Add your logic to convert PriceRequestVariables to PriceVariant here
            createPriceVariantFromVars(prVars)
        }
        .toList()
}

This not only fixes the type issue but also makes your function actually return meaningful results instead of an empty list.

3. Update Your Kotlin Compiler Version #

Occasionally, older Kotlin compiler versions have bugs that generate incorrect bytecode for generic sealed classes. Make sure you're using a recent stable version (e.g., 1.8.x or later) to rule out compiler-specific issues.

Quick Additional Tip #

When working with sealed classes like Option, always make sure you handle both Some and None cases to avoid silent failures. Your current code doesn't account for None (if mapPVRequestToPRVariables could ever return a failure), so adding that handling will make your code more robust.

内容的提问来源于stack exchange，提问作者Dina Bogdan