Start propagating non-primitive types in the backend, and fold instructions that know about the typ…

lib/compiler/implementation/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 {
-  
+  final SourceString name;
+  bool isUserDefinable();
 }
 
 interface UnaryOperation extends Operation {
   /** Returns [:null:] if it was unable to fold the operation. */
   Constant fold(Constant constant);
 }
 
 class BitNotOperation implements UnaryOperation {
+  final SourceString name = const SourceString('~');
+  bool isUserDefinable() => true;
   const BitNotOperation();
   Constant fold(Constant constant) {
     if (constant.isInt()) {
       IntConstant intConstant = constant;
       return new IntConstant(~intConstant.value);
     }
     return null;
   }
 }
 
 class NegateOperation implements UnaryOperation {
+  final SourceString name = const SourceString('negate');
+  bool isUserDefinable() => true;
   const NegateOperation();
   Constant fold(Constant constant) {
     if (constant.isInt()) {
       IntConstant intConstant = constant;
       return new IntConstant(-intConstant.value);
     }
     if (constant.isDouble()) {
       DoubleConstant doubleConstant = constant;
       return new DoubleConstant(-doubleConstant.value);
     }
     return null;
   }
 }
 
 class NotOperation implements UnaryOperation {
+  final SourceString name = const SourceString('!');
+  bool isUserDefinable() => true;
   const NotOperation();
   Constant fold(Constant constant) {
     if (constant.isBool()) {
       BoolConstant boolConstant = constant;
       return boolConstant.negate();
     }
     return null;
   }
 }
 
 interface BinaryOperation extends Operation {
   /** Returns [:null:] if it was unable to fold the operation. */
   Constant fold(Constant left, Constant right);
 }
 
 /**
  * Operations that only work if both arguments are integers.
  */
 class BinaryIntOperation implements BinaryOperation {
+  bool isUserDefinable() => true;
   const BinaryIntOperation();
   Constant fold(Constant left, Constant right) {
     if (left.isInt() && right.isInt()) {
       IntConstant leftInt = left;
       IntConstant rightInt = right;
       int resultValue = foldInts(leftInt.value, rightInt.value);
       if (resultValue === null) return null;
       return new IntConstant(resultValue);
     }
     return null;
   }
 
   abstract int foldInts(int left, int right); 
 }
 
 class BitOrOperation extends BinaryIntOperation {
+  final SourceString name = const SourceString('|');
   const BitOrOperation();
   int foldInts(int left, int right)  => left | right;
 }
 
 class BitAndOperation extends BinaryIntOperation {
+  final SourceString name = const SourceString('&');
   const BitAndOperation();
   int foldInts(int left, int right) => left & right;
 }
 
 class BitXorOperation extends BinaryIntOperation {
+  final SourceString name = const SourceString('^');
   const BitXorOperation();
   int foldInts(int left, int right) => left ^ right;
 }
 
 class ShiftLeftOperation extends BinaryIntOperation {
+  final SourceString name = const SourceString('<<');
   const ShiftLeftOperation();
   int foldInts(int left, int right) {
     // TODO(floitsch): find a better way to guard against excessive shifts to
     // the left.
     if (right > 100 || right < 0) return null;
     return left << right;
   }
 }
 
 class ShiftRightOperation extends BinaryIntOperation {
+  final SourceString name = const SourceString('>>');
   const ShiftRightOperation();
   int foldInts(int left, int right) {
     if (right < 0) return null;
     return left >> right;
   }
 }
 
 class BinaryBoolOperation implements BinaryOperation {
+  bool isUserDefinable() => false;
   const BinaryBoolOperation();
   Constant fold(Constant left, Constant right) {
     if (left.isBool() && right.isBool()) {
       BoolConstant leftBool = left;
       BoolConstant rightBool = right;
       bool resultValue = foldBools(leftBool.value, rightBool.value);
       return new BoolConstant(resultValue);
     }
     return null;
   }
 
   abstract bool foldBools(bool left, bool right);
 }
 
 class BooleanAnd extends BinaryBoolOperation {
+  final SourceString name = const SourceString('&&');
   const BooleanAnd();
   bool foldBools(bool left, bool right) => left && right;
 }
 
 class BooleanOr extends BinaryBoolOperation {
+  final SourceString name = const SourceString('||');
   const BooleanOr();
   bool foldBools(bool left, bool right) => left || right;
 }
 
 class ArithmeticNumOperation implements BinaryOperation {
+  bool isUserDefinable() => true;
   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 {
         foldedValue = foldNums(leftNum.value, rightNum.value);
       }
       // A division by 0 means that we might not have a folded value.
       if (foldedValue === null) return null;
       if (left.isInt() && right.isInt() && !isDivide()) {
         assert(foldedValue is int);
         return new IntConstant(foldedValue);
       } else {
         return new DoubleConstant(foldedValue);
       }
     }
   }
 
   bool isDivide() => false;
   num foldInts(int left, int right) => foldNums(left, right);
   abstract num foldNums(num left, num right);
 }
 
 class SubtractOperation extends ArithmeticNumOperation {
+  final SourceString name = const SourceString('-');
   const SubtractOperation();
   num foldNums(num left, num right) => left - right;
 }
 
 class MultiplyOperation extends ArithmeticNumOperation {
+  final SourceString name = const SourceString('*');
   const MultiplyOperation();
   num foldNums(num left, num right) => left * right;
 }
 
 class ModuloOperation extends ArithmeticNumOperation {
+  final SourceString name = const SourceString('%');
   const ModuloOperation();
   int foldInts(int left, int right) {
     if (right == 0) return null;
     return left % right;
   }
   num foldNums(num left, num right) => left % right;
 }
 
 class TruncatingDivideOperation extends ArithmeticNumOperation {
+  final SourceString name = const SourceString('~/');
   const TruncatingDivideOperation();
   int foldInts(int left, int right) {
     if (right == 0) return null;
     return left ~/ right;
   }
   num foldNums(num left, num right) => left ~/ right;
 }
 
 class DivideOperation extends ArithmeticNumOperation {
+  final SourceString name = const SourceString('/');
   const DivideOperation();
   num foldNums(num left, num right) => left / right;
   bool isDivide() => true;
 }
 
 class AddOperation implements BinaryOperation {
+  final SourceString name = const SourceString('+');
+  bool isUserDefinable() => true;
   const AddOperation();
   Constant fold(Constant left, Constant right) {
     if (left.isInt() && right.isInt()) {
       IntConstant leftInt = left;
       IntConstant rightInt = right;
       return new IntConstant(leftInt.value + rightInt.value);
     } else if (left.isNum() && right.isNum()) {
       NumConstant leftNum = left;
       NumConstant rightNum = right;
       return new DoubleConstant(leftNum.value + rightNum.value);
@@ skipping 10 matching lines @@
             new ConsDartString(leftString.value, rightDartString);
         return new StringConstant(concatenated);        
       }
     } else {
       return null;
     }
   }
 }
 
 class RelationalNumOperation implements BinaryOperation {
+  bool isUserDefinable() => true;
   const RelationalNumOperation();
   Constant fold(Constant left, Constant right) {
     if (left.isNum() && right.isNum()) {
       NumConstant leftNum = left;
       NumConstant rightNum = right;
       bool foldedValue = foldNums(leftNum.value, rightNum.value);
       assert(foldedValue != null);
       return new BoolConstant(foldedValue);
     }
   }
 
   abstract bool foldNums(num left, num right);
 }
 
 class LessOperation extends RelationalNumOperation {
+  final SourceString name = const SourceString('<');
   const LessOperation();
   bool foldNums(num left, num right) => left < right;
 }
 
 class LessEqualOperation extends RelationalNumOperation {
+  final SourceString name = const SourceString('<=');
   const LessEqualOperation();
   bool foldNums(num left, num right) => left <= right;
 }
 
 class GreaterOperation extends RelationalNumOperation {
+  final SourceString name = const SourceString('>');
   const GreaterOperation();
   bool foldNums(num left, num right) => left > right;
 }
 
 class GreaterEqualOperation extends RelationalNumOperation {
+  final SourceString name = const SourceString('>=');
   const GreaterEqualOperation();
   bool foldNums(num left, num right) => left >= right;
 }
 
 class EqualsOperation implements BinaryOperation {
+  final SourceString name = const SourceString('==');
+  bool isUserDefinable() => true;
   const EqualsOperation();
   Constant fold(Constant left, Constant right) {
     if (left.isNum() && right.isNum()) {
       // Numbers need to be treated specially because: NaN != NaN, -0.0 == 0.0,
       // and 1 == 1.0.
       NumConstant leftNum = left;
       NumConstant rightNum = right;
       return new BoolConstant(leftNum.value == rightNum.value);
     }
     if (left.isConstructedObject()) {
       // Unless we know that the user-defined object does not implement the
       // equality operator we cannot fold here.
       return null;
     }
     return new BoolConstant(left == right);
   }
 }
 
 class IdentityOperation implements BinaryOperation {
+  final SourceString name = const SourceString('===');
+  bool isUserDefinable() => false;
   const IdentityOperation();
   Constant fold(Constant left, Constant right) {
     return new BoolConstant(left == right);
   }
 }