Add structural equality to ConstantExpression.

pkg/compiler/lib/src/cps_ir/cps_ir_builder.dart

 // Copyright (c) 2013, 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.
 
 library dart2js.ir_builder;
 
 import '../constants/constant_system.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart' show PrimitiveConstantValue;
 import '../dart_types.dart';
@@ skipping 667 matching lines @@
         sourceInformation: sourceInformation);
   }
 
 
   /// Create a [ir.Constant] from [constant] and add it to the CPS term.
   ir.Constant buildConstant(ConstantExpression constant) {
     assert(isOpen);
     return addPrimitive(new ir.Constant(constant));
   }
 
-  // Helper for building primitive constants.
-  ir.Constant _buildPrimitiveConstant(PrimitiveConstantValue constant) {
-    return buildConstant(new PrimitiveConstantExpression(constant));
-  }
-
   /// Create an integer constant and add it to the CPS term.
   ir.Constant buildIntegerConstant(int value) {
-    return _buildPrimitiveConstant(state.constantSystem.createInt(value));
+    return buildConstant(new IntConstantExpression(
+        value,
+        state.constantSystem.createInt(value)));
   }
 
   /// Create a double constant and add it to the CPS term.
   ir.Constant buildDoubleConstant(double value) {
-    return _buildPrimitiveConstant(state.constantSystem.createDouble(value));
+    return buildConstant(new DoubleConstantExpression(
+        value,
+        state.constantSystem.createDouble(value)));
   }
 
   /// Create a Boolean constant and add it to the CPS term.
   ir.Constant buildBooleanConstant(bool value) {
-    return _buildPrimitiveConstant(state.constantSystem.createBool(value));
+    return buildConstant(new BoolConstantExpression(
+        value,
+        state.constantSystem.createBool(value)));
   }
 
   /// Create a null constant and add it to the CPS term.
   ir.Constant buildNullConstant() {
-    return _buildPrimitiveConstant(state.constantSystem.createNull());
+    return buildConstant(new NullConstantExpression(
+        state.constantSystem.createNull()));
   }
 
   /// Create a string constant and add it to the CPS term.
   ir.Constant buildStringConstant(String value) {
-    return _buildPrimitiveConstant(
-        state.constantSystem.createString(new ast.DartString.literal(value)));
+    return buildConstant(new StringConstantExpression(
+        value,
+        state.constantSystem.createString(new ast.DartString.literal(value))));
   }
 
   /// Create a string constant and add it to the CPS term.
   ir.Constant buildDartStringConstant(ast.DartString value) {
-    return _buildPrimitiveConstant(state.constantSystem.createString(value));
+    return buildConstant(new StringConstantExpression(
+        value.slowToString(),
+        state.constantSystem.createString(value)));
   }
 
   /// Creates a non-constant list literal of the provided [type] and with the
   /// provided [values].
   ir.Primitive buildListLiteral(InterfaceType type,
                                 Iterable<ir.Primitive> values) {
     assert(isOpen);
     return addPrimitive(new ir.LiteralList(type, values.toList()));
   }
 
@@ skipping 1196 matching lines @@
     // ! e is translated as e ? false : true
 
     // Add a continuation parameter for the result of the expression.
     ir.Parameter resultParameter = new ir.Parameter(null);
 
     ir.Continuation joinContinuation = new ir.Continuation([resultParameter]);
     ir.Continuation thenContinuation = new ir.Continuation([]);
     ir.Continuation elseContinuation = new ir.Continuation([]);
 
     ir.Constant makeBoolConstant(bool value) {
-      return new ir.Constant(new PrimitiveConstantExpression(
+      return new ir.Constant(new BoolConstantExpression(
+          value,
           state.constantSystem.createBool(value)));
     }
 
     ir.Constant trueConstant = makeBoolConstant(true);
     ir.Constant falseConstant = makeBoolConstant(false);
 
     thenContinuation.body = new ir.LetPrim(falseConstant)
         ..plug(new ir.InvokeContinuation(joinContinuation, [falseConstant]));
     elseContinuation.body = new ir.LetPrim(trueConstant)
         ..plug(new ir.InvokeContinuation(joinContinuation, [trueConstant]));
@@ skipping 706 matching lines @@
 }
 
 /// Synthetic parameter to a JavaScript factory method that takes the type
 /// argument given for the type variable [variable].
 class TypeInformationParameter implements Local {
   final TypeVariableElement variable;
   final ExecutableElement executableContext;
   TypeInformationParameter(this.variable, this.executableContext);
   String get name => variable.name;
 }