这里的关键点是，不能保证open属性或具有自定义getter的属性在连续调用时返回相同的值。
因此，编译器无法确定，一旦检查从属性接收的值，就可以放心地假设，如果再次呼叫，它会传回相同的对象，什至是相同型别的对象。
示例（虽然非常简化和综合）：

open class Base {
    open val value: List<Int> = ArrayList()
}

val b : Base = foo()

fun printArrayList(list: ArrayList<Int>) { /* ... */ }

if (b.value is ArrayList) { // first call
    printArrayList(b.value) // second call, smart cast is impossible
}

这段代码不会编译，因为printArrayList()需要一个ArrayList，而b.value实际上是open--这就是你在代码中得到的结果。现在，让我们构造一个派生类来演示什么可能出错：

class Derived : Base() {
    private var counter = 0

    override val value: List<Int>
        get() {
            ++counter
            return if (counter % 2 == 0)
                ArrayList() else
                LinkedList()
        }
}

val b = Derived()
println(b.value.javaClass) // class java.util.LinkedList
println(b.value.javaClass) // class java.util.ArrayList

这里很明显，如果一个属性是open，它可以被重写，使得对它的连续调用返回不同的值。在printArrayList()的例子中，有两个这样的调用。这就是为什么智能转换不安全的原因。对于带有自定义getter的属性也是如此。
您在if区块内执行as转换的范例可以运作，因为如果属性在第二次呼叫时传回不相容型别的不同值，转换就会失败并掷回ClassCastException，而这会保留型别安全。
相反，如果val属性不是open，并且有一个默认的getter只返回支持字段的值（在本例中为final），则编译器可以安全地执行智能强制转换：如果多次获取该属性的值，则它肯定是相同的。
另一种方法是取得值一次，将它储存在局部变量中，然后多次使用它，而不是再次使用属性：

val list = b.value

if (list is ArrayList) {
    printArrayList(list) // smart cast to ArrayList
}

现在，无论属性是否为open，都只有一次对其getter的调用，然后代码使用调用返回的值进行操作。因为它不能更改，所以这里可以进行智能转换。

我没有直接使用activity，因为它是一个可以为空的对象，我这样做是有效的

activity?.let{
   if(it is ScreenRouter) {
      decoupler.attachRouter(it)
   }
}

与此代码段没有直接关系，但一种常见的情况是在ViewModel中定义了一个state，如下所示：

private val _state = MutableStateFlow<CardScreenState>(CardScreenState.Loading)
    val state: StateFlow<CardScreenState> = _state

然后，当您在when子句中使用此state时

when (state) {

您将得到相同的错误。
在这里，作为解决方案，您可以使用不可变的getter创建一个状态变量，如下所示：

when (val screenState = state) {