Imperfect Short-Circuit Evaluation

[kevinthenerd]

Short-circuit evaluation in Java is imperfect. The code below breaks if I remove the method declarations or if I change the left-to-right order of the conditionals.

public class pears {
  public static void main(String[] args) {
    if (!(0==1 && unicorn()==pixiedust())) {
      System.out.println("The short-circuit evaluation worked!");
    }
    if (1==1 || unicorn()==pixiedust()) {
      System.out.println("The short-circuit evaluation worked!");
    }
  }
  public static int unicorn() {
    return 1/0;
  }
  public static int pixiedust() {
    return -1/0;
  }
}

This leads me to two higher questions about programming in general.

1. Do all interpreters or JIT compilers do a full syntax check before looking for this sort of optimization? (Is syntax-checking always a separate process before run-time optimization?)
2. Is short-circuit evaluation always performed left-to-right? Do any modern compilers ignore critical errors if the code can correctly continue without them?

 

[kevinthenerd]

(Example was run on JavaSE-1.7)

 

[Cogman]

Short-circuit evaluation in Java is imperfect. The code below breaks if I remove the method declarations or if I change the left-to-right order of the conditionals.

public class pears {
  public static void main(String[] args) {
    if (!(0==1 && unicorn()==pixiedust())) {
      System.out.println("The short-circuit evaluation worked!");
    }
    if (1==1 || unicorn()==pixiedust()) {
      System.out.println("The short-circuit evaluation worked!");
    }
  }
  public static int unicorn() {
    return 1/0;
  }
  public static int pixiedust() {
    return -1/0;
  }
}

This leads me to two higher questions about programming in general.

1. Do all interpreters or JIT compilers do a full syntax check before looking for this sort of optimization? (Is syntax-checking always a separate process before run-time optimization?)
2. Is short-circuit evaluation always performed left-to-right? Do any modern compilers ignore critical errors if the code can correctly continue without them?

1. Most compilers WON'T do this optimization because it changes the way the code behaves. Compilers are supposed to make the code behave exactly as written. That being said, code does not compile if there is a syntax error.
2. Depends on the language, in C like languages (such as Java) yes. Here is an example.

Object val = null;
if (val != null && val.hasMagic())
doStuff();

This is a common sort of expression in languages like java and c++. You first check to see if the object exists, then you use a function that is contained in the object. Reversing the order causes things to break.

 

[DaveSimmons]

The code x = 1/0 ; does not contain a syntax error, it is perfectly valid code. It's just code that at run-time will always generate an arithmetic exception.

Some compilers don't bother to save you from yourself when writing silly code like that because the code that people write for production use will be something like x = y / z ; where the values of y and z are not known in advance.

Microsoft's C++ does catch this: error C2124: divide or mod by zero

 

[Leros]

The code x = 1/0 ; does not contain a syntax error, it is perfectly valid code. It's just code that at run-time will always generate an arithmetic exception.

Some compilers don't bother to save you from yourself when writing silly code like that because the code that people write for production use will be something like x = y / z ; where the values of y and z are not known in advance.

Microsoft's C++ does catch this: error C2124: divide or mod by zero

You missed the point. Those functions should never get called due to short circuit evaluation.

 

[DaveSimmons]

> You missed the point. Those functions should never get called due to short circuit evaluation.

The OP said:
"The code below breaks if I remove the method declarations or if I change the left-to-right order of the conditionals."

Short-circuit evaluation is still working properly if the divide-by-zero exception only happens when you move the functions left of the other conditions.


OP then added:
"1. Do all interpreters or JIT compilers do a full syntax check before looking for this sort of optimization? (Is syntax-checking always a separate process before run-time optimization?)
2. Is short-circuit evaluation always performed left-to-right? Do any modern compilers ignore critical errors if the code can correctly continue without them?"

Perhaps I misread the questions, but OP seemed to be thinking that the compiler would be evaluating all tests at once instead of left-to-right, and should have treated "1 / 0" as a syntax errror.

 

[Ken g6]

In general, it's best to avoid running functions in a conditional that have "side effects". Throwing an exception counts as a side effect. If you want to ensure that all parts of a conditional run, i.e. not short-circuit the evaluation, then use a single "&" or "|".

 

[Cogman]

In general, it's best to avoid running functions in a conditional that have "side effects". Throwing an exception counts as a side effect. If you want to ensure that all parts of a conditional run, i.e. not short-circuit the evaluation, then use a single "&" or "|".

One minor addition, & and && don't work the same, they should be used with caution. For example, 1 && 2 == 1, 1 & 2 == 0. When used for logic, & should only be used on stuff that evals to 1 or 0.... Well, unless you understand how a bitwise and is working.

 

[PhatoseAlpha]

Short circuit evaluation is not short circuit compiling. Even if the compiler were to be able to recognize that 1 never equals zero, it still has to parse the other side of the function simply to determine where the && function ends.

And I'm fairly certain that any compiler will do syntax checking before it does any compiling, let alone performance optimizations. If it didn't, maintenance programmers everywhere would be calling for crucifixions. I don't know of any language where you can have invalid code in your program and still have it compile.