Revert "Refactor constant part."

dart/frog/leg/ssa/nodes.dart

 // Copyright (c) 2011, 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 HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBailoutTarget(HBailoutTarget node);
   R visitBitAnd(HBitAnd node);
   R visitBitNot(HBitNot node);
   R visitBitOr(HBitOr node);
   R visitBitXor(HBitXor node);
   R visitBoolify(HBoolify node);
   R visitBoundsCheck(HBoundsCheck node);
   R visitBreak(HBreak node);
-  R visitConstant(HConstant node);
   R visitDivide(HDivide node);
   R visitEquals(HEquals node);
   R visitExit(HExit node);
   R visitFieldGet(HFieldGet node);
   R visitFieldSet(HFieldSet node);
   R visitForeign(HForeign node);
   R visitForeignNew(HForeignNew);
   R visitGoto(HGoto node);
   R visitGreater(HGreater node);
   R visitGreaterEqual(HGreaterEqual node);
   R visitIdentity(HIdentity node);
   R visitIf(HIf node);
   R visitIndex(HIndex node);
   R visitIndexAssign(HIndexAssign node);
   R visitIntegerCheck(HIntegerCheck node);
   R visitInvokeClosure(HInvokeClosure node);
   R visitInvokeDynamicGetter(HInvokeDynamicGetter node);
   R visitInvokeDynamicMethod(HInvokeDynamicMethod node);
   R visitInvokeDynamicSetter(HInvokeDynamicSetter node);
   R visitInvokeInterceptor(HInvokeInterceptor node);
   R visitInvokeStatic(HInvokeStatic node);
   R visitInvokeSuper(HInvokeSuper node);
   R visitIs(HIs node);
   R visitLess(HLess node);
   R visitLessEqual(HLessEqual node);
+  R visitLiteral(HLiteral node);
   R visitLiteralList(HLiteralList node);
   R visitLoad(HLoad node);
   R visitLocal(HLocal node);
   R visitLogicalOperator(HLogicalOperator node);
   R visitLoopBranch(HLoopBranch node);
   R visitModulo(HModulo node);
   R visitMultiply(HMultiply node);
   R visitNegate(HNegate node);
   R visitNot(HNot node);
   R visitParameterValue(HParameterValue node);
