dart2js cps: Make Identical a built-in and add Interceptor to Tree IR.

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 '../compile_time_constants.dart' show BackendConstantEnvironment;
 import '../constants/constant_system.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart' show ConstantValue, PrimitiveConstantValue;
@@ skipping 1627 matching lines @@
                          SwitchCaseInfo defaultCase,
                          Element error,
                          SourceInformation sourceInformation) {
     assert(isOpen);
     JumpCollector join = new ForwardJumpCollector(environment, target: target);
 
     IrBuilder casesBuilder = makeDelimitedBuilder();
     casesBuilder.state.breakCollectors.add(join);
     for (SwitchCaseInfo caseInfo in cases) {
       buildConditionsFrom(int index) => (IrBuilder builder) {
-        ir.Primitive comparison = builder.addPrimitive(
-            new ir.Identical(value, caseInfo.constants[index]));
+        ir.Primitive comparison = builder.buildIdentical(
+            value, caseInfo.constants[index]);
         return (index == caseInfo.constants.length - 1)
             ? comparison
             : builder.buildLogicalOperator(
                 comparison, buildConditionsFrom(index + 1), isLazyOr: true);
       };
 
       ir.Primitive condition = buildConditionsFrom(0)(casesBuilder);
       IrBuilder thenBuilder = makeDelimitedBuilder();
       caseInfo.buildBody(thenBuilder);
       if (thenBuilder.isOpen) {
@@ skipping 424 matching lines @@
                                                   leftFalseContinuation],
                 new ir.Branch(new ir.IsTrue(leftValue),
                               leftTrueContinuation,
                               leftFalseContinuation))));
     environment = join.environment;
     environment.discard(1);
     // There is always a join parameter for the result value, because it
     // is different on at least two paths.
     return join.continuation.parameters.last;
   }
+
+  ir.Primitive buildIdentical(ir.Primitive x, ir.Primitive y) {
+    return addPrimitive(new ir.ApplyBuiltinOperator(
+        ir.BuiltinOperator.Identical, <ir.Primitive>[x, y]));
+  }
 }
 
 /// State shared between JsIrBuilders within the same function.
 ///
 /// Note that this is not shared between builders of nested functions.
 class JsIrBuilderSharedState {
   /// Maps boxed locals to their location. These locals are not part of
   /// the environment.
   final Map<Local, ClosureLocation> boxedVariables = {};
 
@@ skipping 398 matching lines @@
       // For type tests, we must treat specially the rare cases where `null`
       // satisfies the test (which otherwise never satisfies a type test).
       // This is not an optimization: the TypeOperator assumes that `null`
       // cannot satisfy the type test unless the type is a type variable.
       if (type.isObject || type.isDynamic) {
         // `x is Object` and `x is dynamic` are always true, even if x is null.
         return buildBooleanConstant(true);
       }
       if (type is InterfaceType && type.element == program.nullClass) {
         // `x is Null` is true if and only if x is null.
-        return addPrimitive(new ir.Identical(value, buildNullConstant()));
+        return _buildCheckNull(value);
       }
       return addPrimitive(new ir.TypeTest(value, type, typeArguments));
     } else {
       return _continueWithExpression(
               (k) => new ir.TypeCast(value, type, typeArguments, k));
     }
   }
 
   @override
   ir.Primitive buildIfNull(ir.Primitive value,
                            ir.Primitive buildRight(IrBuilder builder)) {
     ir.Primitive condition = _buildCheckNull(value);
     return buildConditional(condition, buildRight, (_) => value);
   }
 
   @override
   ir.Primitive buildIfNotNullSend(ir.Primitive receiver,
                                   ir.Primitive buildSend(IrBuilder builder)) {
     ir.Primitive condition = _buildCheckNull(receiver);
     return buildConditional(condition, (_) => receiver, buildSend);
   }
 
   /// Creates a type test checking whether [value] is null.
   ir.Primitive _buildCheckNull(ir.Primitive value) {
     assert(isOpen);
-    ir.Primitive right = buildNullConstant();
-    return addPrimitive(new ir.Identical(value, right));
+    return buildIdentical(value, buildNullConstant());
   }
 
   /// Convert the given value to a string.
   ir.Primitive buildStringify(ir.Primitive value) {
     return buildStaticFunctionInvocation(
         program.stringifyFunction,
         new CallStructure.unnamed(1),
         <ir.Primitive>[value]);
   }
 }
@@ skipping 70 matching lines @@
 }
 
 class SwitchCaseInfo {
   final List<ir.Primitive> constants = <ir.Primitive>[];
   final SubbuildFunction buildBody;
 
   SwitchCaseInfo(this.buildBody);
 
   void addConstant(ir.Primitive constant) => constants.add(constant);
 }