diff --git a/dev/core/src/com/google/gwt/dev/jjs/ast/JBlock.java b/dev/core/src/com/google/gwt/dev/jjs/ast/JBlock.java
index 3ab2e84..4d1b106 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/ast/JBlock.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/ast/JBlock.java
@@ -18,6 +18,7 @@
 import com.google.gwt.dev.jjs.SourceInfo;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 
 /**
@@ -27,8 +28,9 @@
 
   private final List<JStatement> statements = new ArrayList<JStatement>();
 
-  public JBlock(SourceInfo info) {
+  public JBlock(SourceInfo info, JStatement... statements) {
     super(info);
+    this.statements.addAll(Arrays.asList(statements));
   }
 
   /**
diff --git a/dev/core/src/com/google/gwt/dev/jjs/impl/DeadCodeElimination.java b/dev/core/src/com/google/gwt/dev/jjs/impl/DeadCodeElimination.java
index e6cc1ef..dae5abb 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/impl/DeadCodeElimination.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/impl/DeadCodeElimination.java
@@ -202,10 +202,10 @@
 
       switch (op) {
         case AND:
-          maybeReplaceMe(x, Simplifier.and(x), ctx);
+          maybeReplaceMe(x, Simplifier.simplifyAnd(x), ctx);
           break;
         case OR:
-          maybeReplaceMe(x, Simplifier.or(x), ctx);
+          maybeReplaceMe(x, Simplifier.simplifyOr(x), ctx);
           break;
         case BIT_XOR:
           simplifyXor(lhs, rhs, ctx);
@@ -315,12 +315,12 @@
 
     @Override
     public void endVisit(JCastOperation x, Context ctx) {
-      maybeReplaceMe(x, Simplifier.cast(x), ctx);
+      maybeReplaceMe(x, Simplifier.simplifyCast(x), ctx);
     }
 
     @Override
     public void endVisit(JConditional x, Context ctx) {
-      maybeReplaceMe(x, Simplifier.conditional(x), ctx);
+      maybeReplaceMe(x, Simplifier.simplifyConditional(x), ctx);
     }
 
     @Override
@@ -340,7 +340,7 @@
 
         // If false, replace do with do's body
         if (!booleanLiteral.getValue()) {
-          if (Simplifier.isEmpty(x.getBody())) {
+          if (JjsUtils.isEmptyBlock(x.getBody())) {
             ctx.removeMe();
           } else { // Unless it contains break/continue statements
             FindBreakContinueStatementsVisitor visitor = new FindBreakContinueStatementsVisitor();
@@ -429,7 +429,8 @@
      */
     @Override
     public void endVisit(JIfStatement x, Context ctx) {
-      maybeReplaceMe(x, Simplifier.ifStatement(x, getCurrentMethod()), ctx);
+      JType methodReturnType = getCurrentMethod() != null ? getCurrentMethod().getType() : null;
+      maybeReplaceMe(x, Simplifier.simplifyIfStatement(x, methodReturnType), ctx);
     }
 
     /**
@@ -651,7 +652,7 @@
       }
 
       if (x.getOp() == JUnaryOperator.NOT) {
-        maybeReplaceMe(x, Simplifier.not(x), ctx);
+        maybeReplaceMe(x, Simplifier.simplifyNot(x), ctx);
         return;
       } else if (x.getOp() == JUnaryOperator.NEG) {
         maybeReplaceMe(x, simplifyNegate(x, x.getArg()), ctx);
@@ -708,9 +709,9 @@
       }
 
       // Compute properties regarding the state of this try statement
-      boolean noTry = Simplifier.isEmpty(x.getTryBlock());
+      boolean noTry = JjsUtils.isEmptyBlock(x.getTryBlock());
       boolean noCatch = catchClauses.size() == 0;
-      boolean noFinally = Simplifier.isEmpty(x.getFinallyBlock());
+      boolean noFinally = JjsUtils.isEmptyBlock(x.getFinallyBlock());
 
       if (noTry) {
         // 2) Prune try statements with no body.
diff --git a/dev/core/src/com/google/gwt/dev/jjs/impl/JjsUtils.java b/dev/core/src/com/google/gwt/dev/jjs/impl/JjsUtils.java
index 61ade42..e0a878e 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/impl/JjsUtils.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/impl/JjsUtils.java
@@ -453,6 +453,16 @@
           .put(JStringLiteral.class, LiteralTranslators.STRING_LITERAL_TRANSLATOR)
           .build();
 
+  /**
+   * Return true if the statement is an empty block.
+   */
+  public static boolean isEmptyBlock(JStatement stmt) {
+    if (stmt == null) {
+      return true;
+    }
+    return (stmt instanceof JBlock && ((JBlock) stmt).getStatements().isEmpty());
+  }
+
   private enum LiteralTranslators {
     BOOLEAN_LITERAL_TRANSLATOR() {
       @Override
diff --git a/dev/core/src/com/google/gwt/dev/jjs/impl/Simplifier.java b/dev/core/src/com/google/gwt/dev/jjs/impl/Simplifier.java
index 9c6e22e..d7dd069 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/impl/Simplifier.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/impl/Simplifier.java
@@ -25,14 +25,11 @@
 import com.google.gwt.dev.jjs.ast.JExpression;
 import com.google.gwt.dev.jjs.ast.JExpressionStatement;
 import com.google.gwt.dev.jjs.ast.JIfStatement;
-import com.google.gwt.dev.jjs.ast.JMethod;
-import com.google.gwt.dev.jjs.ast.JNode;
 import com.google.gwt.dev.jjs.ast.JPrefixOperation;
 import com.google.gwt.dev.jjs.ast.JPrimitiveType;
 import com.google.gwt.dev.jjs.ast.JReturnStatement;
 import com.google.gwt.dev.jjs.ast.JStatement;
 import com.google.gwt.dev.jjs.ast.JType;
-import com.google.gwt.dev.jjs.ast.JUnaryOperation;
 import com.google.gwt.dev.jjs.ast.JUnaryOperator;
 import com.google.gwt.dev.jjs.ast.JValueLiteral;
 import com.google.gwt.dev.jjs.ast.js.JMultiExpression;
@@ -46,25 +43,18 @@
  * the arguments are assumed to already be simplified as much as possible.
  */
 public class Simplifier {
-  /**
-   * TODO: if the AST were normalized, we wouldn't need this.
-   */
-  public static boolean isEmpty(JStatement stmt) {
-    if (stmt == null) {
-      return true;
-    }
-    return (stmt instanceof JBlock && ((JBlock) stmt).getStatements().isEmpty());
-  }
 
   /**
    * Negate the supplied expression if negating it makes the expression shorter.
    * Otherwise, return null.
    */
-  private static JExpression maybeUnflipBoolean(JExpression expr) {
-    if (expr instanceof JUnaryOperation) {
-      JUnaryOperation unop = (JUnaryOperation) expr;
-      if (unop.getOp() == JUnaryOperator.NOT) {
-        return unop.getArg();
+  private static JExpression maybeGetNegatedExpressionArgument(JExpression expression) {
+    if (expression instanceof JPrefixOperation) {
+      JPrefixOperation prefixOperation = (JPrefixOperation) expression;
+      if (prefixOperation.getOp() == JUnaryOperator.NOT
+          // Don't flip negations on floating point comparisons
+          && !isFloatingPointComparison(prefixOperation.getArg())) {
+        return prefixOperation.getArg();
       }
     }
     return null;
@@ -98,7 +88,7 @@
    * @return the simplified expression.
    */
   public static JExpression cast(JType type, JExpression exp) {
-    return castImpl(null, exp.getSourceInfo(), type, exp);
+    return simplifyCast(new JCastOperation(exp.getSourceInfo(), type, exp));
   }
 
   /**
@@ -109,37 +99,36 @@
    * (A) (a,b) -> (a, (A) b)
    * </pre>
    *
-   * @param exp a JCastOperation to be simplified.
+   * @param castExpression a JCastOperation to be simplified.
    * @return the simplified expression if a simplification was possible; <code>exp</code> otherwise.
    */
-  public static JExpression cast(JCastOperation exp) {
-    return castImpl(exp, exp.getSourceInfo(), exp.getCastType(), exp.getExpr());
-  }
+  public static JExpression simplifyCast(JCastOperation castExpression) {
+    SourceInfo info = castExpression.getSourceInfo();
+    JType type = castExpression.getCastType();
+    JExpression argument = castExpression.getExpr();
 
-  private static JExpression castImpl(JExpression original, SourceInfo info, JType type,
-      JExpression exp) {
-    info = getBestSourceInfo(original, info, exp);
-    if (exp instanceof JMultiExpression) {
-      // (T)(a,b,c) -> a,b,(T) c
-      JMultiExpression expMulti = (JMultiExpression) exp;
-      JMultiExpression newMulti = new JMultiExpression(info);
-      newMulti.addExpressions(allButLast(expMulti.getExpressions()));
-      newMulti.addExpressions(castImpl(null, info, type, last(expMulti.getExpressions())));
-      // TODO(rluble): immediately simplify the resulting multi.
-      // TODO(rluble): refactor common outward JMultiExpression movement.
-      return newMulti;
-    }
-    if (type == exp.getType()) {
-      return exp;
+    if (type == argument.getType()) {
+      return argument;
     }
 
-    if (type.isPrimitiveType() && (exp instanceof JValueLiteral)) {
+    if (argument instanceof JMultiExpression) {
+      // (T) (a, b, c) -> (a, b,(T) c)
+      JMultiExpression argumentAsMultiExpression = (JMultiExpression) argument;
+      JMultiExpression simplifiedExpression = new JMultiExpression(info);
+      simplifiedExpression.addExpressions(allButLast(argumentAsMultiExpression.getExpressions()));
+      simplifiedExpression.addExpressions(
+          simplifyCast(
+              new JCastOperation(info, type, last(argumentAsMultiExpression.getExpressions()))));
+      return simplifiedExpression;
+    }
+
+    if (type.isPrimitiveType() && (argument instanceof JValueLiteral)) {
       // Statically evaluate casting literals.
       JPrimitiveType primitiveType = (JPrimitiveType) type;
-      JValueLiteral expLit = (JValueLiteral) exp;
-      JValueLiteral casted = primitiveType.coerce(expLit);
-      if (casted != null) {
-        return casted;
+      JValueLiteral valueLiteral = (JValueLiteral) argument;
+      JValueLiteral simplifiedExpression = primitiveType.coerce(valueLiteral);
+      if (simplifiedExpression != null) {
+        return simplifiedExpression;
       }
     }
 
@@ -149,18 +138,14 @@
      * of concat.
      */
     if (type == JPrimitiveType.INT) {
-      JType expType = exp.getType();
-      if ((expType == JPrimitiveType.SHORT)
-          || (expType == JPrimitiveType.BYTE)) {
-        return exp;
+      if ((argument.getType() == JPrimitiveType.SHORT)
+          || (argument.getType() == JPrimitiveType.BYTE)) {
+        return argument;
       }
     }
 
     // no simplification made
-    if (original != null) {
-      return original;
-    }
-    return new JCastOperation(info, type, exp);
+    return castExpression;
   }
 
   /**
@@ -177,71 +162,65 @@
    * !cond ? then : else -> cond ? else : then
    * </pre>
    *
-   * @param exp a JCondintional to be simplified.
+   * @param expression a JCondintional to be simplified.
    * @return the simplified expression if a simplification was possible; <code>exp</code> otherwise.
    */
-  public static JExpression conditional(JConditional exp) {
-    return conditionalImpl(exp, exp.getSourceInfo(), exp.getType(), exp.getIfTest(),
-        exp.getThenExpr(), exp.getElseExpr());
-  }
-
-  private static JExpression conditionalImpl(JConditional original, SourceInfo info, JType type,
-      JExpression condExpr, JExpression thenExpr, JExpression elseExpr) {
-    info = getBestSourceInfo(original, info, condExpr);
-    if (condExpr instanceof JMultiExpression) {
+  public static JExpression simplifyConditional(JConditional expression) {
+    SourceInfo info = expression.getSourceInfo();
+    JType type = expression.getType();
+    JExpression conditionExpression = expression.getIfTest();
+    JExpression thenExpression = expression.getThenExpr();
+    JExpression elseExpression = expression.getElseExpr();
+    if (conditionExpression instanceof JMultiExpression) {
       // (a,b,c)?d:e -> a,b,(c?d:e)
-      // TODO(spoon): do this outward multi movement for all AST nodes
-      JMultiExpression condMulti = (JMultiExpression) condExpr;
-      JMultiExpression newMulti = new JMultiExpression(info);
-      newMulti.addExpressions(allButLast(condMulti.getExpressions()));
-      newMulti.addExpressions(conditionalImpl(null, info, type, last(condMulti.getExpressions()),
-          thenExpr, elseExpr));
-      // TODO(spoon): immediately simplify the resulting multi
-      return newMulti;
+      JMultiExpression conditionMultiExpression = (JMultiExpression) conditionExpression;
+      JMultiExpression simplifiedExpression = new JMultiExpression(info);
+      simplifiedExpression.addExpressions(allButLast(conditionMultiExpression.getExpressions()));
+      simplifiedExpression.addExpressions(
+          simplifyConditional(
+              new JConditional(info, type, last(conditionMultiExpression.getExpressions()),
+                  thenExpression, elseExpression)));
+      return simplifiedExpression;
     }
-    if (condExpr instanceof JBooleanLiteral) {
-      if (((JBooleanLiteral) condExpr).getValue()) {
+    if (conditionExpression instanceof JBooleanLiteral) {
+      return ((JBooleanLiteral) conditionExpression).getValue()
         // e.g. (true ? then : else) -> then
-        return thenExpr;
-      } else {
+        ? thenExpression
         // e.g. (false ? then : else) -> else
-        return elseExpr;
-      }
-    } else if (thenExpr instanceof JBooleanLiteral) {
-      if (((JBooleanLiteral) thenExpr).getValue()) {
+        : elseExpression;
+   }
+
+   if (thenExpression instanceof JBooleanLiteral) {
+     return ((JBooleanLiteral) thenExpression).getValue()
         // e.g. (cond ? true : else) -> cond || else
-        return orImpl(null, info, condExpr, elseExpr);
-      } else {
+        ? or(info, conditionExpression, elseExpression)
         // e.g. (cond ? false : else) -> !cond && else
-        JExpression notCondExpr = notImpl(null, condExpr.getSourceInfo(), condExpr);
-        return andImpl(null, info, notCondExpr, elseExpr);
-      }
-    } else if (elseExpr instanceof JBooleanLiteral) {
-      if (((JBooleanLiteral) elseExpr).getValue()) {
-        // e.g. (cond ? then : true) -> !cond || then
-        JExpression notCondExpr = notImpl(null, condExpr.getSourceInfo(), condExpr);
-        return orImpl(null, info, notCondExpr, thenExpr);
-      } else {
-        // e.g. (cond ? then : false) -> cond && then
-        return andImpl(null, info, condExpr, thenExpr);
-      }
-    } else {
-      // e.g. (!cond ? then : else) -> (cond ? else : then)
-      JExpression unflipped = maybeUnflipBoolean(condExpr);
-      if (unflipped != null) {
-        return new JConditional(info, type, unflipped, elseExpr, thenExpr);
-      }
+        : and(info,
+            negate(conditionExpression.getSourceInfo(), conditionExpression),
+            elseExpression);
     }
 
-    // no simplification made
-    if (original != null) {
-      return original;
+    if (elseExpression instanceof JBooleanLiteral) {
+      return ((JBooleanLiteral) elseExpression).getValue()
+        // e.g. (cond ? then : true) -> !cond || then
+        ? or(info, negate(conditionExpression.getSourceInfo(), conditionExpression), thenExpression)
+        // e.g. (cond ? then : false) -> cond && then
+        : and(info, conditionExpression, thenExpression);
     }
-    return new JConditional(info, type, condExpr, thenExpr, elseExpr);
+
+      // e.g. (!cond ? then : else) -> (cond ? else : then)
+    JExpression negatedExpressionArgument = maybeGetNegatedExpressionArgument(conditionExpression);
+    if (negatedExpressionArgument != null) {
+      return simplifyConditional(
+          new JConditional(info, type, negatedExpressionArgument, elseExpression, thenExpression));
+    }
+
+    // Not simplified.
+    return expression;
   }
 
   /**
-   * Simplifies an ifthenelse statement.
+   * Simplifies an if then else statement.
    *
    * <pre>
    * if(a,b,c) d [else e] -> {a; b; if(c) d [else e]; }
@@ -253,147 +232,162 @@
    * if(c) ; [else ;] -> c
    *</pre>
    *
-   * @param stmt the statement to simplify.
-   * @param currentMethod the method where the statement resides
-   * @return the simplified statement if a simplification could be done and <code>stmt</code>
+   * @param ifStatement the statement to simplify.
+   * @param methodReturnType the return type of the method where the statement resides if any
+   * @return the simplified statement if a simplification could be done and <code>ifStatement</code>
    *         otherwise.
    */
-  public static JStatement ifStatement(JIfStatement stmt,  JMethod currentMethod) {
-    return ifStatementImpl(stmt, stmt.getSourceInfo(), stmt.getIfExpr(),
-        stmt.getThenStmt(), stmt.getElseStmt(), currentMethod);
-  }
-
-  private static JStatement ifStatementImpl(JIfStatement original, SourceInfo info,
-      JExpression condExpr, JStatement thenStmt,JStatement elseStmt, JMethod currentMethod) {
-    info = getBestSourceInfo(original, info, condExpr);
-    if (condExpr instanceof JMultiExpression) {
+  public static JStatement simplifyIfStatement(JIfStatement ifStatement, JType methodReturnType) {
+    SourceInfo info = ifStatement.getSourceInfo();
+    JExpression conditionExpression = ifStatement.getIfExpr();
+    JStatement thenStmt = ifStatement.getThenStmt();
+    JStatement elseStmt = ifStatement.getElseStmt();
+    if (conditionExpression instanceof JMultiExpression) {
       // if(a,b,c) d else e -> {a; b; if(c) d else e; }
-      JMultiExpression condMulti = (JMultiExpression) condExpr;
-      JBlock newBlock = new JBlock(info);
+      JMultiExpression condMulti = (JMultiExpression) conditionExpression;
+      JBlock simplifiedStatement = new JBlock(info);
       for (JExpression expr : allButLast(condMulti.getExpressions())) {
-        newBlock.addStmt(expr.makeStatement());
+        simplifiedStatement.addStmt(expr.makeStatement());
       }
-      newBlock.addStmt(ifStatementImpl(null, info, last(condMulti.getExpressions()), thenStmt,
-          elseStmt, currentMethod));
-      // TODO(spoon): immediately simplify the resulting block
-      return newBlock;
+      simplifiedStatement.addStmt(
+          simplifyIfStatement(
+              new JIfStatement(info, last(condMulti.getExpressions()), thenStmt, elseStmt),
+              methodReturnType));
+      return simplifiedStatement;
     }
 
-    if (condExpr instanceof JBooleanLiteral) {
-      JBooleanLiteral booleanLiteral = (JBooleanLiteral) condExpr;
-      boolean boolVal = booleanLiteral.getValue();
-      if (boolVal && !isEmpty(thenStmt)) {
+    if (conditionExpression instanceof JBooleanLiteral) {
+      boolean conditionValue = ((JBooleanLiteral) conditionExpression).getValue();
+      if (conditionValue && !JjsUtils.isEmptyBlock(thenStmt)) {
         // If true, replace myself with then statement
         return thenStmt;
-      } else if (!boolVal && !isEmpty(elseStmt)) {
+      } else if (!conditionValue && !JjsUtils.isEmptyBlock(elseStmt)) {
         // If false, replace myself with else statement
         return elseStmt;
       } else {
-        // just prune me
-        return condExpr.makeStatement();
+        // just prune me.
+        return conditionExpression.makeStatement();
       }
     }
 
-    if (isEmpty(thenStmt) && isEmpty(elseStmt)) {
-      return condExpr.makeStatement();
+    if (JjsUtils.isEmptyBlock(thenStmt) && JjsUtils.isEmptyBlock(elseStmt)) {
+      return conditionExpression.makeStatement();
     }
 
-    if (!isEmpty(elseStmt)) {
+    if (!JjsUtils.isEmptyBlock(elseStmt)) {
       // if (!cond) foo else bar -> if (cond) bar else foo
-      JExpression unflipped = Simplifier.maybeUnflipBoolean(condExpr);
-      if (unflipped != null) {
+      JExpression negationArugment =
+          Simplifier.maybeGetNegatedExpressionArgument(conditionExpression);
+      if (negationArugment != null) {
         // Force sub-parts to blocks, otherwise we break else-if chains.
         // TODO: this goes away when we normalize the Java AST properly.
         thenStmt = ensureBlock(thenStmt);
         elseStmt = ensureBlock(elseStmt);
-        return ifStatementImpl(null, info, unflipped, elseStmt, thenStmt, currentMethod);
+        return simplifyIfStatement(
+            new JIfStatement(info, negationArugment, elseStmt, thenStmt), methodReturnType);
       }
     }
 
     JStatement rewritenStatement =
-        rewriteIfIntoBoolean(info, condExpr, thenStmt, elseStmt, currentMethod);
+        rewriteIfStatementAsExpression(
+            info, conditionExpression, thenStmt, elseStmt, methodReturnType);
     if (rewritenStatement != null) {
       return rewritenStatement;
     }
 
     // no simplification made
-    if (original != null) {
-      return original;
-    }
-    return new JIfStatement(info, condExpr, thenStmt, elseStmt);
+    return ifStatement;
   }
 
   /**
    * Simplifies an negation expression.
    *
-   * if(a,b,c) d else e -> {a; b; if(c) d else e; }
+   * !(a > b) => a <= b
    *
-   * @param expr the expression to simplify.
+   * @param expression the expression to simplify.
    * @return the simplified expression if a simplification could be done and <code>expr</code>
    *         otherwise.
    */
-  public static JExpression not(JPrefixOperation expr) {
-    return notImpl(expr, expr.getSourceInfo(), expr.getArg());
+  public static JExpression simplifyNot(JPrefixOperation expression) {
+    JExpression argument = expression.getArg();
+    if (isFloatingPointComparison(argument)) {
+      // Don't negate floating point expression because it changes the values when NaNs are
+      // involved. E.g. !(Nan > 3) is not equivalent to (Nan <= 3).
+      return expression;
+    }
+    SourceInfo info = expression.getSourceInfo();
+    if (argument instanceof JMultiExpression) {
+      // !(a,b,c) -> (a,b,!c)
+      JMultiExpression multiExpression = (JMultiExpression) argument;
+      JMultiExpression simplifiedExpression = new JMultiExpression(info);
+      simplifiedExpression.addExpressions(allButLast(multiExpression.getExpressions()));
+      simplifiedExpression.addExpressions(negate(info, last(multiExpression.getExpressions())));
+      return simplifiedExpression;
+    }
+
+    if (argument instanceof JBinaryOperation) {
+      // try to invert the binary operator
+      JBinaryOperation binaryExpression = (JBinaryOperation) argument;
+      switch (binaryExpression.getOp()) {
+        case EQ:
+          // e.g. !(x == y) -> x != y
+          return new JBinaryOperation(info, binaryExpression.getType(), JBinaryOperator.NEQ,
+              binaryExpression.getLhs(), binaryExpression.getRhs());
+        case NEQ:
+          // e.g. !(x != y) -> x == y
+          return new JBinaryOperation(info, binaryExpression.getType(), JBinaryOperator.EQ,
+              binaryExpression.getLhs(), binaryExpression.getRhs());
+        case GT:
+          // e.g. !(x > y) -> x <= y
+          return new JBinaryOperation(info, binaryExpression.getType(), JBinaryOperator.LTE,
+              binaryExpression.getLhs(), binaryExpression.getRhs());
+        case LTE:
+          // e.g. !(x <= y) -> x > y
+          return new JBinaryOperation(info, binaryExpression.getType(), JBinaryOperator.GT,
+              binaryExpression.getLhs(), binaryExpression.getRhs());
+        case GTE:
+          // e.g. !(x >= y) -> x < y
+          return new JBinaryOperation(info, binaryExpression.getType(), JBinaryOperator.LT,
+              binaryExpression.getLhs(), binaryExpression.getRhs());
+        case LT:
+          // e.g. !(x < y) -> x >= y
+          return new JBinaryOperation(info, binaryExpression.getType(), JBinaryOperator.GTE,
+              binaryExpression.getLhs(), binaryExpression.getRhs());
+      }
+    }
+
+    if (argument instanceof JPrefixOperation) {
+      // try to invert the unary operator
+      JPrefixOperation prefixExpression = (JPrefixOperation) argument;
+      // e.g. !!x -> x
+      if (prefixExpression.getOp() == JUnaryOperator.NOT) {
+        return prefixExpression.getArg();
+      }
+    }
+
+    if (argument instanceof JBooleanLiteral) {
+      JBooleanLiteral booleanLiteral = (JBooleanLiteral) argument;
+      return JBooleanLiteral.get(!booleanLiteral.getValue());
+    }
+    // no simplification made.
+    return expression;
   }
 
-  private static JExpression notImpl(JPrefixOperation original, SourceInfo info, JExpression arg) {
-    info = getBestSourceInfo(original, info, arg);
-    if (arg instanceof JMultiExpression) {
-      // !(a,b,c) -> (a,b,!c)
-      JMultiExpression argMulti = (JMultiExpression) arg;
-      JMultiExpression newMulti = new JMultiExpression(info);
-      newMulti.addExpressions(allButLast(argMulti.getExpressions()));
-      newMulti.addExpressions(notImpl(null, info, last(argMulti.getExpressions())));
-      // TODO(spoon): immediately simplify the newMulti
-      return newMulti;
+  private static boolean isFloatingPointComparison(JExpression expr) {
+    if (expr instanceof JBinaryOperation) {
+      JBinaryOperation binaryOperation = (JBinaryOperation) expr;
+      return
+          binaryOperation.getType() == JPrimitiveType.BOOLEAN
+          && (binaryOperation.getLhs().getType() == JPrimitiveType.FLOAT
+              || binaryOperation.getLhs().getType() == JPrimitiveType.DOUBLE
+              || binaryOperation.getRhs().getType() == JPrimitiveType.FLOAT
+              || binaryOperation.getRhs().getType() == JPrimitiveType.DOUBLE);
     }
-    if (arg instanceof JBinaryOperation) {
-      // try to invert the binary operator
-      JBinaryOperation argOp = (JBinaryOperation) arg;
-      JBinaryOperator op = argOp.getOp();
-      JBinaryOperator newOp = null;
-      if (op == JBinaryOperator.EQ) {
-        // e.g. !(x == y) -> x != y
-        newOp = JBinaryOperator.NEQ;
-      } else if (op == JBinaryOperator.NEQ) {
-        // e.g. !(x != y) -> x == y
-        newOp = JBinaryOperator.EQ;
-      } else if (op == JBinaryOperator.GT) {
-        // e.g. !(x > y) -> x <= y
-        newOp = JBinaryOperator.LTE;
-      } else if (op == JBinaryOperator.LTE) {
-        // e.g. !(x <= y) -> x > y
-        newOp = JBinaryOperator.GT;
-      } else if (op == JBinaryOperator.GTE) {
-        // e.g. !(x >= y) -> x < y
-        newOp = JBinaryOperator.LT;
-      } else if (op == JBinaryOperator.LT) {
-        // e.g. !(x < y) -> x >= y
-        newOp = JBinaryOperator.GTE;
-      }
-      if (newOp != null) {
-        JBinaryOperation newBinOp =
-            new JBinaryOperation(info, argOp.getType(), newOp, argOp.getLhs(), argOp.getRhs());
-        return newBinOp;
-      }
-    } else if (arg instanceof JPrefixOperation) {
-      // try to invert the unary operator
-      JPrefixOperation argOp = (JPrefixOperation) arg;
-      JUnaryOperator op = argOp.getOp();
-      // e.g. !!x -> x
-      if (op == JUnaryOperator.NOT) {
-        return argOp.getArg();
-      }
-    } else if (arg instanceof JBooleanLiteral) {
-      JBooleanLiteral booleanLit = (JBooleanLiteral) arg;
-      return JBooleanLiteral.get(!booleanLit.getValue());
-    }
+    return false;
+  }
 
-    // no simplification made
-    if (original != null) {
-      return original;
-    }
-    return new JPrefixOperation(info, JUnaryOperator.NOT, arg);
+  private static JExpression negate(SourceInfo info, JExpression argument) {
+    return simplifyNot(new JPrefixOperation(info, JUnaryOperator.NOT, argument));
   }
 
   /**
@@ -409,49 +403,45 @@
    * (a, b) && c -> (a, b && c)
    * </pre>
    *
-   * @param exp an AND JBinaryExpression to be simplified.
+   * @param expression an AND JBinaryExpression to be simplified.
    * @return the simplified expression if a simplification was possible; <code>exp</code> otherwise.
    *
    */
-  public static JExpression and(JBinaryOperation exp) {
-    assert exp.getOp() == JBinaryOperator.AND : "Simplifier.and was called with " + exp;
-    return andImpl(exp, null, exp.getLhs(), exp.getRhs());
-  }
-
-  private static JExpression andImpl(JBinaryOperation original, SourceInfo info, JExpression lhs,
-      JExpression rhs) {
-    info = getBestSourceInfo(original, info, lhs);
+  public static JExpression simplifyAnd(JBinaryOperation expression) {
+    assert expression.getOp() == JBinaryOperator.AND
+        : "Simplifier.and was called with " + expression;
+    JExpression lhs = expression.getLhs();
+    JExpression rhs = expression.getRhs();
+    SourceInfo info = expression.getSourceInfo();
     if (lhs instanceof JMultiExpression) {
       // (a,b,c)&&d -> a,b,(c&&d)
-      JMultiExpression lhsMulti = (JMultiExpression) lhs;
-      JMultiExpression newMulti = new JMultiExpression(info);
-      newMulti.addExpressions(allButLast(lhsMulti.getExpressions()));
-      newMulti.addExpressions(andImpl(null, info, last(lhsMulti.getExpressions()), rhs));
-      // TODO(rluble): immediately simplify the resulting multi.
-      // TODO(rluble): refactor common outward JMultiExpression movement.
-      return newMulti;
+      JMultiExpression lhsMultiExpression = (JMultiExpression) lhs;
+      JMultiExpression simplifiedExpression = new JMultiExpression(info);
+      simplifiedExpression.addExpressions(allButLast(lhsMultiExpression.getExpressions()));
+      simplifiedExpression.addExpressions(
+          and(info, last(lhsMultiExpression.getExpressions()), rhs));
+      return simplifiedExpression;
     }
     if (lhs instanceof JBooleanLiteral) {
-      JBooleanLiteral booleanLiteral = (JBooleanLiteral) lhs;
-      if (booleanLiteral.getValue()) {
-        return rhs;
-      } else {
-        return lhs;
-      }
+      return (((JBooleanLiteral) lhs).getValue()) ? rhs : lhs;
+    }
 
-    } else if (rhs instanceof JBooleanLiteral) {
-      JBooleanLiteral booleanLiteral = (JBooleanLiteral) rhs;
-      if (booleanLiteral.getValue()) {
+    if (rhs instanceof JBooleanLiteral) {
+      if (((JBooleanLiteral) rhs).getValue()) {
         return lhs;
       } else if (!lhs.hasSideEffects()) {
+        // Do not remove lhs if it had side effects
         return rhs;
       }
     }
-    // no simplification made
-    if (original != null) {
-      return original;
-    }
-    return new JBinaryOperation(info, rhs.getType(), JBinaryOperator.AND, lhs, rhs);
+
+    // no simplification made.
+    return expression;
+  }
+
+  private static JExpression and(SourceInfo info, JExpression lhs, JExpression rhs) {
+    return simplifyAnd(
+        new JBinaryOperation(info, JPrimitiveType.BOOLEAN, JBinaryOperator.AND, lhs, rhs));
   }
 
   /**
@@ -467,108 +457,81 @@
    * (a, b) || c -> (a, b || c)
    * </pre>
    *
-   * @param exp an OR JBinaryExpression to be simplified.
+   * @param expression an OR JBinaryExpression to be simplified.
    * @return the simplified expression if a simplification was possible; <code>exp</code> otherwise.
    *
    */
-  public static JExpression or(JBinaryOperation exp) {
-    assert exp.getOp() == JBinaryOperator.OR : "Simplifier.and was called with " + exp;
-    return orImpl(exp, null, exp.getLhs(), exp.getRhs());
-  }
-
-  private static JExpression orImpl(JBinaryOperation original, SourceInfo info, JExpression lhs,
-      JExpression rhs) {
-    info = getBestSourceInfo(original, info, lhs);
+  public static JExpression simplifyOr(JBinaryOperation expression) {
+    assert expression.getOp() == JBinaryOperator.OR
+        : "Simplifier.or was called with " + expression;
+    JExpression lhs = expression.getLhs();
+    JExpression rhs = expression.getRhs();
+    SourceInfo info = expression.getSourceInfo();
     if (lhs instanceof JMultiExpression) {
       // (a,b,c)|| d -> a,b,(c||d)
-      JMultiExpression lhsMulti = (JMultiExpression) lhs;
-      JMultiExpression newMulti = new JMultiExpression(info);
-      newMulti.addExpressions(allButLast(lhsMulti.getExpressions()));
-      newMulti.addExpressions(orImpl(null, info, last(lhsMulti.getExpressions()), rhs));
-      // TODO(rluble): immediately simplify the resulting multi.
-      // TODO(rluble): refactor common outward JMultiExpression movement.
-      return newMulti;
+      JMultiExpression lhsMultiExpression = (JMultiExpression) lhs;
+      JMultiExpression simplifiedExpression = new JMultiExpression(info);
+      simplifiedExpression.addExpressions(allButLast(lhsMultiExpression.getExpressions()));
+      simplifiedExpression.addExpressions(or(info, last(lhsMultiExpression.getExpressions()), rhs));
+      return simplifiedExpression;
     }
     if (lhs instanceof JBooleanLiteral) {
-      JBooleanLiteral booleanLiteral = (JBooleanLiteral) lhs;
-      if (booleanLiteral.getValue()) {
-        return lhs;
-      } else {
-        return rhs;
-      }
-    } else if (rhs instanceof JBooleanLiteral) {
-      JBooleanLiteral booleanLiteral = (JBooleanLiteral) rhs;
-      if (!booleanLiteral.getValue()) {
+      return ((JBooleanLiteral) lhs).getValue() ? lhs : rhs;
+    }
+
+    if (rhs instanceof JBooleanLiteral) {
+      if (!((JBooleanLiteral) rhs).getValue()) {
         return lhs;
       } else if (!lhs.hasSideEffects()) {
         return rhs;
       }
     }
-    // no simplification made
-    if (original != null) {
-      return original;
-    }
-    return new JBinaryOperation(info, rhs.getType(), JBinaryOperator.OR, lhs, rhs);
+    return expression;
   }
 
-  private static JStatement ensureBlock(JStatement stmt) {
-    if (stmt == null) {
+  private static JExpression or(SourceInfo info, JExpression lhs, JExpression rhs) {
+    return simplifyOr(
+        new JBinaryOperation(info, JPrimitiveType.BOOLEAN, JBinaryOperator.OR, lhs, rhs));
+  }
+
+  private static JStatement ensureBlock(JStatement statement) {
+    if (statement == null) {
       return null;
     }
-    if (!(stmt instanceof JBlock)) {
-      JBlock block = new JBlock(stmt.getSourceInfo());
-      block.addStmt(stmt);
-      stmt = block;
+    if (statement instanceof JBlock) {
+      return statement;
     }
-    return stmt;
+
+    return new JBlock(statement.getSourceInfo(), statement);
   }
 
-  private static JExpression extractExpression(JStatement stmt) {
-    if (stmt instanceof JExpressionStatement) {
-      JExpressionStatement statement = (JExpressionStatement) stmt;
-      return statement.getExpr();
+  private static JExpression extractExpression(JStatement statement) {
+    if (statement instanceof JExpressionStatement) {
+      return ((JExpressionStatement) statement).getExpr();
     }
 
     return null;
   }
 
-  private static JStatement extractSingleStatement(JStatement stmt) {
-    if (stmt instanceof JBlock) {
-      JBlock block = (JBlock) stmt;
+  private static JStatement extractSingleStatement(JStatement statement) {
+    if (statement instanceof JBlock) {
+      JBlock block = (JBlock) statement;
       if (block.getStatements().size() == 1) {
         return extractSingleStatement(block.getStatements().get(0));
       }
     }
 
-    return stmt;
+    return statement;
   }
 
-  /**
-   * Determine the best SourceInfo to use in a particular transformation.
-   *
-   * @param original the original node that is being transformed. Can be <code>null</code>.
-   * @param info an explicit SourceInfo that might be used, Can be <code>null</code>.
-   * @param defaultNode a node from where to obtain the SourceInfo.
-   * @return a SourceInfo chosen according to the following priority info>original>default.
-   */
-  private static SourceInfo getBestSourceInfo(JNode original, SourceInfo info, JNode defaultNode) {
-    if (info == null) {
-      if (original == null) {
-        info = defaultNode.getSourceInfo();
-      } else {
-        info = original.getSourceInfo();
-      }
-    }
-    return info;
-  }
-
-  private static JStatement rewriteIfIntoBoolean(SourceInfo sourceInfo, JExpression condExpr,
-      JStatement thenStmt, JStatement elseStmt, JMethod currentMethod) {
+  private static JStatement rewriteIfStatementAsExpression(SourceInfo sourceInfo,
+      JExpression conditionExpression, JStatement thenStmt, JStatement elseStmt,
+      JType methodReturnType) {
     thenStmt = extractSingleStatement(thenStmt);
     elseStmt = extractSingleStatement(elseStmt);
 
     if (thenStmt instanceof JReturnStatement && elseStmt instanceof JReturnStatement
-        && currentMethod != null) {
+        && methodReturnType != null) {
       // Special case
       // if () { return ..; } else { return ..; } =>
       // return ... ? ... : ...;
@@ -579,12 +542,10 @@
         return null;
       }
 
-      JConditional conditional =
-          new JConditional(sourceInfo, currentMethod.getType(), condExpr, thenExpression,
-              elseExpression);
-
-      JReturnStatement returnStatement = conditional.makeReturnStatement();
-      return returnStatement;
+      return
+          new JConditional(
+              sourceInfo, methodReturnType, conditionExpression, thenExpression, elseExpression
+          ).makeReturnStatement();
     }
 
     if (elseStmt != null) {
@@ -593,11 +554,10 @@
       JExpression elseExpression = extractExpression(elseStmt);
 
       if (thenExpression != null && elseExpression != null) {
-        JConditional conditional =
-            new JConditional(sourceInfo, JPrimitiveType.VOID, condExpr, thenExpression,
-                elseExpression);
-
-        return conditional.makeStatement();
+        return
+            new JConditional(
+                sourceInfo, JPrimitiveType.VOID, conditionExpression, thenExpression, elseExpression
+            ).makeStatement();
       }
     } else {
       // if () { } -> ... && ...;
@@ -606,17 +566,16 @@
       if (thenExpression != null) {
         JBinaryOperator binaryOperator = JBinaryOperator.AND;
 
-        JExpression unflipExpression = maybeUnflipBoolean(condExpr);
-        if (unflipExpression != null) {
-          condExpr = unflipExpression;
+        JExpression negationArgument = maybeGetNegatedExpressionArgument(conditionExpression);
+        if (negationArgument != null) {
+          conditionExpression = negationArgument;
           binaryOperator = JBinaryOperator.OR;
         }
 
-        JBinaryOperation binaryOperation =
-            new JBinaryOperation(sourceInfo, JPrimitiveType.VOID, binaryOperator, condExpr,
-                thenExpression);
-
-        return binaryOperation.makeStatement();
+        return
+            new JBinaryOperation(
+                sourceInfo, JPrimitiveType.VOID, binaryOperator, conditionExpression, thenExpression
+            ).makeStatement();
       }
     }
 
diff --git a/dev/core/test/com/google/gwt/dev/jjs/impl/DeadCodeEliminationTest.java b/dev/core/test/com/google/gwt/dev/jjs/impl/DeadCodeEliminationTest.java
index a7003ea..d639dcf 100644
--- a/dev/core/test/com/google/gwt/dev/jjs/impl/DeadCodeEliminationTest.java
+++ b/dev/core/test/com/google/gwt/dev/jjs/impl/DeadCodeEliminationTest.java
@@ -310,6 +310,39 @@
         "} while (false);");
   }
 
+  public void testNegationOptimizations() throws Exception {
+    optimize("boolean", "int a = 0; return !(a < 2);").intoString(
+        "int a = 0;",
+        "return a >= 2;");
+    optimize("boolean", "double a = 0; return !(a < 2);").intoString(
+    "double a = 0;",
+        "return !(a < 2);");
+    optimize("boolean", "float a = 0; return !(a == 2);").intoString(
+        "float a = 0;",
+        "return !(a == 2);");
+    optimize("void", "float a = 0; if (a == 2) {} else {a=3;}").intoString(
+    "float a = 0;",
+        "if (a == 2);",
+        "else {",
+        "  a = 3;",
+        "}");
+    optimize("void", "int a = 0; if (a == 2) {} else {a=3;}").intoString(
+        "int a = 0;",
+        "if (a == 2);",
+        "else {",
+        "  a = 3;",
+        "}");
+    optimize("void", "float a = 0; if (!(a == 2)) {} else {a=3;}").intoString(
+        "float a = 0;",
+        "if (!(a == 2));",
+        "else {",
+        "  a = 3;",
+        "}");
+    optimize("boolean", "int a = 0; return !(a == 2) ? false : a==3;").intoString(
+        "int a = 0;",
+        "return a == 2 && a == 3;");
+  }
+
   public void testMultiExpressionOptimization() throws Exception {
     runMethodInliner = true;
     addSnippetClassDecl(
diff --git a/user/test/com/google/gwt/dev/jjs/test/CompilerTest.java b/user/test/com/google/gwt/dev/jjs/test/CompilerTest.java
index cc52752..9d72028 100644
--- a/user/test/com/google/gwt/dev/jjs/test/CompilerTest.java
+++ b/user/test/com/google/gwt/dev/jjs/test/CompilerTest.java
@@ -1208,6 +1208,12 @@
 
     assertTrue(!!TRUE);
     assertFalse(!!FALSE);
+
+    double nan = Math.random() == 0 ? Double.NaN : Double.NaN;
+    assertFalse(nan == (0.0 / 0.0));
+    assertTrue(!(nan > 0));
+    assertTrue(!(nan < 0));
+    assertFalse(!!(nan > 0));
   }
 
   public void testNullFlow() {