dart2js: num.compareTo is pure, and a.compareTo(a) is zero

pkg/compiler/lib/src/ssa/invoke_dynamic_specializers.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.
 
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
 import '../elements/elements.dart' show Name;
 import '../elements/entities.dart';
 import '../js_backend/backend_helpers.dart';
 import '../options.dart';
@@ skipping 18 matching lines @@
       GlobalTypeInferenceResults results,
       CompilerOptions options,
       BackendHelpers helpers,
       ClosedWorld closedWorld) {
     return TypeMaskFactory.inferredTypeForSelector(
         instruction.selector, instruction.mask, results);
   }
 
   HInstruction tryConvertToBuiltin(
       HInvokeDynamic instruction,
+      HGraph graph,
       GlobalTypeInferenceResults results,
       CompilerOptions options,
       BackendHelpers helpers,
       ClosedWorld closedWorld) {
     return null;
   }
 
   void clearAllSideEffects(HInstruction instruction) {
     instruction.sideEffects.clearAllSideEffects();
     instruction.sideEffects.clearAllDependencies();
@@ skipping 35 matching lines @@
       return const InvokeDynamicSpecializer();
     }
     if (selector.isCall) {
       if (selector.namedArguments.length == 0) {
         int argumentCount = selector.argumentCount;
         if (argumentCount == 0) {
           if (name == 'round') return const RoundSpecializer();
           if (name == 'trim') return const TrimSpecializer();
         } else if (argumentCount == 1) {
           if (name == 'codeUnitAt') return const CodeUnitAtSpecializer();
+          if (name == 'compareTo') return const CompareToSpecializer();
           if (name == 'remainder') return const RemainderSpecializer();
           if (name == 'substring') return const SubstringSpecializer();
           if (name == 'contains') return const PatternMatchSpecializer();
           if (name == 'indexOf') return const PatternMatchSpecializer();
           if (name == 'startsWith') return const PatternMatchSpecializer();
           if (name == 'endsWith') return const PatternMatchSpecializer();
         } else if (argumentCount == 2) {
           if (name == 'substring') return const SubstringSpecializer();
           if (name == 'contains') return const PatternMatchSpecializer();
           if (name == 'indexOf') return const PatternMatchSpecializer();
           if (name == 'startsWith') return const PatternMatchSpecializer();
           if (name == 'endsWith') return const PatternMatchSpecializer();
         }
       }
     }
     return const InvokeDynamicSpecializer();
   }
 }
 
 class IndexAssignSpecializer extends InvokeDynamicSpecializer {
   const IndexAssignSpecializer();
 
   HInstruction tryConvertToBuiltin(
       HInvokeDynamic instruction,
+      HGraph graph,
       GlobalTypeInferenceResults results,
       CompilerOptions options,
       BackendHelpers helpers,
       ClosedWorld closedWorld) {
     if (instruction.inputs[1].isMutableIndexable(closedWorld)) {
       if (!instruction.inputs[2].isInteger(closedWorld) &&
           options.enableTypeAssertions) {
         // We want the right checked mode error.
         return null;
       }
       return new HIndexAssign(instruction.inputs[1], instruction.inputs[2],
           instruction.inputs[3], instruction.selector);
     }
     return null;
   }
 }
 
 class IndexSpecializer extends InvokeDynamicSpecializer {
   const IndexSpecializer();
 
   HInstruction tryConvertToBuiltin(
       HInvokeDynamic instruction,
+      HGraph graph,
       GlobalTypeInferenceResults results,
       CompilerOptions options,
       BackendHelpers helpers,
       ClosedWorld closedWorld) {
     if (!instruction.inputs[1].isIndexablePrimitive(closedWorld)) return null;
     if (!instruction.inputs[2].isInteger(closedWorld) &&
         options.enableTypeAssertions) {
       // We want the right checked mode error.
       return null;
     }
@@ skipping 23 matching lines @@
     // integer or throw an error.
     if (instruction.inputs[1].isPrimitiveOrNull(closedWorld)) {
       return closedWorld.commonMasks.uint32Type;
     }
     return super.computeTypeFromInputTypes(
         instruction, results, options, helpers, closedWorld);
   }
 
   HInstruction tryConvertToBuiltin(
       HInvokeDynamic instruction,
+      HGraph graph,
       GlobalTypeInferenceResults results,
       CompilerOptions options,
       BackendHelpers helpers,
       ClosedWorld closedWorld) {
     HInstruction input = instruction.inputs[1];
     if (input.isNumber(closedWorld)) {
       return new HBitNot(
           input,
           instruction.selector,
           computeTypeFromInputTypes(
@@ skipping 17 matching lines @@
       BackendHelpers helpers,
       ClosedWorld closedWorld) {
     TypeMask operandType = instruction.inputs[1].instructionType;
     if (instruction.inputs[1].isNumberOrNull(closedWorld)) return operandType;
     return super.computeTypeFromInputTypes(
         instruction, results, options, helpers, closedWorld);
   }
 
   HInstruction tryConvertToBuiltin(
       HInvokeDynamic instruction,
+      HGraph graph,
       GlobalTypeInferenceResults results,
       CompilerOptions options,
       BackendHelpers helpers,
       ClosedWorld closedWorld) {
     HInstruction input = instruction.inputs[1];
     if (input.isNumber(closedWorld)) {
       return new HNegate(input, instruction.selector, input.instructionType);
     }
     return null;
   }
@@ skipping 25 matching lines @@
         instruction, results, options, helpers, closedWorld);
   }
 
   bool isBuiltin(HInvokeDynamic instruction, ClosedWorld closedWorld) {
     return instruction.inputs[1].isNumber(closedWorld) &&
         instruction.inputs[2].isNumber(closedWorld);
   }
 
   HInstruction tryConvertToBuiltin(
       HInvokeDynamic instruction,
+      HGraph graph,
       GlobalTypeInferenceResults results,
       CompilerOptions options,
       BackendHelpers helpers,
       ClosedWorld closedWorld) {
     if (isBuiltin(instruction, closedWorld)) {
       HInstruction builtin = newBuiltinVariant(
           instruction, results, options, helpers, closedWorld);
       if (builtin != null) return builtin;
       // Even if there is no builtin equivalent instruction, we know
       // the instruction does not have any side effect, and that it
@@ skipping 323 matching lines @@
       }
       if (left.isUInt32(closedWorld) && isTwoOrGreater(right)) {
         return true;
       }
     }
     return false;
   }
 
   HInstruction tryConvertToBuiltin(
       HInvokeDynamic instruction,
+      HGraph graph,
       GlobalTypeInferenceResults results,
       CompilerOptions options,
       BackendHelpers helpers,
       ClosedWorld closedWorld) {
     HInstruction right = instruction.inputs[2];
     if (isBuiltin(instruction, closedWorld)) {
       if (right.isPositiveInteger(closedWorld) && isNotZero(right)) {
         if (hasUint31Result(instruction, closedWorld)) {
           return newBuiltinVariant(
               instruction, results, options, helpers, closedWorld);
@@ skipping 71 matching lines @@
 
 class ShiftLeftSpecializer extends BinaryBitOpSpecializer {
   const ShiftLeftSpecializer();
 
   BinaryOperation operation(ConstantSystem constantSystem) {
     return constantSystem.shiftLeft;
   }
 
   HInstruction tryConvertToBuiltin(
       HInvokeDynamic instruction,
+      HGraph graph,
       GlobalTypeInferenceResults results,
       CompilerOptions options,
       BackendHelpers helpers,
       ClosedWorld closedWorld) {
     HInstruction left = instruction.inputs[1];
     HInstruction right = instruction.inputs[2];
     if (left.isNumber(closedWorld)) {
       if (argumentLessThan32(right)) {
         return newBuiltinVariant(
             instruction, results, options, helpers, closedWorld);
@@ skipping 35 matching lines @@
       BackendHelpers helpers,
       ClosedWorld closedWorld) {
     HInstruction left = instruction.inputs[1];
     if (left.isUInt32(closedWorld)) return left.instructionType;
     return super.computeTypeFromInputTypes(
         instruction, results, options, helpers, closedWorld);
   }
 
   HInstruction tryConvertToBuiltin(
       HInvokeDynamic instruction,
+      HGraph graph,
       GlobalTypeInferenceResults results,
       CompilerOptions options,
       BackendHelpers helpers,
       ClosedWorld closedWorld) {
     HInstruction left = instruction.inputs[1];
     HInstruction right = instruction.inputs[2];
     if (left.isNumber(closedWorld)) {
       if (argumentLessThan32(right) && isPositive(left, closedWorld)) {
         return newBuiltinVariant(
             instruction, results, options, helpers, closedWorld);
@@ skipping 158 matching lines @@
       ClosedWorld closedWorld) {
     if (instruction.inputs[1].isPrimitiveOrNull(closedWorld)) {
       return closedWorld.commonMasks.boolType;
     }
     return super.computeTypeFromInputTypes(
         instruction, results, options, helpers, closedWorld);
   }
 
   HInstruction tryConvertToBuiltin(
       HInvokeDynamic instruction,
+      HGraph graph,
       GlobalTypeInferenceResults results,
       CompilerOptions options,
       BackendHelpers helpers,
       ClosedWorld closedWorld) {
     HInstruction left = instruction.inputs[1];
     HInstruction right = instruction.inputs[2];
     if (left.isNumber(closedWorld) && right.isNumber(closedWorld)) {
       return newBuiltinVariant(instruction, closedWorld);
     }
     return null;
   }
 
   HInstruction newBuiltinVariant(
       HInvokeDynamic instruction, ClosedWorld closedWorld);
 }
 
 class EqualsSpecializer extends RelationalSpecializer {
   const EqualsSpecializer();
 
   HInstruction tryConvertToBuiltin(
       HInvokeDynamic instruction,
+      HGraph graph,
       GlobalTypeInferenceResults results,
       CompilerOptions options,
       BackendHelpers helpers,
       ClosedWorld closedWorld) {
     HInstruction left = instruction.inputs[1];
     HInstruction right = instruction.inputs[2];
     TypeMask instructionType = left.instructionType;
     if (right.isConstantNull() || left.isPrimitiveOrNull(closedWorld)) {
       return newBuiltinVariant(instruction, closedWorld);
     }
@@ skipping 78 matching lines @@
 
 class CodeUnitAtSpecializer extends InvokeDynamicSpecializer {
   const CodeUnitAtSpecializer();
 
   BinaryOperation operation(ConstantSystem constantSystem) {
     return constantSystem.codeUnitAt;
   }
 
   HInstruction tryConvertToBuiltin(
       HInvokeDynamic instruction,
+      HGraph graph,
       GlobalTypeInferenceResults results,
       CompilerOptions options,
       BackendHelpers helpers,
       ClosedWorld closedWorld) {
     // TODO(sra): Implement a builtin HCodeUnitAt instruction and the same index
     // bounds checking optimizations as for HIndex.
     HInstruction receiver = instruction.getDartReceiver(closedWorld);
     if (receiver.isStringOrNull(closedWorld)) {
       // Even if there is no builtin equivalent instruction, we know
       // String.codeUnitAt does not have any side effect (other than throwing),
       // and that it can be GVN'ed.
       clearAllSideEffects(instruction);
       if (instruction.inputs.last.isPositiveInteger(closedWorld)) {
         instruction.selector = renameToOptimizedSelector(
             '_codeUnitAt', instruction.selector, helpers);
       }
     }
     return null;
   }
 }
 
+class CompareToSpecializer extends InvokeDynamicSpecializer {
+  const CompareToSpecializer();
+
+  HInstruction tryConvertToBuiltin(
+      HInvokeDynamic instruction,
+      HGraph graph,
+      GlobalTypeInferenceResults results,
+      CompilerOptions options,
+      BackendHelpers helpers,
+      ClosedWorld closedWorld) {
+    HInstruction receiver = instruction.getDartReceiver(closedWorld);
+    // `compareTo` has no side-effect (other than throwing) and can be GVN'ed
+    // for some known types.
+    if (receiver.isStringOrNull(closedWorld) ||
+        receiver.isNumberOrNull(closedWorld)) {
+      // Replace `a.compareTo(a)` with `0`, but only if receiver and argument
+      // are such that no exceptions can be thrown.
+      HInstruction argument = instruction.inputs.last;
+      if ((receiver.isNumber(closedWorld) && argument.isNumber(closedWorld)) ||
+          (receiver.isString(closedWorld) && argument.isString(closedWorld))) {
+        if (identical(receiver.nonCheck(), argument.nonCheck())) {
+          return graph.addConstantInt(0, closedWorld);
+        }
+      }
+      clearAllSideEffects(instruction);
+    }
+    return null;
+  }
+}
+
 class IdempotentStringOperationSpecializer extends InvokeDynamicSpecializer {
   const IdempotentStringOperationSpecializer();
 
   HInstruction tryConvertToBuiltin(
       HInvokeDynamic instruction,
+      HGraph graph,
       GlobalTypeInferenceResults results,
       CompilerOptions options,
       BackendHelpers helpers,
       ClosedWorld closedWorld) {
     HInstruction receiver = instruction.getDartReceiver(closedWorld);
     if (receiver.isStringOrNull(closedWorld)) {
       // String.xxx does not have any side effect (other than throwing), and it
       // can be GVN'ed.
       clearAllSideEffects(instruction);
     }
     return null;
   }
 }
 
 class SubstringSpecializer extends IdempotentStringOperationSpecializer {
   const SubstringSpecializer();
 }
 
 class TrimSpecializer extends IdempotentStringOperationSpecializer {
   const TrimSpecializer();
 }
 
 class PatternMatchSpecializer extends InvokeDynamicSpecializer {
   const PatternMatchSpecializer();
 
   HInstruction tryConvertToBuiltin(
       HInvokeDynamic instruction,
+      HGraph graph,
       GlobalTypeInferenceResults results,
       CompilerOptions options,
       BackendHelpers helpers,
       ClosedWorld closedWorld) {
     HInstruction receiver = instruction.getDartReceiver(closedWorld);
     HInstruction pattern = instruction.inputs[2];
     if (receiver.isStringOrNull(closedWorld) &&
         pattern.isStringOrNull(closedWorld)) {
       // String.contains(String s) does not have any side effect (other than
       // throwing), and it can be GVN'ed.
       clearAllSideEffects(instruction);
     }
     return null;
   }
 }
 
 class RoundSpecializer extends InvokeDynamicSpecializer {
   const RoundSpecializer();
 
   UnaryOperation operation(ConstantSystem constantSystem) {
     return constantSystem.round;
   }
 
   HInstruction tryConvertToBuiltin(
       HInvokeDynamic instruction,
+      HGraph graph,
       GlobalTypeInferenceResults results,
       CompilerOptions options,
       BackendHelpers helpers,
       ClosedWorld closedWorld) {
     HInstruction receiver = instruction.getDartReceiver(closedWorld);
     if (receiver.isNumberOrNull(closedWorld)) {
       // Even if there is no builtin equivalent instruction, we know the
       // instruction does not have any side effect, and that it can be GVN'ed.
       clearAllSideEffects(instruction);
     }
     return null;
   }
 }