Add CPS IR transformation to make the JavaScript backend specific semantics explicit in the tree.

pkg/compiler/lib/src/cps_ir/cps_ir_nodes.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.
 
 // IrNodes are kept in a separate library to have precise control over their
 // dependencies on other parts of the system.
 library dart2js.ir_nodes;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' as values show ConstantValue;
@@ skipping 94 matching lines @@
     if (next != null) next.previous = previous;
   }
 }
 
 /// Binding a value (primitive or constant): 'let val x = V in E'.  The bound
 /// value is in scope in the body.
 /// During one-pass construction a LetVal with an empty body is used to
 /// represent one-level context 'let val x = V in []'.
 class LetPrim extends Expression implements InteriorNode {
   final Primitive primitive;
-  Expression body = null;
+  Expression body;
 
-  LetPrim(this.primitive);
+  LetPrim(this.primitive, [this.body = null]);
 
   Expression plug(Expression expr) {
     assert(body == null);
     return body = expr;
   }
 
   accept(Visitor visitor) => visitor.visitLetPrim(this);
 }
 
 
@@ skipping 316 matching lines @@
   final Reference<Continuation> trueContinuation;
   final Reference<Continuation> falseContinuation;
 
   Branch(this.condition, Continuation trueCont, Continuation falseCont)
       : trueContinuation = new Reference<Continuation>(trueCont),
         falseContinuation = new Reference<Continuation>(falseCont);
 
   accept(Visitor visitor) => visitor.visitBranch(this);
 }
 
+class Identical extends Primitive {
+  final Reference<Primitive> left;
+  final Reference<Primitive> right;
+  Identical(Primitive a, Primitive b)

[Kevin Millikin (Google), 2014/11/25 14:27:23]

I do prefer a ==> left and b ==> right in parameters.

[karlklose, 2014/11/25 14:38:46]

Done.

+      : left = new Reference<Primitive>(a),
+        right = new Reference<Primitive>(b);
+  accept(Visitor visitor) => visitor.visitIdentical(this);
+}
+
 class Constant extends Primitive {
   final ConstantExpression expression;
 
   Constant(this.expression);
 
   values.ConstantValue get value => expression.value;
 
   accept(Visitor visitor) => visitor.visitConstant(this);
 }
 
@@ skipping 149 matching lines @@
   T visitConstant(Constant node) => visitPrimitive(node);
   T visitThis(This node) => visitPrimitive(node);
   T visitReifyTypeVar(ReifyTypeVar node) => visitPrimitive(node);
   T visitCreateFunction(CreateFunction node) => visitPrimitive(node);
   T visitGetClosureVariable(GetClosureVariable node) => visitPrimitive(node);
   T visitParameter(Parameter node) => visitPrimitive(node);
   T visitContinuation(Continuation node) => visitDefinition(node);
 
   // Conditions.
   T visitIsTrue(IsTrue node) => visitCondition(node);
+
+  // JavaScript specific nodes.
+  T visitIdentical(Identical node) => visitPrimitive(node);
 }
 
 /// Recursively visits the entire CPS term, and calls abstract `process*`
 /// (i.e. `processLetPrim`) functions in pre-order.
 abstract class RecursiveVisitor extends Visitor {
   const RecursiveVisitor();
 
   // Ensures that RecursiveVisitor contains overrides for all relevant nodes.
   // As a rule of thumb, nodes with structure to traverse should be overridden
   // with the appropriate visits in this class (for example, visitLetCont),
@@ skipping 146 matching lines @@
     visit(node.body);
   }
 
   // Conditions.
 
   processIsTrue(IsTrue node) {}
   visitIsTrue(IsTrue node) {
     processIsTrue(node);
     processReference(node.value);
   }
+
+  // JavaScript specific nodes.
+  processIdentical(Identical node) {}
+  visitIdentical(Identical node) {
+    processIdentical(node);
+    processReference(node.left);
+    processReference(node.right);
+  }
 }
 
 /// Keeps track of currently unused register indices.
 class RegisterArray {
   int nextIndex = 0;
   final List<int> freeStack = <int>[];
 
   /// Returns an index that is currently unused.
   int makeIndex() {
     if (freeStack.isEmpty) {
@@ skipping 148 matching lines @@
     // transferred without intermediate assignments.
     for (int i = node.parameters.length - 1; i >= 0; --i) {
       release(node.parameters[i]);
     }
   }
 
   void visitIsTrue(IsTrue node) {
     visitReference(node.value);
   }
 
+  // JavaScript specific nodes.
+
+  void visitIdentical(Identical node) {
+    visitReference(node.left);
+    visitReference(node.right);
+  }
 }