Not-null assertion operator(!!) is used when you are completely certain that a variable is not null. It can be useful for example to avoid additional checks with if statement or let() function. If you have at least a little doubt use safe calls(?.).

Not-null assertion operator(!!) is also used for interoperability with the Java language. For example if some Java library returns an object, Kotlin considers it as nullable, but if you are certain and library docs says that the object can't be null, so you can use Not-null assertion operator(!!).

!! is evaluated at runtime, it's just an operator.

The expression (x!!)

• throws a KotlinNullPointerException if x == null,
• otherwise, it returns x cast to the corresponding non-nullable type (for example, it returns it as a String when called on a variable with type String?).

This, of course, makes null!! shorthand for throw KotlinNullPointerException().

If it helps, you can think of !! as doing the same as a function like this does:

fun <T> T?.toNonNullable() : T {
    if(this == null) {
        throw KotlinNullPointerException()
    }
    return this as T // this would actually get smart cast, but this 
                     // explicit cast demonstrates the point better
}

So doing x!! would give you the same result as x.toNonNullable().

The compiler can’t know that body() is guaranteed to return the same thing each time so it can’t smart-cast it to non-null. Also, it doesn’t know anything as complex as the fact that the body won’t be null if isSuccessful is true.

Since we know from the documentation of this library that it will always be the same, it’s safe to use !!. But you could alternatively copy the value to a local variable and work with that variable in your null check. Then you could be sure your code is safe even if you misinterpreted the documentation.

I don't really use Retrofit myself, but from a little bit of reading about it, I know that you can work with it more naturally in Kotlin by using suspend functions, and then you wouldn't have to work with callbacks and Response objects. So instead of creating a function that returns a Call<MyData>, followed by enqueuing the call, listening for success/failure, and then unwrapping the body if it's successful; instead you can mark the function as suspend and return MyData directly. Use try/catch or runCatching when making the function call, because it throws when not successful.

Unfortunately, the bodies of the functions that you call, including inline functions, are not used for smart casts and nullability inference.

There's not much in your code that can be improved, and I would only suggest one thing: you can use the Elvis operator with a Nothing function for those assertion statements. The control flow analysis takes into account the branches resulting into Nothing and infers nullability from that:

fun failOnNull(): Nothing = throw AssertionError("Value should not be null")

val test: Foo? = foo()

test ?: failOnNull()
// `test` is not-null after that

^{This can be written without a function as well: test ?: throw AssertionError("..."), because a throw expression also has type Nothing.}

Speaking of a more general case of failing an assertion, one might use a fail(...): Nothing function, which provides a bonus hint for the control flow analysis as well. The JUnit Assert.fail(...) is not a Nothing function, but you can find one in the kotlin-test-junit module or write your own one.

test as? SomeType ?: fail("`test` should be an instance of SomeType")
// smart cast works here, `test` is `SomeType`