Optimize length access on all JSIndexable things.

sdk/lib/_internal/compiler/implementation/ssa/optimize.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;
 
 abstract class OptimizationPhase {
   String get name;
   void visitGraph(HGraph graph);
 }
@@ skipping 216 matching lines @@
     if (operand is HConstant) {
       HConstant receiver = operand;
       Constant folded = operation.fold(receiver.constant);
       if (folded != null) return graph.addConstant(folded);
     }
     return null;
   }
 
   HInstruction tryOptimizeLengthInterceptedGetter(HInvokeDynamic node) {
     HInstruction actualReceiver = node.inputs[1];
-    if (actualReceiver.isIndexablePrimitive()) {
+
+    // TODO(kasperl): Get rid of HType.isIndexablePrimitive() and use
+    // something like this everywhere instead.
+    TypeMask mask = actualReceiver.instructionType.computeMask(compiler);
+    DartType base = backend.jsIndexableClass.computeType(compiler);
+    TypeMask indexable = new TypeMask.nonNullSubtype(base);
+    TypeMask union = indexable.union(mask, compiler);
+    bool isIndexable = (union == indexable);
+
+    if (isIndexable) {
       if (actualReceiver.isConstantString()) {
         HConstant constantInput = actualReceiver;
         StringConstant constant = constantInput.constant;
         return graph.addConstantInt(constant.length, constantSystem);
       } else if (actualReceiver.isConstantList()) {
         HConstant constantInput = actualReceiver;
         ListConstant constant = constantInput.constant;
         return graph.addConstantInt(constant.length, constantSystem);
       }
-      Element element;
-      bool isAssignable;
-      if (actualReceiver.isString()) {
-        element = backend.jsStringLength;
-        isAssignable = false;
-      } else {
-        element = backend.jsArrayLength;
-        isAssignable = !actualReceiver.isFixedArray();
-      }
+      Element element = backend.jsIndexableLength;
+      bool isAssignable = !actualReceiver.isFixedArray() &&
+          !actualReceiver.isString();
       HFieldGet result = new HFieldGet(
           element, actualReceiver, isAssignable: isAssignable);
       result.instructionType = HType.INTEGER;
       return result;
     } else if (actualReceiver.isConstantMap()) {
       HConstant constantInput = actualReceiver;
       MapConstant constant = constantInput.constant;
       return graph.addConstantInt(constant.length, constantSystem);
     }
     return null;
@@ skipping 50 matching lines @@
         // HForeign is too opaque for the SsaCheckInserter (that adds a
         // bounds check on removeLast). Once we start inlining, the
         // bounds check will become explicit, so we won't need this
         // optimization.
         HInvokeDynamicMethod result = new HInvokeDynamicMethod(
             node.selector, node.inputs.sublist(1));
         result.element = target;
         return result;
       }
     } else if (selector.isGetter()) {
-      if (selector.applies(backend.jsArrayLength, compiler)
-          || selector.applies(backend.jsStringLength, compiler)) {
+      if (selector.asUntyped.applies(backend.jsIndexableLength, compiler)) {
         HInstruction optimized = tryOptimizeLengthInterceptedGetter(node);
         if (optimized != null) return optimized;
       }
     }
 
     return node;
   }
 
   HInstruction visitInvokeDynamicMethod(HInvokeDynamicMethod node) {
     if (node.isInterceptedCall) {
@@ skipping 280 matching lines @@
   }
 
   Element findConcreteFieldForDynamicAccess(HInstruction receiver,
                                             Selector selector) {
     HType receiverType = receiver.instructionType;
     return compiler.world.locateSingleField(
         receiverType.refine(selector, compiler));
   }
 
   HInstruction visitFieldGet(HFieldGet node) {
-    if (node.element == backend.jsArrayLength) {
+    if (node.element == backend.jsIndexableLength) {
       if (node.receiver is HInvokeStatic) {
         // Try to recognize the length getter with input
         // [:new List(int):].
         HInvokeStatic call = node.receiver;
         Element element = call.target.element;
         // TODO(ngeoffray): checking if the second input is an integer
         // should not be necessary but it currently makes it easier for
         // other optimizations to reason about a fixed length constructor
         // that we know takes an int.
         if (element == compiler.unnamedListConstructor
             && call.inputs.length == 2
             && call.inputs[1].isInteger()) {
           return call.inputs[1];
         }
-      } else if (node.receiver.isConstantList()) {
+      } else if (node.receiver.isConstantList() ||
+                 node.receiver.isConstantString()) {
         var instruction = node.receiver;
         return graph.addConstantInt(
             instruction.constant.length, backend.constantSystem);
       }
-    } else if (node.element == backend.jsStringLength
-               && node.receiver.isConstantString()) {
-        var instruction = node.receiver;
-        return graph.addConstantInt(
-            instruction.constant.length, backend.constantSystem);
     }
     return node;
   }
 
   HInstruction visitIndex(HIndex node) {
     if (node.receiver.isConstantList() && node.index.isConstantInteger()) {
       var instruction = node.receiver;
       List<Constant> entries = instruction.constant.entries;
       instruction = node.index;
       int index = instruction.constant.value;
@@ skipping 271 matching lines @@
       HInstruction next = instruction.next;
       instruction = instruction.accept(this);
       instruction = next;
     }
   }
 
   HBoundsCheck insertBoundsCheck(HInstruction node,
                                  HInstruction receiver,
                                  HInstruction index) {
     bool isAssignable = !receiver.isFixedArray() && !receiver.isString();
-    Element element = receiver.isString()
-        ? backend.jsStringLength
-        : backend.jsArrayLength;
     HFieldGet length = new HFieldGet(
-        element, receiver, isAssignable: isAssignable);
-    length.instructionType = HType.INTEGER;
+        backend.jsIndexableLength, receiver, isAssignable: isAssignable);
     length.instructionType = HType.INTEGER;
     node.block.addBefore(node, length);
 
     HBoundsCheck check = new HBoundsCheck(index, length);
     node.block.addBefore(node, check);
     boundsChecked.add(node);
     return check;
   }
 
   HIntegerCheck insertIntegerCheck(HInstruction node, HInstruction value) {
@@ skipping 743 matching lines @@
     HBasicBlock block = user.block;
     block.addAfter(user, interceptor);
     block.rewrite(user, interceptor);
     block.remove(user);
 
     // The interceptor will be removed in the dead code elimination
     // phase. Note that removing it here would not work because of how
     // the [visitBasicBlock] is implemented.
   }
 }