Почему блок использования не может безопасно инициализировать переменную?

Поскольку use { ... } не является языковой конструкцией, а является просто библиотечной функцией, компилятор не знает (и в настоящее время не пытается доказать), что переданная вами лямбда когда-либо выполнялась. Поэтому использование переменной, которая может быть не инициализирована, запрещено.

Например, сравните свой код с этим вызовом функции. Без дополнительного анализа кода для компилятора они идентичны:

inline fun ignoreBlock(block: () -> Unit) = Unit

var myVar: MyType
ignoreBlock { myVar = it.foo() }
println(myVar) // Expectedly, `myVar` stays uninitialized, and the compiler prohibits it

Чтобы обойти это ограничение, вы можете использовать значение, возвращаемое из use (это значение, которое возвращает ваш блок), для инициализации вашей переменной:

val myVar = autoClosable.use {
    it.foo()
}

И если вы также хотите обработать исключение, которое оно может вызвать, используйте try как выражение:

val myVar = try {
    autoClosable.use {
        it.foo()
    }
} catch (e: SomeException) {
    otherValue   
}

Теоретически встроенные функции могут быть проверены на вызов лямбды ровно один раз, и если бы компилятор Kotlin мог это сделать, он разрешил бы ваш вариант использования и некоторые другие. Но это еще не реализовано.

В случае возникновения исключения при выполнении it.foo() блок use перехватит исключение, закроет autoClosable и затем вернется. В этом случае myVar останется неинициализированным.

Вот почему компилятор не позволит вам сделать то, что вы пытаетесь сделать.

Это связано с тем, что use является встроенной функцией, что означает, что тело лямбда-выражения будет встроено в функцию сайта вызова, а фактический тип переменной myVar зависит от ее контекста.

ЕСЛИ myVar используется в лямбде для чтения, это тип MyType или его супертип. Например:

//      v--- the actual type here is MyType
var myVar: MyType = TODO()

autoClosable.use {
    myVar.todo()
}

ЕСЛИ myVar используется в лямбда-выражении для записи, фактический тип — ObjectRef. Зачем? это связано с тем, что Java не позволяет вам изменять переменную за пределами раздражающей области класса. Фактически, myVar является эффективно окончательным. Например:

//  v--- the actual type here is an ObjectRef type.
var myVar: MyType

autoClosable.use {
    myVar = autoClosable.foo()
}

Поэтому когда компилятор проверяет println(myVar), он не может быть уверен, что элемент ObjectRef инициализирован или нет. то возникает ошибка компилятора.

ЕСЛИ вы что-то ловите, код тоже не может быть скомпилирован, например:

//  v--- the actual type here is an ObjectRef type.
var myVar: MyType
try {
    autoClosable.use {
        myVar = it.foo()
    }
} catch(e: Throwable) {
    myVar = MyType()
}

//       v--- Error: Variable 'myVar' must be initialized
println(myVar) 

Но когда фактический тип myVar равен MyType, все работает нормально. Например:

var myVar: MyType
try {
    TODO()
} catch(e: Throwable) {
    myVar = MyType()
}

println(myVar) // works fine

Почему kotlin не оптимизировал встроенные функции для использования MyType непосредственно для записи?

единственное, что я думаю, компилятор не знает, будет ли myVar использоваться в теле лямбда другой неинлайновой функции в будущем. или kotlin хотят сохранить семантическую согласованность для всех функций.