Remove unused API.

dart/sdk/lib/_internal/compiler/implementation/constant_system_dart.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.
 
 part of dart2js;
 
 const DART_CONSTANT_SYSTEM = const DartConstantSystem();
 
 class BitNotOperation implements UnaryOperation {
   final String name = '~';
-  bool isUserDefinable() => true;
   const BitNotOperation();
   Constant fold(Constant constant) {
     if (constant.isInt()) {
       IntConstant intConstant = constant;
       return DART_CONSTANT_SYSTEM.createInt(~intConstant.value);
     }
     return null;
   }
-  apply(value) => ~value;

[Johnni Winther, 2013/12/03 11:52:31]

Remove only together with UnaryOperation.apply.

 }
 
 class NegateOperation implements UnaryOperation {
   final String name = 'negate';
-  bool isUserDefinable() => true;
   const NegateOperation();
   Constant fold(Constant constant) {
     if (constant.isInt()) {
       IntConstant intConstant = constant;
       return DART_CONSTANT_SYSTEM.createInt(-intConstant.value);
     }
     if (constant.isDouble()) {
       DoubleConstant doubleConstant = constant;
       return DART_CONSTANT_SYSTEM.createDouble(-doubleConstant.value);
     }
     return null;
   }
-  apply(value) => -value;

[Johnni Winther, 2013/12/03 11:52:31]

Remove only together with UnaryOperation.apply.

 }
 
 class NotOperation implements UnaryOperation {
   final String name = '!';
-  bool isUserDefinable() => true;
   const NotOperation();
   Constant fold(Constant constant) {
     if (constant.isBool()) {
       BoolConstant boolConstant = constant;
       return DART_CONSTANT_SYSTEM.createBool(!boolConstant.value);
     }
     return null;
   }
-  apply(value) => !value;

[Johnni Winther, 2013/12/03 11:52:31]

Remove only together with UnaryOperation.apply.

 }
 
 /**
  * Operations that only work if both arguments are integers.
  */
 abstract class BinaryBitOperation implements BinaryOperation {
-  bool isUserDefinable() => true;
   const BinaryBitOperation();
   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 DART_CONSTANT_SYSTEM.createInt(resultValue);
     }
     return null;
@@ skipping 39 matching lines @@
   final String name = '>>';
   const ShiftRightOperation();
   int foldInts(int left, int right) {
     if (right < 0) return null;
     return left >> right;
   }
   apply(left, right) => left >> right;
 }
 
 abstract 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 DART_CONSTANT_SYSTEM.createBool(resultValue);
     }
     return null;
   }
 
   bool foldBools(bool left, bool right);
 }
 
 class BooleanAndOperation extends BinaryBoolOperation {
   final String name = '&&';
   const BooleanAndOperation();
   bool foldBools(bool left, bool right) => left && right;
   apply(left, right) => left && right;
 }
 
 class BooleanOrOperation extends BinaryBoolOperation {
   final String name = '||';
   const BooleanOrOperation();
   bool foldBools(bool left, bool right) => left || right;
   apply(left, right) => left || right;
 }
 
 abstract 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);
@@ skipping 61 matching lines @@
 class DivideOperation extends ArithmeticNumOperation {
   final String name = '/';
   const DivideOperation();
   num foldNums(num left, num right) => left / right;
   bool isDivide() => true;
   apply(left, right) => left / right;
 }
 
 class AddOperation implements BinaryOperation {
   final String name = '+';
-  bool isUserDefinable() => true;
   const AddOperation();
   Constant fold(Constant left, Constant right) {
     if (left.isInt() && right.isInt()) {
       IntConstant leftInt = left;
       IntConstant rightInt = right;
       int result = leftInt.value + rightInt.value;
       return DART_CONSTANT_SYSTEM.createInt(result);
     } else if (left.isNum() && right.isNum()) {
       NumConstant leftNum = left;
       NumConstant rightNum = right;
       double result = leftNum.value + rightNum.value;
       return DART_CONSTANT_SYSTEM.createDouble(result);
     } else {
       return null;
     }
   }
   apply(left, right) => left + right;
 }
 
 abstract 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 DART_CONSTANT_SYSTEM.createBool(foldedValue);
     }
   }
@@ skipping 24 matching lines @@
 
 class GreaterEqualOperation extends RelationalNumOperation {
   final String name = '>=';
   const GreaterEqualOperation();
   bool foldNums(num left, num right) => left >= right;
   apply(left, right) => left >= right;
 }
 
 class EqualsOperation implements BinaryOperation {
   final String name = '==';
-  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;
       bool result = leftNum.value == rightNum.value;
       return DART_CONSTANT_SYSTEM.createBool(result);
     }
     if (left.isConstructedObject()) {
       // Unless we know that the user-defined object does not implement the
       // equality operator we cannot fold here.
       return null;
     }
     return DART_CONSTANT_SYSTEM.createBool(left == right);
   }
   apply(left, right) => left == right;
 }
 
 class IdentityOperation implements BinaryOperation {
   final String name = '===';
-  bool isUserDefinable() => false;
   const IdentityOperation();
   BoolConstant fold(Constant left, Constant right) {
     // In order to preserve runtime semantics which says that NaN !== NaN don't
     // constant fold NaN === NaN. Otherwise the output depends on inlined
     // variables and other optimizations.
     if (left.isNaN() && right.isNaN()) return null;
     return DART_CONSTANT_SYSTEM.createBool(left == right);
   }
   apply(left, right) => identical(left, right);
 }
@@ skipping 39 matching lines @@
   bool isInt(Constant constant) => constant.isInt();
   bool isDouble(Constant constant) => constant.isDouble();
   bool isString(Constant constant) => constant.isString();
   bool isBool(Constant constant) => constant.isBool();
   bool isNull(Constant constant) => constant.isNull();
 
   bool isSubtype(Compiler compiler, DartType s, DartType t) {
     return compiler.types.isSubtype(s, t);
   }
 }