No history yet

Smart Casts Overview

The Compiler as an Ally

In many languages, type checking is a rigid, explicit process. You check if a variable is of a certain type, and then you must explicitly cast it to use its type-specific properties. Kotlin streamlines this with smart casts, a feature where the compiler performs the cast for you based on its own control-flow analysis.

A smart cast is an implicit cast applied by the compiler after a successful type check. It treats a variable as a more specific type within a certain scope, eliminating the need for redundant as casts.

The key is that the compiler must be able to guarantee the variable's type has not changed between the check and its usage. This guarantee is the foundation of smart casting. Let's look at a common scenario.

fun process(any: Any) {
    if (any is String) {
        // The compiler smart casts 'any' to String here
        println("Length is ${any.length}") 
    }
}

Inside the if block, the compiler knows any is a String. Calling any.length is safe, and no explicit (any as String).length is needed. This also works with when expressions, providing a clean way to handle sealed class hierarchies or different subtypes.

Smart Casts and Nullability

Smart casts are equally powerful for null safety. If you check that a nullable variable is not null, the compiler smart casts it to its non-nullable counterpart within that scope. This avoids the constant use of the safe-call operator (?.) or the not-null assertion (!!).

fun printTrimmed(text: String?) {
    if (text != null) {
        // 'text' is smart cast to String (non-nullable)
        println(text.trim()) 
    }
}

After the text != null check, the compiler guarantees text is not null for the rest of the if block's scope. This allows direct access to methods like trim() without a safe call.

Conditions for Smart Casts

The compiler's guarantee is not absolute; it depends on how a variable is declared. Smart casts are only possible for variables that are provably immutable after the check.

This means they work reliably for:

  • Local val variables
  • val properties
  • Local var variables, as long as they are not modified between the check and the usage.

They do not work for mutable properties of a class (var) because the value could be changed by another function or thread after the check. In those cases, you must use a safe call, an explicit cast, or assign the property to a local variable first.

class MyClass {
    var myVar: Any = "Hello"

    fun doSomething() {
        if (myVar is String) {
            // This would be a COMPILE ERROR!
            // println(myVar.length) 

            // You must use a local variable (shadowing)
            val myVar = this.myVar
            if (myVar is String) {
                 println(myVar.length) // This works
            }
        }
    }
}

By capturing the state of myVar in a local val, we provide the compiler with the immutability guarantee it needs to perform the smart cast. This is a common and effective pattern for working with mutable state safely.

Quiz Questions 1/5

What is the primary benefit of Kotlin's smart cast feature?

Quiz Questions 2/5

In which of the following scenarios is a smart cast NOT guaranteed to work?

Smart casts are a subtle but powerful feature, reducing boilerplate and enhancing safety by leveraging the compiler's flow analysis. Understanding when and why they apply is key to writing clean, idiomatic Kotlin.