@@ skipping 58 matching lines @@
     currentBlock = node;
     visitInstructionList(node);
   }
 }
 
 class HGraph {
   HBasicBlock entry;
   HBasicBlock exit;
   final List<HBasicBlock> blocks;
 
-  // We canonicalize all constants used within a graph so we do not
+  // We canonicalize all literals used within a graph so we do not
   // have to worry about them for global value numbering.
-  Map<Constant, HConstant> constants;
+  HLiteral nullLiteral;
+  HLiteral trueLiteral;
+  HLiteral falseLiteral;
+  HLiteral nanLiteral;
+  HLiteral negativeZeroLiteral;
+  Map<int, HLiteral> intLiterals;
+  Map<double, HLiteral> doubleLiterals;
+  Map<num, HLiteral> numLiterals;
+  Map<String, HLiteral> stringLiterals;
 
-  HGraph()
-      : blocks = new List<HBasicBlock>(),
-        constants = new Map<Constant, HConstant>() {
+  HGraph() : blocks = new List<HBasicBlock>() {
     entry = addNewBlock();
     // The exit block will be added later, so it has an id that is
     // after all others in the system.
     exit = new HBasicBlock();
   }
 
   void addBlock(HBasicBlock block) {
     int id = blocks.length;
     block.id = id;
     blocks.add(block);
     assert(blocks[id] === block);
   }
 
   HBasicBlock addNewBlock() {
     HBasicBlock result = new HBasicBlock();
     addBlock(result);
     return result;
   }
 
   HBasicBlock addNewLoopHeaderBlock(List<SourceString> labels) {
     HBasicBlock result = addNewBlock();
     result.loopInformation = new HLoopInformation(result, labels);
     return result;
   }
 
-  static HType mapConstantTypeToSsaType(Constant constant) {
-    if (constant.isNull()) return HType.UNKNOWN;
-    if (constant.isBool()) return HType.BOOLEAN;
-    if (constant.isInt()) return HType.INTEGER;
-    if (constant.isDouble()) return HType.DOUBLE;
-    if (constant.isString()) return HType.STRING;
-    if (constant.isList()) return HType.ARRAY;
-    return HType.UNKNOWN;
-  }
-
-  HConstant addConstant(Constant constant) {
-    HConstant result = constants[constant];
+  HLiteral addNewLiteralInt(int value) {
+    if (intLiterals === null) intLiterals = new Map<int, HLiteral>();
+    HLiteral result = intLiterals[value];
     if (result === null) {
-      HType type = mapConstantTypeToSsaType(constant);
-      result = new HConstant.internal(constant, type);
+      result = new HLiteral.internal(value, HType.INTEGER);
       entry.addAtExit(result);
-      constants[constant] = result;
+      intLiterals[value] = result;
     }
     return result;
   }
 
-  HConstant addConstantInt(int i) {
-    return addConstant(new IntConstant(i));
+  HLiteral addNewLiteralNaN() {
+    if (nanLiteral === null) {
+      nanLiteral = new HLiteral.internal(double.NAN, HType.DOUBLE);
+      entry.addAtExit(nanLiteral);
+    }
+    return nanLiteral;
   }
 
-  HConstant addConstantDouble(int d) {
-    return addConstant(new DoubleConstant(d));
+  HLiteral addNewNegativeZeroLiteral() {
+    if (negativeZeroLiteral === null) {
+      negativeZeroLiteral = new HLiteral.internal(-0.0, HType.DOUBLE);
+      entry.addAtExit(negativeZeroLiteral);
+    }
+    return negativeZeroLiteral;
   }
 
-  HConstant addConstantString(DartString str) {
-    return addConstant(new StringConstant(str));
+  HLiteral addNewLiteralDouble(double value) {
+    if (value.isNaN()) return addNewLiteralNaN();  // Avoid hashing NaN.
+    if (value == 0 && value.isNegative()) {
+      // Avoid hashing -0.0 as it compares equal to 0.0.
+      return addNewNegativeZeroLiteral();
+    }
+    if (doubleLiterals === null) doubleLiterals = new Map<double, HLiteral>();
+    HLiteral result = doubleLiterals[value];
+    if (result === null) {
+      result = new HLiteral.internal(value, HType.DOUBLE);
+      entry.addAtExit(result);
+      doubleLiterals[value] = result;
+    }
+    return result;
   }
 
-  HConstant addConstantBool(bool value) {
-    return addConstant(new BoolConstant(value));
+  HLiteral addNewLiteralNum(num value, HType type) {
+    // If we've propagated type information then the type must be a
+    // number or in conflict, but when we turn off speculative
+    // optimization the type may be unknown. In any case, we make it a
+    // number from this point forward.
+    assert(type.isUnknown() || type.isConflicting() || type.isNumber());
+    if (type.isInteger()) return addNewLiteralInt(value);
+    if (type.isDouble() || value.isNaN()) return addNewLiteralDouble(value);
+    // Probe our literals map and add a new number literal if necessary.
+    if (numLiterals === null) numLiterals = new Map<num, HLiteral>();
+    HLiteral result = numLiterals[value];
+    if (result === null) {
+      result = new HLiteral.internal(value, HType.NUMBER);
+      entry.addAtExit(result);
+      numLiterals[value] = result;
+     }
+    return result;
   }
 
-  HConstant addConstantNull() {
-    return addConstant(const NullConstant());
+  HLiteral addNewLiteralTrue() {
+    if (trueLiteral === null) {
+      trueLiteral = new HLiteral.internal(true, HType.BOOLEAN);
+      entry.addAtExit(trueLiteral);
+    }
+    return trueLiteral;
+  }
+
+  HLiteral addNewLiteralFalse() {
+    if (falseLiteral === null) {
+      falseLiteral = new HLiteral.internal(false, HType.BOOLEAN);
+      entry.addAtExit(falseLiteral);
+    }
+    return falseLiteral;
+  }
+
+  HLiteral addNewLiteralBool(bool value) {
+    return value ? addNewLiteralTrue() : addNewLiteralFalse();
+  }
+
+  HLiteral addNewLiteralString(DartString value) {
+    if (stringLiterals === null) stringLiterals = new Map<String, HLiteral>();
+    String key = value.toString();  // We need something hashable.
+    HLiteral result = stringLiterals[key];
+    if (result === null) {
+      result = new HLiteral.internal(value, HType.STRING);
+      entry.addAtExit(result);
+      stringLiterals[key] = result;
+    }
+    return result;
+  }
+
+  HLiteral addNewLiteralNull() {
+    if (nullLiteral === null) {
+      nullLiteral = new HLiteral.internal(null, HType.UNKNOWN);
+      entry.addAtExit(nullLiteral);
+    }
+    return nullLiteral;
   }
 
   void finalize() {
     addBlock(exit);
     exit.open();
     exit.close(new HExit());
     assignDominators();
   }
 
   void assignDominators() {
@@ skipping 50 matching lines @@
   visitAdd(HAdd node) => visitBinaryArithmetic(node);
   visitBitAnd(HBitAnd node) => visitBinaryBitOp(node);
   visitBitNot(HBitNot node) => visitInvokeUnary(node);
   visitBitOr(HBitOr node) => visitBinaryBitOp(node);
   visitBitXor(HBitXor node) => visitBinaryBitOp(node);
   visitBailoutTarget(HBailoutTarget node) => visitInstruction(node);
   visitBoolify(HBoolify node) => visitInstruction(node);
   visitBoundsCheck(HBoundsCheck node) => visitCheck(node);
   visitBreak(HBreak node) => visitGoto(node);
   visitCheck(HCheck node) => visitInstruction(node);
-  visitConstant(HConstant node) => visitInstruction(node);
   visitDivide(HDivide node) => visitBinaryArithmetic(node);
   visitEquals(HEquals node) => visitRelational(node);
   visitExit(HExit node) => visitControlFlow(node);
   visitFieldGet(HFieldGet node) => visitInstruction(node);
   visitFieldSet(HFieldSet node) => visitInstruction(node);
   visitForeign(HForeign node) => visitInstruction(node);
   visitForeignNew(HForeignNew node) => visitForeign(node);
   visitGoto(HGoto node) => visitControlFlow(node);
   visitGreater(HGreater node) => visitRelational(node);
   visitGreaterEqual(HGreaterEqual node) => visitRelational(node);
@@ skipping 12 matching lines @@
       => visitInvokeDynamicField(node);
   visitInvokeInterceptor(HInvokeInterceptor node)
       => visitInvokeStatic(node);
   visitInvokeStatic(HInvokeStatic node) => visitInvoke(node);
   visitInvokeSuper(HInvokeSuper node) => visitInvoke(node);
   visitLess(HLess node) => visitRelational(node);
   visitLessEqual(HLessEqual node) => visitRelational(node);
   visitLoad(HLoad node) => visitInstruction(node);
   visitLocal(HLocal node) => visitInstruction(node);
   visitLogicalOperator(HLogicalOperator node) => visitInstruction(node);
+  visitLiteral(HLiteral node) => visitInstruction(node);
   visitLiteralList(HLiteralList node) => visitInstruction(node);
   visitLoopBranch(HLoopBranch node) => visitConditionalBranch(node);
   visitModulo(HModulo node) => visitBinaryArithmetic(node);
   visitNegate(HNegate node) => visitInvokeUnary(node);
   visitNot(HNot node) => visitInstruction(node);
   visitPhi(HPhi node) => visitInstruction(node);
   visitMultiply(HMultiply node) => visitBinaryArithmetic(node);
   visitParameterValue(HParameterValue node) => visitInstruction(node);
   visitReturn(HReturn node) => visitControlFlow(node);
   visitShiftRight(HShiftRight node) => visitBinaryBitOp(node);
@@ skipping 640 matching lines @@
           inputUsedBy[j] = inputUsedBy[inputUsedBy.length - 1];
           inputUsedBy.removeLast();
           break;
         }
       }
     }
     this.block = null;
     assert(isValid());
   }
 
-  bool isConstantNull() => false;
-  bool isConstantNumber() => false;
-  bool isConstantString() => false;
+  bool isLiteralNull() => false;
+  bool isLiteralNumber() => false;
+  bool isLiteralString() => false;
 
   bool isValid() {
     HValidator validator = new HValidator();
     validator.currentBlock = block;
     validator.visitInstruction(this);
     return validator.isValid;
   }
 }
 
 class HBoolify extends HInstruction {
@@ skipping 241 matching lines @@
           || name == const SourceString('removeLast')) {
         return HType.ARRAY;
       }
     }
     return HType.UNKNOWN;
   }
 
   bool hasExpectedType() => builtinJsName != null;
 
   HInstruction fold(HGraph graph) {
-    if (name == const SourceString('length') && inputs[1].isConstantString()) {
-      HConstant input = inputs[1];
-      DartString string = input.constant.value;
-      return graph.addConstantInt(string.length);
+    if (name == const SourceString('length') && inputs[1].isLiteralString()) {
+      HLiteral input = inputs[1];
+      DartString string = input.value;
+      return graph.addNewLiteralInt(string.length);
     }
     return this;
   }
 
   void prepareGvn() {
     if (builtinJsName == 'length') {
       assert(!hasSideEffects());
     } else {
       setAllSideEffects();
     }
@@ skipping 74 matching lines @@
 
   HType computeInputsType() {
     HType leftType = left.type;
     HType rightType = right.type;
     if (leftType.isUnknown() || rightType.isUnknown()) {
       return HType.UNKNOWN;
     }
     return leftType.combine(rightType);
   }
 
-  HInstruction fold(HGraph graph) {
-    if (left is HConstant && right is HConstant) {
-      HConstant op1 = left;
-      HConstant op2 = right;
-      Constant folded =
-          op1.constant.binaryFold(operationAsString(), op2.constant);
-      if (folded !== null) return graph.addConstant(folded);
-    }
-    return this;
-  }
-  abstract String operationAsString();
+  abstract HInstruction fold(HGraph graph);
+  abstract evaluate(num a, num b);
 }
 
 class HBinaryArithmetic extends HInvokeBinary {
   HBinaryArithmetic(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
 
   void prepareGvn() {
     // An arithmetic expression can take part in global value
     // numbering and do not have any side-effects if we know that all
     // inputs are numbers.
     if (builtin) {
       assert(!hasSideEffects());
       setUseGvn();
     } else {
       setAllSideEffects();
     }
   }
 
+  HInstruction fold(HGraph graph) {
+    if (left.isLiteralNumber() && right.isLiteralNumber()) {
+      HLiteral op1 = left;
+      HLiteral op2 = right;
+      return graph.addNewLiteralNum(evaluate(op1.value, op2.value), type);
+    }
+    return this;
+  }
+
   HType computeType() {
     HType type = computeInputsType();
     builtin = type.isNumber();
     if (!type.isUnknown()) return type;
     if (left.isNumber()) return HType.NUMBER;
     return HType.UNKNOWN;
   }
 
   HType computeDesiredInputType(HInstruction input) {
     // TODO(floitsch): we want the target to be a function.
     if (input == target) return HType.UNKNOWN;
     if (isNumber() || left.isNumber() || right.isNumber()) return HType.NUMBER;
     if (type.isUnknown()) return HType.NUMBER;
     return HType.UNKNOWN;
   }
 
   bool hasExpectedType() => builtin || type.isUnknown();
+
+  abstract num evaluate(num a, num b);
 }
 
 class HAdd extends HBinaryArithmetic {
   HAdd(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitAdd(this);
+  num evaluate(num a, num b) => a + b;
+  int typeCode() => 5;
+  bool typeEquals(other) => other is HAdd;
+  bool dataEquals(HInstruction other) => true;
 
   HType computeType() {
     HType type = computeInputsType();
     builtin = (type.isNumber() || type.isString());
     if (type.isConflicting() && left.isString()) {
-      builtin = right is HConstant;
+      builtin = right is HLiteral;
       return HType.STRING;
     }
     if (!type.isUnknown()) return type;
     if (left.isNumber()) return HType.NUMBER;
     return HType.UNKNOWN;
   }
 
   bool hasExpectedType() => builtin || type.isUnknown() || left.isString();
 
   HType computeDesiredInputType(HInstruction input) {
     // TODO(floitsch): we want the target to be a function.
     if (input == target) return HType.UNKNOWN;
     if (isString() || left.isString()) {
       return (input == left) ? HType.STRING : HType.UNKNOWN;
     }
     if (right.isString()) return HType.STRING;
     if (isNumber() || left.isNumber() || right.isNumber()) return HType.NUMBER;
     return HType.UNKNOWN;
   }
 
   HInstruction fold(HGraph graph) {
-    // TODO(floitsch): move this code to the compile-time-constant handler.
-    if (left.isConstantString() && right is HConstant) {
-      HConstant op1 = left;
-      HConstant op2 = right;
-      DartString leftString = op1.constant.value;
+    if (left.isLiteralString() && right is HLiteral) {
+      HLiteral op1 = left;
+      HLiteral op2 = right;
+      DartString leftString = op1.value;
       DartString otherString = null;
-      if (right.isConstantString()) {
-        otherString = op2.constant.value;
+      if (right.isLiteralString()) {
+        otherString = op2.value;
       } else {
-        assert(op2.isConstantNumber() ||
-               op2.isConstantBoolean() ||
-               op2.isConstantNull());
-        otherString = new DartString.literal(op2.constant.value.toString());
+        assert(op2.isLiteralNumber() ||
+               op2.isLiteralBoolean() ||
+               op2.isLiteralNull());
+        otherString = new DartString.literal(op2.value.toString());
       }
       DartString cons = new ConsDartString(leftString, otherString);
-      return graph.addConstantString(cons);
+      return graph.addNewLiteralString(cons);
     }
     return super.fold(graph);
   }
-
-  String operationAsString() => "+";
-  int typeCode() => 5;
-  bool typeEquals(other) => other is HAdd;
-  bool dataEquals(HInstruction other) => true;
 }
 
 class HDivide extends HBinaryArithmetic {
   HDivide(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitDivide(this);
 
   HType computeType() {
     HType type = computeInputsType();
     builtin = type.isNumber();
     if (left.isNumber()) return HType.DOUBLE;
     return HType.UNKNOWN;
   }
 
-  String operationAsString() => "/";
+  num evaluate(num a, num b) => a / b;
   int typeCode() => 6;
   bool typeEquals(other) => other is HDivide;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HModulo extends HBinaryArithmetic {
   HModulo(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitModulo(this);
-
-  String operationAsString() => "%";
+  num evaluate(num a, num b) => a % b;
   int typeCode() => 7;
   bool typeEquals(other) => other is HModulo;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HMultiply extends HBinaryArithmetic {
   HMultiply(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitMultiply(this);
-
-  String operationAsString() => "*";
+  num evaluate(num a, num b) => a * b;
   int typeCode() => 8;
   bool typeEquals(other) => other is HMultiply;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HSubtract extends HBinaryArithmetic {
   HSubtract(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitSubtract(this);
-
-  String operationAsString() => "-";
+  num evaluate(num a, num b) => a - b;
   int typeCode() => 9;
   bool typeEquals(other) => other is HSubtract;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HTruncatingDivide extends HBinaryArithmetic {
   HTruncatingDivide(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitTruncatingDivide(this);
 
-  String operationAsString() => "~/";
+  HInstruction fold(HGraph graph) {
+    // Avoid a DivisionByZeroException.
+    if (right.isLiteralNumber() && right.dynamic.value == 0) {
+      return this;
+    }
+    return super.fold(graph);
+  }
+
+  num evaluate(num a, num b) => a ~/ b;
   int typeCode() => 10;
   bool typeEquals(other) => other is HTruncatingDivide;
   bool dataEquals(HInstruction other) => true;
 }
 
 
 // TODO(floitsch): Should HBinaryArithmetic really be the super class of
 // HBinaryBitOp?
 class HBinaryBitOp extends HBinaryArithmetic {
   HBinaryBitOp(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
 
   HType computeType() {
     HType type = computeInputsType();
     builtin = type.isInteger();
     if (!type.isUnknown()) return type;
     if (left.isInteger()) return HType.INTEGER;
     return HType.UNKNOWN;
   }
 
   HType computeDesiredInputType(HInstruction input) {
     // TODO(floitsch): we want the target to be a function.
     if (input == target) return HType.UNKNOWN;
     return HType.INTEGER;
   }
 
+  HInstruction fold(HGraph graph) {
+    // Bit-operations are only defined on integers.
+    if (left.isLiteralNumber() && right.isLiteralNumber()) {
+      HLiteral op1 = left;
+      HLiteral op2 = right;
+      // Avoid exceptions.
+      if (op1.isInteger() && op2.isInteger()) {
+        return graph.addNewLiteralInt(evaluate(op1.value, op2.value));
+      }
+    }
+    return this;
+  }
+
   // TODO(floitsch): make class abstract instead of adding an abstract method.
   abstract accept(HVisitor visitor);
 }
 
 class HShiftLeft extends HBinaryBitOp {
   HShiftLeft(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitShiftLeft(this);
 
-  String operationAsString() => "<<";
+  HInstruction fold(HGraph graph) {
+    if (right.isLiteralNumber()) {
+      // TODO(floitsch): find good max left-shift amount.
+      final int MAX_SHIFT_LEFT_AMOUNT = 50;
+      HLiteral op2 = right;
+      // Only positive shifting is allowed. Also guard against out-of-memory
+      // shifts.
+      if (op2.value < 0 || op2.value > MAX_SHIFT_LEFT_AMOUNT) return this;
+    }
+    return super.fold(graph);
+  }
+
+  int evaluate(int a, int b) => a << b;
   int typeCode() => 11;
   bool typeEquals(other) => other is HShiftLeft;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HShiftRight extends HBinaryBitOp {
   HShiftRight(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitShiftRight(this);
 
-  String operationAsString() => ">>";
+  HInstruction fold(HGraph graph) {
+    if (right.isLiteralNumber()) {
+      HLiteral op2 = right;
+      // Only positive shifting is allowed.
+      if (op2.value < 0) return this;
+    }
+    return super.fold(graph);
+  }
+
+  int evaluate(int a, int b) => a >> b;
   int typeCode() => 12;
   bool typeEquals(other) => other is HShiftRight;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HBitOr extends HBinaryBitOp {
   HBitOr(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitBitOr(this);
 
-  String operationAsString() => "|";
+  int evaluate(int a, int b) => a | b;
   int typeCode() => 13;
   bool typeEquals(other) => other is HBitOr;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HBitAnd extends HBinaryBitOp {
   HBitAnd(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitBitAnd(this);
 
-  String operationAsString() => "&";
+  int evaluate(int a, int b) => a & b;
   int typeCode() => 14;
   bool typeEquals(other) => other is HBitAnd;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HBitXor extends HBinaryBitOp {
   HBitXor(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitBitXor(this);
 
-  String operationAsString() => "^";
+  int evaluate(int a, int b) => a ^ b;
   int typeCode() => 15;
   bool typeEquals(other) => other is HBitXor;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HInvokeUnary extends HInvokeStatic {
   HInvokeUnary(HStatic target, HInstruction input)
       : super(Selector.UNARY_OPERATOR, <HInstruction>[target, input]);
 
   HInstruction get operand() => inputs[1];
@@ skipping 19 matching lines @@
 
   HType computeDesiredInputType(HInstruction input) {
     // TODO(floitsch): we want the target to be a function.
     if (input == target) return HType.UNKNOWN;
     if (type.isUnknown() || type.isNumber()) return HType.NUMBER;
     return HType.UNKNOWN;
   }
 
   bool hasExpectedType() => builtin || (type.isUnknown());
 
-  HInstruction fold(HGraph graph) {
-    if (operand is HConstant) {
-      HConstant op = operand;
-      Constant folded = op.constant.unaryFold(operationAsString());
-      if (folded !== null) return graph.addConstant(folded);
-    }
-    return this;
-  }
+  abstract HInstruction fold(HGraph graph);
 
-  abstract String operationAsString();
+  abstract num evaluate(num a);
 }
 
 class HNegate extends HInvokeUnary {
   HNegate(HStatic target, HInstruction input) : super(target, input);
   accept(HVisitor visitor) => visitor.visitNegate(this);
 
-  String operationAsString() => "-";
+  HInstruction fold(HGraph graph) {
+    if (operand.isLiteralNumber()) {
+      HLiteral input = operand;
+      return graph.addNewLiteralNum(evaluate(input.value), type);
+    }
+    return this;
+  }
+
+  num evaluate(num a) => -a;
   int typeCode() => 16;
   bool typeEquals(other) => other is HNegate;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HBitNot extends HInvokeUnary {
   HBitNot(HStatic target, HInstruction input) : super(target, input);
   accept(HVisitor visitor) => visitor.visitBitNot(this);
 
   HType computeType() {
     HType type = operand.type;
     builtin = type.isInteger();
     if (!type.isUnknown()) return type;
     return HType.UNKNOWN;
   }
 
   HType computeDesiredInputType(HInstruction input) {
     // TODO(floitsch): we want the target to be a function.
     if (input == target) return HType.UNKNOWN;
     return HType.INTEGER;
   }
 
-  String operationAsString() => "~";
+  HInstruction fold(HGraph graph) {
+    if (operand.isLiteralNumber()) {
+      HLiteral input = operand;
+      if (input.isInteger()) {
+        return graph.addNewLiteralInt(evaluate(input.value));
+      }
+    }
+    return this;
+  }
+
+  int evaluate(int a) => ~a;
   int typeCode() => 17;
   bool typeEquals(other) => other is HBitNot;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HExit extends HControlFlow {
   HExit() : super(const <HInstruction>[]);
   toString() => 'exit';
   accept(HVisitor visitor) => visitor.visitExit(this);
 }
@@ skipping 52 matching lines @@
   HLoopBranch(HInstruction condition, [this.kind = CONDITION_FIRST_LOOP])
       : super(<HInstruction>[condition]);
   toString() => 'loop-branch';
   accept(HVisitor visitor) => visitor.visitLoopBranch(this);
 
   bool isDoWhile() {
     return kind === DO_WHILE_LOOP;
   }
 }
 
-class HConstant extends HInstruction {
-  final Constant constant;
-  HConstant.internal(this.constant, HType type) : super(<HInstruction>[]) {
+class HLiteral extends HInstruction {
+  final value;
+  HLiteral.internal(this.value, HType type) : super(<HInstruction>[]) {
     this.type = type;
     tryGenerateAtUseSite();  // Maybe avoid this if the literal is big?
   }
 
   void prepareGvn() {
     assert(!hasSideEffects());
   }
 
-  toString() => 'literal: $constant';
-  accept(HVisitor visitor) => visitor.visitConstant(this);
+  toString() => 'literal: $value';
+  accept(HVisitor visitor) => visitor.visitLiteral(this);
   HType computeType() => type;
 
   // Literals have the type they have. It can't be changed.
   bool updateType() => false;
 
   bool hasExpectedType() => true;
 
-  bool isConstantBoolean() => constant.isBool();
-  bool isConstantNull() => constant.isNull();
-  bool isConstantNumber() => constant.isNum();
-  bool isConstantString() => constant.isString();
+  bool isLiteralBoolean() => value is bool;
+  bool isLiteralNull() => value === null;
+  bool isLiteralNumber() => value is num;
+  bool isLiteralString() => value is DartString;
 }
 
 class HNot extends HInstruction {
   HNot(HInstruction value) : super(<HInstruction>[value]);
   void prepareGvn() {
     assert(!hasSideEffects());
     setUseGvn();
   }
 
   HType computeType() => HType.BOOLEAN;
@@ skipping 118 matching lines @@
     // and do not have any side-effects if we know all the inputs are
     // numbers. This can be improved for at least equality.
     if (builtin) {
       assert(!hasSideEffects());
       setUseGvn();
     } else {
       setAllSideEffects();
     }
   }
 
+   HInstruction fold(HGraph graph) {
+    if (left.isLiteralNumber() && right.isLiteralNumber()) {
+      HLiteral op1 = left;
+      HLiteral op2 = right;
+      return graph.addNewLiteralBool(evaluate(op1.value, op2.value));
+    }
+    return this;
+  }
+
   HType computeType() {
     builtin = computeInputsType().isNumber();
     return HType.BOOLEAN;
   }
 
   HType computeDesiredInputType(HInstruction input) {
     // TODO(floitsch): we want the target to be a function.
     if (input == target) return HType.UNKNOWN;
     // For all relational operations exept HEquals, we expect to only
     // get numbers.
     return HType.NUMBER;
   }
 
   // A HRelational goes through the builtin operator or the top level
   // element. Therefore, it always has the expected type.
   bool hasExpectedType() => true;
+
+  abstract bool evaluate(num a, num b);
 }
 
 class HEquals extends HRelational {
   HEquals(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
+  bool evaluate(num a, num b) => a == b;
   accept(HVisitor visitor) => visitor.visitEquals(this);
+  int typeCode() => 19;
+  bool typeEquals(other) => other is HEquals;
+  bool dataEquals(HInstruction other) => true;
 
   HType computeType() {
-    builtin = computeInputsType().isNumber() || (left is HConstant);
+    builtin = computeInputsType().isNumber() || (left is HLiteral);
     return HType.BOOLEAN;
   }
 
   HType computeDesiredInputType(HInstruction input) {
     // TODO(floitsch): we want the target to be a function.
     if (input == target) return HType.UNKNOWN;
     if (left.isNumber() || right.isNumber()) return HType.NUMBER;
     return HType.UNKNOWN;
   }
-
-  String operationAsString() => "==";
-  int typeCode() => 19;
-  bool typeEquals(other) => other is HEquals;
-  bool dataEquals(HInstruction other) => true;
 }
 
 class HIdentity extends HRelational {
   HIdentity(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
+  bool evaluate(num a, num b) => a === b;
   accept(HVisitor visitor) => visitor.visitIdentity(this);
+  int typeCode() => 20;
+  bool typeEquals(other) => other is HIdentity;
+  bool dataEquals(HInstruction other) => true;
 
   HType computeType() {
     builtin = true;
     return HType.BOOLEAN;
   }
 
   bool hasExpectedType() => true;
 
   HType computeDesiredInputType(HInstruction input) => HType.UNKNOWN;
-
-  String operationAsString() => "===";
-  int typeCode() => 20;
-  bool typeEquals(other) => other is HIdentity;
-  bool dataEquals(HInstruction other) => true;
 }
 
 class HGreater extends HRelational {
   HGreater(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
+  bool evaluate(num a, num b) => a > b;
   accept(HVisitor visitor) => visitor.visitGreater(this);
-
-  String operationAsString() => ">";
   int typeCode() => 21;
   bool typeEquals(other) => other is HGreater;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HGreaterEqual extends HRelational {
   HGreaterEqual(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
+  bool evaluate(num a, num b) => a >= b;
   accept(HVisitor visitor) => visitor.visitGreaterEqual(this);
-
-  String operationAsString() => ">=";
   int typeCode() => 22;
   bool typeEquals(other) => other is HGreaterEqual;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HLess extends HRelational {
   HLess(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
+  bool evaluate(num a, num b) => a < b;
   accept(HVisitor visitor) => visitor.visitLess(this);
-
-  String operationAsString() => "<";
-  int typeCode() => 23;
   bool typeEquals(other) => other is HLess;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HLessEqual extends HRelational {
   HLessEqual(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
+  bool evaluate(num a, num b) => a <= b;
   accept(HVisitor visitor) => visitor.visitLessEqual(this);
-
-  String operationAsString() => "<=";
-  int typeCode() => 24;
+  int typeCode() => 23;
   bool typeEquals(other) => other is HLessEqual;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HReturn extends HControlFlow {
   HReturn(value) : super(<HInstruction>[value]);
   toString() => 'return';
   accept(HVisitor visitor) => visitor.visitReturn(this);
 }
 
@@ skipping 12 matching lines @@
   void prepareGvn() {
     assert(!hasSideEffects());
     if (!element.isAssignable()) {
       setUseGvn();
     }
   }
   toString() => 'static ${element.name}';
   accept(HVisitor visitor) => visitor.visitStatic(this);
 
   int gvnHashCode() => super.gvnHashCode() ^ element.hashCode();
-  int typeCode() => 25;
+  int typeCode() => 24;
   bool typeEquals(other) => other is HStatic;
   bool dataEquals(HStatic other) => element == other.element;
 }
 
 class HStaticStore extends HInstruction {
   Element element;
   HStaticStore(this.element, HInstruction value) : super(<HInstruction>[value]);
   toString() => 'static store ${element.name}';
   accept(HVisitor visitor) => visitor.visitStaticStore(this);
 
-  int typeCode() => 26;
+  int typeCode() => 25;
   bool typeEquals(other) => other is HStaticStore;
   bool dataEquals(HStaticStore other) => element == other.element;
 }
 
 class HLiteralList extends HInstruction {
   HLiteralList(inputs, this.isConst) : super(inputs);
   toString() => 'literal list';
   accept(HVisitor visitor) => visitor.visitLiteralList(this);
   HType computeType() => HType.ARRAY;
   bool hasExpectedType() => true;
@@ skipping 136 matching lines @@
 class HIfBlockInformation {
   final HIf branch;
   final SubGraph thenGraph;
   final SubGraph elseGraph;
   final HBasicBlock joinBlock;
   HIfBlockInformation(this.branch,
                       this.thenGraph,
                       this.elseGraph,
                       this.joinBlock);
 }