Hi all noticed this little thing and got curious why awesome kotlin team decided to do this consider this kotiln code

fun enter(key: String) {

      if (disabled) {
         return
      }
      // lots of code
}

when i decompile kotlin bytecode to see what is the underlying java code i see this

public final void enter(@NotNull String key) {
      Intrinsics.checkParameterIsNotNull(key, "key");
      if(!disabled) {
          // lots of code moved inside inverted if      
      }
}

not a big deal just curious why inverting the if statement? i cant think of some low level performance trick that may be the reason for this

vach: I think this is the question to the authors of decompiler

i shall post somwhere else?

both ways to represent this logic are equivalent from any performance point of view. Why do you care?

It might be the decompiler tries to reduce nesting to make the code easier to understand. In your case it looks a bit silly, but it would do this for larger methods as well. http://codebetter.com/patricksmacchia/2008/03/07/a-simple-trick-to-code-better-and-to-increase-testability/

Siguard compiler exactly does the oposite

Kotlin compiler doesn’t generate Java, it generates bytecode. There is no such thing as

if

in bytecode, they are lower level constructs. So decompiler tries to reconstruct Java from bytecode it sees, and there are potentially a lot of ways to represent particular bytecode in equivalent Java syntax.

Ah right thanks Ilya