Allow constant folding of && and ||.

frog/leg/operations.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 interface Operation {
   
 }
 
 interface UnaryOperation extends Operation {
   /** Returns [:null:] if it was unable to fold the operation. */
@@ skipping 87 matching lines @@
 }
 
 class ShiftRightOperation extends BinaryIntOperation {
   const ShiftRightOperation();
   int foldInts(int left, int right) {
     if (right < 0) return null;
     return left >> right;
   }
 }
 
+class BinaryBoolOperation implements BinaryOperation {
+  const BinaryBoolOperation();
+  Constant fold(Constant left, Constant right) {

[Lasse Reichstein Nielsen, 2012/03/27 07:48:53]

This seems like a pretty weak folding, if it requires the right-hand-side to be
constant.
Is it not possible to fold if just the LHS is constant and the short-circuiting
value?

+    if (left.isBool() && right.isBool()) {
+      BoolConstant leftBool = left;
+      BoolConstant rightBool = right;
+      bool resultValue = foldBools(leftBool.value, rightBool.value);
+      return new BoolConstant(resultValue);
+    }
+    return null;

[Lasse Reichstein Nielsen, 2012/03/27 07:48:53]

If left or right are not boolean, you can still fold, since any non-boolean is
converted to false.

+  }
+
+  abstract bool foldBools(bool left, bool right);
+}
+
+class BooleanAnd extends BinaryBoolOperation {
+  const BooleanAnd();
+  bool foldBools(bool left, bool right) => left && right;
+}
+
+class BooleanOr extends BinaryBoolOperation {
+  const BooleanOr();
+  bool foldBools(bool left, bool right) => left || right;
+}
+
 class ArithmeticNumOperation implements BinaryOperation {
   const ArithmeticNumOperation();
   Constant fold(Constant left, Constant right) {
     if (left.isNum() && right.isNum()) {
       NumConstant leftNum = left;
       NumConstant rightNum = right;
       num foldedValue;
       if (left.isInt() && right.isInt()) {
         foldedValue = foldInts(leftNum.value, rightNum.value);
       } else {
@@ skipping 127 matching lines @@
     return new BoolConstant(left == right);
   }
 }
 
 class IdentityOperation implements BinaryOperation {
   const IdentityOperation();
   Constant fold(Constant left, Constant right) {
     return new BoolConstant(left == right);
   }
 }