Add structural equality to ConstantExpression.

pkg/compiler/lib/src/js_backend/codegen/unsugar.dart

 library dart2js.unsugar_cps;
 
 import '../../cps_ir/cps_ir_nodes.dart';
 
 // TODO(karlklose): share the [ParentVisitor].
 import '../../cps_ir/optimizers.dart';
 import '../../constants/expressions.dart';
 import '../../constants/values.dart';
 import '../../elements/elements.dart'
     show ClassElement, FieldElement, FunctionElement, Element;
@@ skipping 19 matching lines @@
   }
 
   @override
   visit(Node node) {
     Node result = node.accept(this);
     return result != null ? result : node;
   }
 
   Constant get trueConstant {
     return new Constant(
-        new PrimitiveConstantExpression(
+        new BoolConstantExpression(
+            true,
             new TrueConstantValue()));
   }
 
   void insertLetPrim(Primitive primitive, Expression node) {
     LetPrim let = new LetPrim(primitive);
     InteriorNode parent = node.parent;
     parent.body = let;
     let.body = node;
     node.parent = let;
     let.parent = parent;
@@ skipping 77 matching lines @@
     Primitive intercepted = new Interceptor(receiver, interceptedClasses);
     insertLetPrim(intercepted, node);
     node.arguments.insert(0, node.receiver);
     node.callingConvention = CallingConvention.JS_INTERCEPTED;
     assert(node.isValid);
     node.receiver = new Reference<Primitive>(intercepted);
   }
 
   Primitive makeNull() {
     NullConstantValue nullConst = new NullConstantValue();
-    return new Constant(new PrimitiveConstantExpression(nullConst));
+    return new Constant(new NullConstantExpression(nullConst));
   }
 
   processInvokeMethodDirectly(InvokeMethodDirectly node) {
     if (_glue.isInterceptedMethod(node.target)) {
       Primitive nullPrim = makeNull();
       insertLetPrim(nullPrim, node);
       node.arguments.insert(0, node.receiver);
       node.receiver = new Reference<Primitive>(nullPrim);
     }
   }
 
   processBranch(Branch node) {
     // TODO(karlklose): implement the checked mode part of boolean conversion.
     InteriorNode parent = node.parent;
     IsTrue condition = node.condition;
     Primitive t = trueConstant;
     Primitive i = new Identical(condition.value.definition, t);
     LetPrim newNode = new LetPrim(t,
         new LetPrim(i,
             new Branch(new IsTrue(i),
                 node.trueContinuation.definition,
                 node.falseContinuation.definition)));
     condition.value.unlink();
     node.trueContinuation.unlink();
     node.falseContinuation.unlink();
     parent.body = newNode;
   }
 }