Improving type guarantees when invoking

[GrigoriiSolnyshkin]

With this pull request necessary casts are added when calling and returning from lambdas and functions (inline and non-inline).

Before code like

fun <T> id(x: T) = x

inline fun <T, R> T.runWithId(block: T.() -> R) = id(this).block()

class Class {
  val member = 0
}

Class().runWithId { member }

wouldn't work: we only knew that the object returned from id had type Any?. Therefore, we make casts when entering (inline calls) and returning (from any calls) to keep TypeEmbedding consistent with kotlin types (this is also needed to correctly represent == calls etc.)

[jesyspa]

My impression was that we already make copies of values passed to inlined functions; otherwise the following code is not translated correctly:

class X(var a: Int)
fun f(x: X) : Int = x.a.run { x.a += 1; it }

This isn't an idiomatic example, of course, but do we miscompile it?

[GrigoriiSolnyshkin]

Hm, I added a couple of tests now that check we don't evaluate receiver twice. I'm not able to find any other copies when passing arguments. Anyway this part is just slightly changed logic of what was in this file before.

[GrigoriiSolnyshkin]

I think I'll try to experiment without this piece of code and report what happens.

[jesyspa]

Is this special case really worth it? I guess it reduces the number of inhales we do, but it may be hard to find why nullable any behaves differently. Perhaps with the type decomposition redesign we can do something nicer.

[GrigoriiSolnyshkin]

Nah, I think it has some sense to introduce this optimization eventually. Particularly because it can enable further optimizations (like .simplified). But I don't think it should be done like this anyway.

[jesyspa]

This code is a bit hard to read because there's no verb: I'm guessing withInvariants produces an ExpEmbedding that inhales the invariants?

[jesyspa]

nit: equalToType or equalsType