Move relational operators to the new interceptors.

sdk/lib/_internal/compiler/implementation/ssa/builder.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;
 
 /**
  * A special element for the extra parameter taken by intercepted
  * methods. We need to override [Element.computeType] because our
  * optimizers may look at its declared type.
@@ skipping 1005 matching lines @@
    *
    * Invariant: [functionElement] must be an implementation element.
    */
   HGraph buildMethod(FunctionElement functionElement) {
     assert(invariant(functionElement, functionElement.isImplementation));
     FunctionExpression function = functionElement.parseNode(compiler);
     assert(function != null);
     assert(!function.modifiers.isExternal());
     assert(elements[function] != null);
     openFunction(functionElement, function);
+    SourceString name = functionElement.name;
+    // If [functionElement] is operator== we explicitely add a null
+    // check at the beginning of the method. This is to avoid having
+    // call sites do the null check.
+    if (name == const SourceString('==')) {
+      handleIf(
+          function,
+          () {
+            HParameterValue parameter = parameters.values.first;
+            push(new HIdentity(
+                parameter, graph.addConstantNull(constantSystem)));
+          },
+          () {
+            HReturn ret = new HReturn(
+                graph.addConstantBool(false, constantSystem));
+            close(ret).addSuccessor(graph.exit);
+          },
+          null);
+    }
     function.body.accept(this);
     return closeFunction();
   }
 
   HGraph buildLazyInitializer(VariableElement variable) {
     SendSet node = variable.parseNode(compiler);
     openFunction(variable, node);
     Link<Node> link = node.arguments;
     assert(!link.isEmpty && link.tail.isEmpty);
     visit(link.head);
@@ skipping 504 matching lines @@
 
       // Fetch the original default value of [element];
       Constant constant = compileVariable(element);
       HConstant defaultValue = constant == null
           ? graph.addConstantNull(constantSystem)
           : graph.addConstant(constant);
 
       // Emit the equality check with the sentinel.
       HConstant sentinel = graph.addConstant(SentinelConstant.SENTINEL);
       Element equalsHelper = interceptors.getTripleEqualsInterceptor();
-      HInstruction target = new HStatic(equalsHelper);
-      add(target);
       HInstruction operand = parameters[element];
-      check = new HIdentity(target, sentinel, operand);
+      check = new HIdentity(sentinel, operand);
       add(check);
 
       // If the check succeeds, we must update the parameter with the
       // default value.
       handleIf(element.parseNode(compiler),
                () => stack.add(check),
                () => localsHandler.updateLocal(element, defaultValue),
                null);
 
       // Create the instruction that parameter checks will use.
@@ skipping 791 matching lines @@
         selector = new Selector.binaryOperator(const SourceString('|'));
         break;
       case "&":
       case "&=":
         selector = new Selector.binaryOperator(const SourceString('&'));
         break;
       case "^":
       case "^=":
         selector = new Selector.binaryOperator(const SourceString('^'));
         break;
+      case "==":
+      case "!=":
+        selector = new Selector.binaryOperator(const SourceString('=='));
+        break;
+      case "<":
+        selector = new Selector.binaryOperator(const SourceString('<'));
+        break;
+      case "<=":
+        selector = new Selector.binaryOperator(const SourceString('<='));
+        break;
+      case ">":
+        selector = new Selector.binaryOperator(const SourceString('>'));
+        break;
+      case ">=":
+        selector = new Selector.binaryOperator(const SourceString('>='));
+        break;
+      case "===":
+        pushWithPosition(new HIdentity(left, right), op);
+        return;
+      case "!==":
+        HIdentity eq = new HIdentity(left, right);
+        add(eq);
+        pushWithPosition(new HNot(eq), op);
+        return;
       default:
         break;
     }
 
     if (selector != null) {
       pushWithPosition(
             buildInvokeDynamic(send, selector, left, [right]),
             op);
+      if (op.source.stringValue == '!=') {
+        HBoolify bl = new HBoolify(pop());
+        add(bl);
+        pushWithPosition(new HNot(bl), op);
+      }
       return;
     }
     Element element = interceptors.getOperatorInterceptor(op);
     assert(element != null);
     HInstruction target = new HStatic(element);
     add(target);
     switch (op.source.stringValue) {
-      case "==":
-        pushWithPosition(new HEquals(target, left, right), op);
-        break;
-      case "===":
-        pushWithPosition(new HIdentity(target, left, right), op);
-        break;
-      case "!==":
-        HIdentity eq = new HIdentity(target, left, right);
-        add(eq);
-        pushWithPosition(new HNot(eq), op);
-        break;
-      case "<":
-        pushWithPosition(new HLess(target, left, right), op);
-        break;
-      case "<=":
-        pushWithPosition(new HLessEqual(target, left, right), op);
-        break;
-      case ">":
-        pushWithPosition(new HGreater(target, left, right), op);
-        break;
-      case ">=":
-        pushWithPosition(new HGreaterEqual(target, left, right), op);
-        break;
-      case "!=":
-        HEquals eq = new HEquals(target, left, right);
-        add(eq);
-        HBoolify bl = new HBoolify(eq);
-        add(bl);
-        pushWithPosition(new HNot(bl), op);
-        break;
       default: compiler.unimplemented("SsaBuilder.visitBinary");
     }
   }
 
   HInstruction generateInstanceSendReceiver(Send send) {
     assert(Elements.isInstanceSend(send, elements));
     if (send.receiver == null) {
       return localsHandler.readThis();
     }
     visit(send.receiver);
@@ skipping 1052 matching lines @@
       // calling [addStaticSendArgumentsToList].
       bool succeeded = addStaticSendArgumentsToList(selector, node.arguments,
                                                     element.implementation,
                                                     inputs);
       if (!succeeded) {
         generateWrongArgumentCountError(node, element, node.arguments);
         return;
       }
 
       if (isIdenticalFunction) {
-        pushWithPosition(new HIdentity(target, inputs[1], inputs[2]), node);
+        pushWithPosition(new HIdentity(inputs[1], inputs[2]), node);
         return;
       }
 
       HInvokeStatic instruction = new HInvokeStatic(inputs);
       // TODO(ngeoffray): Only do this if knowing the return type is
       // useful.
       HType returnType =
           builder.backend.optimisticReturnTypesWithRecompilationOnTypeChange(
               work.element, element);
       if (returnType != null) instruction.guaranteedType = returnType;
@@ skipping 956 matching lines @@
       // This must be the final case (otherwise "default" would be invalid),
       // so we don't need to check for fallthrough.
       return;
     }
 
     // Recursively build the test conditions. Leaves the result on the
     // expression stack.
     void buildTests(Link<Node> remainingCases) {
       // Build comparison for one case expression.
       void left() {
-        Element equalsHelper = interceptors.getEqualsInterceptor();
-        HInstruction target = new HStatic(equalsHelper);
-        add(target);
         CaseMatch match = remainingCases.head;
         // TODO(lrn): Move the constant resolution to the resolver, so
         // we can report an error before reaching the backend.
         Constant constant =
             compiler.constantHandler.tryCompileNodeWithDefinitions(
                 match.expression, elements);
         if (constant != null) {
           stack.add(graph.addConstant(constant));
         } else {
           visit(match.expression);
         }
-        push(new HEquals(target, pop(), expression));
+        push(new HIdentity(pop(), expression));
       }
 
       // If this is the last expression, just return it.
       Link<Node> tail = skipLabels(remainingCases.tail);
       if (tail.isEmpty) {
         left();
         return;
       }
 
       void right() {
@@ skipping 635 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }