- Inline iterator calls made for a "for in".

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 1113 matching lines @@
     return result;
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [function] must be an implementation element.
    */
   InliningState enterInlinedMethod(FunctionElement function,
                                    Selector selector,
-                                   Link<Node> argumentsNodes,
                                    List<HInstruction> providedArguments,
                                    Node currentNode) {
     assert(invariant(function, function.isImplementation));
 
     List<HInstruction> compiledArguments;
     bool isInstanceMember = function.isInstanceMember();
 
-    if (isInstanceMember && !function.isGenerativeConstructorBody()) {
+    if (currentNode == null
+        || currentNode.asForIn() != null
+        || !isInstanceMember
+        || function.isGenerativeConstructorBody()) {
+      // For these cases, the provided arguments must match the
+      // expected parameters.
+      assert(providedArguments != null);
+      compiledArguments = providedArguments;
+    } else {
+      Send send = currentNode.asSend();
       assert(providedArguments != null);
       compiledArguments = new List<HInstruction>();
       compiledArguments.add(providedArguments[0]);
       // [providedArguments] contains the arguments given in our
       // internal order (see [addDynamicSendArgumentsToList]). So we
       // call [Selector.addArgumentsToList] only for getting the
       // default values of the optional parameters.
       bool succeeded = selector.addArgumentsToList(
-          argumentsNodes,
+          send.isPropertyAccess ? null : send.arguments,
           compiledArguments,
           function,
           (node) => null,
           handleConstantForOptionalParameter,
           compiler);
       int argumentIndex = 1; // Skip receiver.
       // [compiledArguments] now only contains the default values of
       // the optional parameters that were not provided by
       // [argumentsNodes]. So we iterate over [providedArguments] to fill
       // in all the arguments.
       for (int i = 1; i < compiledArguments.length; i++) {
         if (compiledArguments[i] == null) {
           compiledArguments[i] = providedArguments[argumentIndex++];
         }
       }
       // The caller of [enterInlinedMethod] has ensured the selector
       // matches the element.
       assert(succeeded);
-    } else {
-      assert(providedArguments != null);
-      compiledArguments = providedArguments;
     }
 
     // Create the inlining state after evaluating the arguments, that
     // may have an impact on the state of the current method.
     InliningState state = new InliningState(
         function, returnElement, returnType, elements, stack, localsHandler);
     LocalsHandler newLocalsHandler = new LocalsHandler(this);
     newLocalsHandler.closureData =
         compiler.closureToClassMapper.computeClosureToClassMapping(
             function, function.parseNode(compiler), elements);
@@ skipping 46 matching lines @@
     stack = state.oldStack;
     localsHandler = state.oldLocalsHandler;
   }
 
   /**
    * Try to inline [element] within the currect context of the
    * builder. The insertion point is the state of the builder.
    */
   bool tryInlineMethod(Element element,
                        Selector selector,
-                       Link<Node> argumentsNodes,
                        List<HInstruction> providedArguments,
                        Node currentNode) {
     // We cannot inline a method from a deferred library into a method
     // which isn't deferred.
     // TODO(ahe): But we should still inline into the same
     // connected-component of the deferred library.
     if (compiler.deferredLoadTask.isDeferred(element)) return false;
+    if (compiler.disableInlining) return false;
+    if (inliningStack.length > MAX_INLINING_DEPTH) return false;
 
-    if (compiler.disableInlining) return false;
     // Ensure that [element] is an implementation element.
     element = element.implementation;
-    // TODO(floitsch): find a cleaner way to know if the element is a function
-    // containing nodes.
-    // [PartialFunctionElement]s are [FunctionElement]s that have [Node]s.
-    if (element is !PartialFunctionElement
-        && !element.isGenerativeConstructorBody()) {
-      return false;
-    }
-    if (inliningStack.length > MAX_INLINING_DEPTH) return false;
-    // Don't inline recursive calls. We use the same elements for the inlined
-    // functions and would thus clobber our local variables.
-    // Use [:element.declaration:] since [work.element] is always a declaration.
-    if (currentElement == element.declaration) return false;
-    for (int i = 0; i < inliningStack.length; i++) {
-      if (inliningStack[i].function == element) return false;
-    }
-
     FunctionElement function = element;
     bool canBeInlined = backend.canBeInlined[function];
     if (canBeInlined == false) return false;
     assert(selector != null
            || Elements.isStaticOrTopLevel(element)
            || element.isGenerativeConstructorBody());
     if (selector != null && !selector.applies(function, compiler)) return false;
 
     // Don't inline operator== methods if the parameter can be null.
     if (element.name == const SourceString('==')) {
@@ skipping 20 matching lines @@
     // Add an explicit null check on the receiver before doing the
     // inlining. We use [element] to get the same name in the NoSuchMethodError
     // message as if we had called it.
     if (element.isInstanceMember()
         && !element.isGenerativeConstructorBody()
         && (selector.mask == null || selector.mask.isNullable)) {
       addWithPosition(
           new HFieldGet(element, providedArguments[0]), currentNode);
     }
     InliningState state = enterInlinedMethod(
-        function, selector, argumentsNodes, providedArguments, currentNode);
+        function, selector, providedArguments, currentNode);
 
     inlinedFrom(element, () {
       FunctionElement function = element;
       FunctionSignature signature = function.computeSignature(compiler);
       signature.orderedForEachParameter((Element parameter) {
         HInstruction argument = localsHandler.readLocal(parameter);
         potentiallyCheckType(argument, parameter.computeType(compiler));
       });
       element.isGenerativeConstructor()
           ? buildFactory(element)
@@ skipping 348 matching lines @@
         });
       }
 
       // If there are locals that escape (ie mutated in closures), we
       // pass the box to the constructor.
       ClosureScope scopeData = parameterClosureData.capturingScopes[node];
       if (scopeData != null) {
         bodyCallInputs.add(localsHandler.readLocal(scopeData.boxElement));
       }
 
-      if (tryInlineMethod(body, null, null, bodyCallInputs, function)) {
+      if (tryInlineMethod(body, null, bodyCallInputs, function)) {
         pop();
       } else {
         HInvokeConstructorBody invoke =
             new HInvokeConstructorBody(body, bodyCallInputs);
         invoke.sideEffects =
             compiler.world.getSideEffectsOfElement(constructor);
         add(invoke);
       }
     }
     if (inliningStack.isEmpty) {
@@ skipping 1991 matching lines @@
         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;
       }
     }
 
