Improve optimization of operations on indexables by using more inferred type information and by dis…

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 2895 matching lines @@
   }
 
   visitDynamicSend(Send node, {bool inline: true}) {
     Selector selector = elements.getSelector(node);
 
     List<HInstruction> inputs = <HInstruction>[];
     HInstruction receiver = generateInstanceSendReceiver(node);
     inputs.add(receiver);
     addDynamicSendArgumentsToList(node, inputs);
 
+    // We prefer to not inline certain operations on indexables,
+    // because the constant folder will handle them better and turn
+    // them into simpler instructions that allow further
+    // optimizations.
+    bool isOptimizableOperationOnIndexable(Selector selector, Element element) {
+      bool isLength = selector.isGetter()
+          && selector.name == const SourceString("length");
+      if (isLength || selector.isIndex()) {
+        DartType classType = element.getEnclosingClass().computeType(compiler);
+        HType type = new HType.nonNullExact(classType, compiler);
+        return type.isIndexable(compiler);
+      } else if (selector.isIndexSet()) {
+        DartType classType = element.getEnclosingClass().computeType(compiler);
+        HType type = new HType.nonNullExact(classType, compiler);
+        return type.isMutableIndexable(compiler);
+      } else {
+        return false;
+      }
+    }
+
     Element element = compiler.world.locateSingleElement(selector);
     // TODO(ngeoffray): If [element] is a getter, then this send is
     // a closure send. We should teach that to [ResolvedVisitor].
     if (inline
         && element != null
         && !element.isGetter()
         // This check is to ensure we don't regress compared to our
         // previous limited inlining. We currently don't want to
         // inline methods on intercepted classes because the
         // optimizers apply their own optimizations on these methods.
         && (!backend.interceptedClasses.contains(element.getEnclosingClass())
-            || isThisSend(node))) {
+            || isThisSend(node))
+        // Avoid inlining optimizable operations on indexables.
+        && !isOptimizableOperationOnIndexable(selector, element)) {
       if (tryInlineMethod(element, selector, node.arguments, inputs, node)) {
         return;
       }
     }
 
     HInstruction invoke = buildInvokeDynamic(node, selector, inputs);
     pushWithPosition(invoke, node);
   }
 
   visitClosureSend(Send node) {
@@ skipping 427 matching lines @@
         isListConstructor = true;
         return HType.FIXED_ARRAY;
       } else if (Elements.isGrowableListConstructorCall(
                     originalElement, node, compiler)) {
         isListConstructor = true;
         return HType.EXTENDABLE_ARRAY;
       } else if (element.isGenerativeConstructor()) {
         ClassElement cls = element.getEnclosingClass();
         return new HType.nonNullExact(cls.thisType, compiler);
       } else {
-        return HType.UNKNOWN;
+        return new HType.inferredTypeForElement(originalElement, compiler);
       }
     }
 
     Element constructor = elements[node];
     Selector selector = elements.getSelector(node);
     if (compiler.enqueuer.resolution.getCachedElements(constructor) == null) {
       compiler.internalError("Unresolved element: $constructor", node: node);
     }
     FunctionElement functionElement = constructor;
     constructor = functionElement.redirectionTarget;
@@ skipping 1862 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;
   }
 }