Revert "Refactor constant part."

dart/frog/leg/ssa/optimize.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 OptimizationPhase {
   String get name();
   void visitGraph(HGraph graph);
 }
 
 class SsaOptimizerTask extends CompilerTask {
@@ skipping 72 matching lines @@
   HInstruction visitInstruction(HInstruction node) {
     return node;
   }
 
   HInstruction visitBoolify(HBoolify node) {
     List<HInstruction> inputs = node.inputs;
     assert(inputs.length == 1);
     HInstruction input = inputs[0];
     if (input.isBoolean()) return input;
     // All values !== true are boolified to false.
-    if (input.type.isKnown()) {
-      return graph.addConstantBool(false);
-    }
+    if (input.type.isKnown()) return graph.addNewLiteralFalse();
     return node;
   }
 
   HInstruction visitNot(HNot node) {
     List<HInstruction> inputs = node.inputs;
     assert(inputs.length == 1);
     HInstruction input = inputs[0];
-    if (input is HConstant) {
-      HConstant constant = input;
-      bool isTrue = constant.constant.isTrue();
-      return graph.addConstantBool(!isTrue);
+    if (input is HLiteral) {
+      HLiteral literal = input;
+      return graph.addNewLiteralBool(literal.value !== true);
     }
     return node;
   }
 
   HInstruction visitInvokeBinary(HInvokeBinary node) => node.fold(graph);
   HInstruction visitInvokeUnary(HInvokeUnary node) => node.fold(graph);
   HInstruction visitInvokeInterceptor(HInvokeInterceptor node)
       => node.fold(graph);
 
   HInstruction visitAdd(HAdd node) {
-    // TODO(floitsch): move this code into the compile-time constant handler.
-
     // String + is defined for all literals. We don't need to know which
-    // type the right-hand side is.
+    // literal type the right-hand side is.
 
     if (node.left.isString()) {
       // First try to eliminate adding the empty string to a string.
-      if (node.right.isConstantString()) {
-        HConstant right = node.right;
-        Constant rightStringConstant = right.constant;
-        DartString rightString = rightStringConstant.value;
+      if (node.right.isLiteralString()) {
+        HLiteral right = node.right;
+        DartString rightString = right.value;
         if (rightString.isEmpty()) {
           // String has no content, i.e., it's the empty string.
           return node.left;
         }
       }
-      // Then, if both are constants, try to do the concatenation statically.
-      if (node.left.isConstantString()) {
-        HConstant left = node.left;
-        Constant leftStringConstant = left.constant;
-        DartString leftString = leftStringConstant.value;
+      // Then, if both are literals, try to do the concatenation statically.
+      if (node.left.isLiteralString()) {
+        HLiteral left = node.left;
+        DartString leftString = left.value;
         if (leftString.isEmpty()) {
           // Left is empty String.
           if (node.right.isString()) {
             // Right is already a String, just return that.
             return node.right;
           }
-          if (node.right is HConstant) {
-            HConstant right = node.right;
-            // Right is a constant, so we can statically convert it to String
+          if (node.right is HLiteral) {
+            HLiteral right = node.right;
+            // Right is a literal, so we can statically convert it to String
             // and return that.
             // Remaining literal types are represented by their Dart value.
-            if (right.isConstantBoolean() ||
-                right.isConstantNumber() ||
-                right.isConstantNull()) {
-              PrimitiveConstant rightConstant = right.constant;
-              String str = rightConstant.value.toString();
-              return graph.addConstantString(new DartString.literal(str));
-            }
+            assert(right.isLiteralBoolean() ||
+                   right.isLiteralNumber() ||
+                   right.isLiteralNull());
+            String str = right.value.toString();
+            return graph.addNewLiteralString(new DartString.literal(str));
           }
         }
         // TODO(lrn): Perform concatenation in Dart.
       }
     }
     return visitInvokeBinary(node);
   }
 
+  HInstruction visitEquals(HEquals node) {
+    if (node.left is HLiteral && node.right is HLiteral) {
+      HLiteral op1 = node.left;
+      HLiteral op2 = node.right;
+      if (op1.isLiteralString()) {
+        if (op2.isLiteralString() && op1.value.definitelyEquals(op2.value)) {
+          return graph.addNewLiteralTrue();
+        }
+      } else {
+        return graph.addNewLiteralBool(op1.value == op2.value);
+      }
+    } else if (node.right.isLiteralNull()) {
+      HStatic target = new HStatic(
+          compiler.builder.interceptors.getEqualsNullInterceptor());
+      node.block.addBefore(node, target);
+      return new HEquals(target, node.left, node.right);
+    }
+    return node;
+  }
+
   HInstruction visitTypeGuard(HTypeGuard node) {
     HInstruction value = node.guarded;
     return (value.type.combine(node.type) == value.type) ? value : node;
   }
 
   HInstruction visitIntegerCheck(HIntegerCheck node) {
     HInstruction value = node.value;
     return value.isInteger() ? value : node;
   }
 }
@@ skipping 451 matching lines @@
         }
       }
       if (!canBeMoved) continue;
 
       // This is safe because we are running after GVN.
       // TODO(ngeoffray): ensure GVN has been run.
       set_.add(current);
     }
   }
 }