-    bool isOptimizableOperation(Send node, Selector selector, Element element) {
+    bool isOptimizableOperation(Selector selector, Element element) {
       ClassElement cls = element.getEnclosingClass();
       if (isOptimizableOperationOnIndexable(selector, element)) return true;
       if (!backend.interceptedClasses.contains(cls)) return false;
       if (selector.isOperator()) return true;
       if (selector.isSetter()) return true;
       if (selector.isIndex()) return true;
       if (selector.isIndexSet()) return true;
       if (element == backend.jsArrayAdd
           || element == backend.jsArrayRemoveLast
           || element == backend.jsStringSplit) {
         return true;
       }
       return false;
     }
 
     Element element = compiler.world.locateSingleElement(selector);
     if (element != null
-        // TODO(ngeoffray): Handle non-send nodes.
-        && (node.asSend() != null)
+        && !element.isField()
         && !(element.isGetter() && selector.isCall())
         && !(element.isFunction() && selector.isGetter())
-        && !isOptimizableOperation(node, selector, element)) {
-      Send send = node.asSend();
-      Link<Node> nodes = send.isPropertyAccess ? null : send.arguments;
-      if (tryInlineMethod(element, selector, nodes, arguments, node)) {
+        && !isOptimizableOperation(selector, element)) {
+      if (tryInlineMethod(element, selector, arguments, node)) {
         return;
       }
     }
 
     HInstruction receiver = arguments[0];
     List<HInstruction> inputs = <HInstruction>[];
     bool isIntercepted = backend.isInterceptedSelector(selector);
     if (isIntercepted) {
       inputs.add(invokeInterceptor(receiver));
     }
@@ skipping 12 matching lines @@
       pushWithPosition(
           new HInvokeDynamicMethod(selector, inputs, isIntercepted),
           location);
     }
   }
 
   void pushInvokeStatic(Node location,
                         Element element,
                         List<HInstruction> arguments,
                         [HType type = null]) {
-    if (tryInlineMethod(element, null, null, arguments, location)) {
+    if (tryInlineMethod(element, null, arguments, location)) {
       return;
     }
 
     if (type == null) {
       type = new HType.inferredReturnTypeForElement(element, compiler);
       if (type.isUnknown()) {
         // TODO(ngeoffray): Only do this if knowing the return type is
         // useful.
         type =
             builder.backend.optimisticReturnTypesWithRecompilationOnTypeChange(
@@ skipping 431 matching lines @@
     // Generate a structure equivalent to:
     //   Iterator<E> $iter = <iterable>.iterator;
     //   while ($iter.moveNext()) {
     //     E <declaredIdentifier> = $iter.current;
     //     <body>
     //   }
 
     // The iterator is shared between initializer, condition and body.
     HInstruction iterator;
     void buildInitializer() {
-      Selector selector = compiler.iteratorSelector;
+      Selector selector = elements.getIteratorSelector(node);
       visit(node.expression);
       HInstruction receiver = pop();
       pushInvokeDynamic(node, selector, [receiver]);
       iterator = pop();
     }
     HInstruction buildCondition() {
-      Selector selector = compiler.moveNextSelector;
+      Selector selector = elements.getMoveNextSelector(node);
       pushInvokeDynamic(node, selector, [iterator]);
       return popBoolified();
     }
     void buildBody() {
-      Selector call = compiler.currentSelector;
+      Selector call = elements.getCurrentSelector(node);
       pushInvokeDynamic(node, call, [iterator]);
 
       Node identifier = node.declaredIdentifier;
       Element variable = elements[identifier];
       Selector selector = elements.getSelector(identifier);
 
       HInstruction value = pop();
       if (identifier.asSend() != null
           && Elements.isInstanceSend(identifier, elements)) {
         HInstruction receiver = generateInstanceSendReceiver(identifier);
@@ skipping 1157 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;
   }
 }