better propagation of boolean values through the program

[mraleph]

Right now we have some support for propagating constant boolean values through the program:

• Simple unreachable code elimination is capable of folding some patterns (like false && ... into false)
• TFA is capable of propagating boolean constants

However these passes have some unpredictable short comings and can surprise developers:

• TFA does not attempt to evaluate logical expressions so in f() => true; g() => f(); h() => f() && g() g() will be inferred to return true but h() will not
• Unreachable code elimination short-circuits false && ... => false but does not attempt to rewrite ... && false into let t = ... in false.

We should consider making these more predictable.

/cc @alexmarkov

[alexmarkov]

A few random thoughts:

• We also do constant folding in TFA tree shaker (using the values propagated by TFA) and in the VM's local optimizations, so the 2nd pattern should be optimized anyway.
• Adding constant folding of logical expressions to TFA will make TFA summaries larger, increasing memory usage and potentially slowing the analysis and compilation time. We need to have a serious reason to do so (such as a real-world case where this optimization would actually help).
• Transformation foo && false into let t = foo in false is only valid with sound null safety (without sound null safety foo should be checked for null).

@mraleph Do you have a real-world example where the lack of the constant propagation / folding in these cases causes suboptimal code and affects performance or code size?