Move relational operators to the new interceptors.

sdk/lib/_internal/compiler/implementation/ssa/codegen.dart

 // Copyright (c) 2012, 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.
 
 part of ssa;
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
@@ skipping 1245 matching lines @@
     visit(instruction);
   }
 
   visitInvokeBinary(HInvokeBinary node, String op) {
     use(node.left);
     js.Expression jsLeft = pop();
     use(node.right);
     push(new js.Binary(op, jsLeft, pop()), node);
   }
 
-  visitRelational(HRelational node, String op) {
-    if (node.isBuiltin(types)) {
-      use(node.left);
-      js.Expression jsLeft = pop();
-      use(node.right);
-      push(new js.Binary(op, jsLeft, pop()), node);
-    } else {
-      visitInvokeStatic(node);
-    }
-  }
+  visitRelational(HRelational node, String op) => visitInvokeBinary(node, op);
 
   // We want the outcome of bit-operations to be positive. We use the unsigned
   // shift operator to achieve this.
   visitBitInvokeBinary(HBinaryBitOp node, String op) {
     visitInvokeBinary(node, op);
     if (requiresUintConversion(node)) {
       push(new js.Binary(">>>", pop(), new js.LiteralNumber("0")), node);
     }
   }
 
@@ skipping 27 matching lines @@
       js.Binary rightEqualsNull =
           new js.Binary("==", pop(), new js.LiteralNull());
       use(right);
       use(left);
       js.Binary tripleEq = new js.Binary("===", pop(), pop());
 
       push(new js.Conditional(leftEqualsNull, rightEqualsNull, tripleEq));
     }
   }
 
-  visitEquals(HEquals node) {
-    if (node.isBuiltin(types)) {
-      emitIdentityComparison(node.left, node.right);
-    } else {
-      visitInvokeStatic(node);
-    }
-  }
-
   visitIdentity(HIdentity node) {
-    assert(node.isBuiltin(types));
     emitIdentityComparison(node.left, node.right);
   }
 
   visitAdd(HAdd node)               => visitInvokeBinary(node, '+');
   visitDivide(HDivide node)         => visitInvokeBinary(node, '/');
   visitMultiply(HMultiply node)     => visitInvokeBinary(node, '*');
   visitSubtract(HSubtract node)     => visitInvokeBinary(node, '-');
   visitBitAnd(HBitAnd node)         => visitBitInvokeBinary(node, '&');
   visitBitNot(HBitNot node)         => visitBitInvokeUnary(node, '~');
   visitBitOr(HBitOr node)           => visitBitInvokeBinary(node, '|');
@@ skipping 505 matching lines @@
       }
     }
   }
 
   visitNot(HNot node) {
     assert(node.inputs.length == 1);
     generateNot(node.inputs[0]);
     attachLocationToLast(node);
   }
 
-
   void generateNot(HInstruction input) {
     bool canGenerateOptimizedComparison(HInstruction instruction) {
       if (instruction is !HRelational) return false;
       HRelational relational = instruction;
       HInstruction left = relational.left;
       HInstruction right = relational.right;
       // This optimization doesn't work for NaN, so we only do it if the
       // type is known to be an integer.
-      return relational.isBuiltin(types)
-          && types[left].isUseful() && left.isInteger(types)
+      return types[left].isUseful() && left.isInteger(types)
           && types[right].isUseful() && right.isInteger(types);
     }
 
     if (input is HBoolify && isGenerateAtUseSite(input)) {
       use(input.inputs[0]);
       push(new js.Binary("!==", pop(), newLiteralBool(true)), input);
     } else if (canGenerateOptimizedComparison(input) &&
                isGenerateAtUseSite(input)) {
       Map<String, String> inverseOperator = const <String, String>{
         "==" : "!=",
@@ skipping 1139 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }