La conversión inteligente a 'Tipo' es imposible, porque 'variable' es una propiedad mutable que podría haberse cambiado en este momento

Y el novato de Kotlin pregunta: "¿por qué no se compila el siguiente código?":

    var left: Node? = null

    fun show() {
         if (left != null) {
             queue.add(left) // ERROR HERE
         }
    }

La conversión inteligente a 'Nodo' es imposible, porque 'izquierda' es una propiedad mutable que podría haberse cambiado en este momento

Entiendo que leftes una variable mutable, pero estoy comprobando explícitamente left != nully leftes de tipo, Node¿por qué no se puede convertir de forma inteligente en ese tipo?

¿Cómo puedo arreglar esto con elegancia? :)

Entre la ejecución de left != nully queue.add(left)otro hilo podría haber cambiado el valor de lefta null.

Para evitar esto, tiene varias opciones. Aquí están algunas:

1. Use una variable local con conversión inteligente:

   val node = left
   if (node != null) {
       queue.add(node)
   }

2. Use una llamada segura como una de las siguientes:

   left?.let { node -> queue.add(node) }
   left?.let { queue.add(it) }
   left?.let(queue::add)

3. Use el operador Elvis con returnpara regresar temprano de la función de cierre:

   queue.add(left ?: return)

   Tenga en cuenta que breaky continuepuede usarse de manera similar para las comprobaciones dentro de los bucles.

1) También puede usar lateinitSi seguro realiza su inicialización más adelante onCreate()o en otro lugar.

Utilizar este

lateinit var left: Node

En lugar de esto

var left: Node? = null

2) Y hay otra forma de usar el !!final de variable cuando lo usas así

queue.add(left!!) // add !!

Hay una cuarta opción además de las de la respuesta de mfulton26.

Al usar el ?.operador, es posible llamar a métodos y campos sin tener que lidiar leto usar variables locales.

Algún código para el contexto:

var factory: ServerSocketFactory = SSLServerSocketFactory.getDefault();
socket = factory.createServerSocket(port)
socket.close()//smartcast impossible
socket?.close()//Smartcast possible. And works when called

Funciona con métodos, campos y todas las otras cosas que intenté para que funcione.

Entonces, para resolver el problema, en lugar de tener que usar conversiones manuales o usar variables locales, puede usar ?.para llamar a los métodos.

Como referencia, esto se probó en Kotlin 1.1.4-3, pero también se probó en 1.1.51y 1.1.60. No hay garantía de que funcione en otras versiones, podría ser una nueva característica.

El uso del ?.operador no se puede usar en su caso, ya que el problema es una variable pasada. El operador de Elvis se puede usar como alternativa, y probablemente sea el que requiera la menor cantidad de código. Sin continueembargo, en lugar de usar , returntambién podría usarse.

El uso de la conversión manual también podría ser una opción, pero esto no es nulo seguro:

queue.add(left as Node);

Es decir, si la izquierda ha cambiado en un hilo diferente, el programa se bloqueará.

La razón práctica por la que esto no funciona no está relacionada con los hilos. El punto es que node.leftse traduce efectivamente en node.getLeft().

Este captador de propiedades se puede definir como:

val left get() = if (Math.random() < 0.5) null else leftPtr

Por lo tanto, dos llamadas podrían no devolver el mismo resultado.

Cambiar var left: Node? = nulla lateinit var left: Node. Problema resuelto.

Hacer esto:

var left: Node? = null

fun show() {
     val left = left
     if (left != null) {
         queue.add(left) // safe cast succeeds
     }
}

Cuál parece ser la primera opción proporcionada por la respuesta aceptada, pero eso es lo que estás buscando.

Para que haya un Smart Cast de las propiedades, el tipo de datos de la propiedad debe ser la clase que contiene el método o comportamiento al que desea acceder y NO que la propiedad sea del tipo de la superclase.

por ejemplo, en Android

Ser:

class MyVM : ViewModel() {
    fun onClick() {}
}

Solución:

From: private lateinit var viewModel: ViewModel
To: private lateinit var viewModel: MyVM

Uso:

viewModel = ViewModelProvider(this)[MyVM::class.java]
viewModel.onClick {}

GL

Su solución más elegante debe ser:

var left: Node? = null

fun show() {
    left?.also {
        queue.add( it )
    }
}

Entonces no tiene que definir una variable local nueva e innecesaria, y no tiene nuevas aserciones o conversiones (que no sean SECAS). Otras funciones de alcance también podrían funcionar, así que elija su favorito.

Intente usar el operador de aserción no nulo ...

queue.add(left!!) 

Cómo lo escribiría:

var left: Node? = null

fun show() {
     val left = left ?: return
     queue.add(left) // no error because we return if it is null
}