Limit the amount of inlining we do to try to avoid generating too much code.

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 35 matching lines @@
       } else if (kind == ElementKind.FIELD) {
         assert(!element.isInstanceMember());
         graph = builder.buildLazyInitializer(element);
       } else {
         compiler.internalErrorOnElement(element,
                                         'unexpected element kind $kind');
       }
       assert(graph.isValid());
       if (!identical(kind, ElementKind.FIELD)) {
         FunctionElement function = element;
-        graph.calledInLoop = compiler.world.isCalledInLoop(function);
         FunctionSignature signature = function.computeSignature(compiler);
         signature.forEachOptionalParameter((Element parameter) {
           // This ensures the default value will be computed.
           builder.compileVariable(parameter);
         });
       }
 
       if (compiler.tracer.enabled) {
         String name;
         if (element.isMember()) {
@@ skipping 858 matching lines @@
       parameters = new Map<Element, HInstruction>(),
       sourceElementStack = <Element>[work.element],
       inliningStack = <InliningState>[],
       rti = builder.backend.rti,
       super(work.resolutionTree) {
     localsHandler = new LocalsHandler(this);
   }
 
   static const MAX_INLINING_DEPTH = 3;
   static const MAX_INLINING_NODES = 46;
+
   List<InliningState> inliningStack;
+
   Element returnElement;
   DartType returnType;
+
   bool inTryStatement = false;
+  int loopNesting = 0;
 
   HBasicBlock get current => _current;
   void set current(c) {
     isReachable = c != null;
     _current = c;
   }
 
   /**
    * Compiles compile-time constants. Never returns [:null:]. If the
    * initial value is not a compile-time constants, it reports an
@@ skipping 46 matching lines @@
     });
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [functionElement] must be an implementation element.
    */
   HGraph buildMethod(FunctionElement functionElement) {
     assert(invariant(functionElement, functionElement.isImplementation));
+    graph.calledInLoop = compiler.world.isCalledInLoop(functionElement);
     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('==')) {
@@ skipping 200 matching lines @@
                        Selector selector,
                        List<HInstruction> providedArguments,
                        Node currentNode) {
     backend.registerStaticUse(element, compiler.enqueuer.codegen);
     // 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 (loopNesting == 0 && !graph.calledInLoop) return false;
+    int maxDepth = (loopNesting > 0) ? MAX_INLINING_DEPTH : 1;
+    if (inliningStack.length >= maxDepth) return false;
 
     // Ensure that [element] is an implementation element.
     element = element.implementation;
     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;
@@ skipping 856 matching lines @@
     HBasicBlock startBlock;
     if (initialize != null) {
       HBasicBlock initializerBlock = openNewBlock();
       startBlock = initializerBlock;
       initialize();
       assert(!isAborted());
       initializerGraph =
           new SubExpression(initializerBlock, current);
     }
 
+    loopNesting++;
     JumpHandler jumpHandler = beginLoopHeader(loop);
     HLoopInformation loopInfo = current.loopInformation;
     HBasicBlock conditionBlock = current;
     if (startBlock == null) startBlock = conditionBlock;
 
     HInstruction conditionInstruction = condition();
     HBasicBlock conditionExitBlock =
         close(new HLoopBranch(conditionInstruction));
     SubExpression conditionExpression =
         new SubExpression(conditionBlock, conditionExitBlock);
@@ skipping 139 matching lines @@
         conditionBlock.setBlockFlow(labelInfo, current);
 
         jumpHandler.forEachBreak((HBreak breakInstruction, _) {
           HBasicBlock block = breakInstruction.block;
           block.addAtExit(new HBreak.toLabel(label));
           block.remove(breakInstruction);
         });
       }
     }
     jumpHandler.close();
+    loopNesting--;
   }
 
   visitFor(For node) {
     assert(isReachable);
     assert(node.body != null);
     void buildInitializer() {
       if (node.initializer == null) return;
       Node initializer = node.initializer;
       if (initializer != null) {
         visit(initializer);
@@ skipping 34 matching lines @@
                () {},
                buildCondition,
                () {},
                () { visit(node.body); });
   }
 
   visitDoWhile(DoWhile node) {
     assert(isReachable);
     LocalsHandler savedLocals = new LocalsHandler.from(localsHandler);
     localsHandler.startLoop(node);
+    loopNesting++;
     JumpHandler jumpHandler = beginLoopHeader(node);
     HLoopInformation loopInfo = current.loopInformation;
     HBasicBlock loopEntryBlock = current;
     HBasicBlock bodyEntryBlock = current;
     TargetElement target = elements[node];
     bool hasContinues = target != null && target.isContinueTarget;
     if (hasContinues) {
       // Add extra block to hang labels on.
       // It doesn't currently work if they are on the same block as the
       // HLoopInfo. The handling of HLabeledBlockInformation will visit a
@@ skipping 105 matching lines @@
             new HSubGraphBlockInformation(bodyGraph), <LabelElement>[label]);
         loopEntryBlock.setBlockFlow(info, current);
         jumpHandler.forEachBreak((HBreak breakInstruction, _) {
           HBasicBlock block = breakInstruction.block;
           block.addAtExit(new HBreak.toLabel(label));
           block.remove(breakInstruction);
         });
       }
     }
     jumpHandler.close();
+    loopNesting--;
   }
 
   visitFunctionExpression(FunctionExpression node) {
     ClosureClassMap nestedClosureData =
         compiler.closureToClassMapper.getMappingForNestedFunction(node);
     assert(nestedClosureData != null);
     assert(nestedClosureData.closureClassElement != null);
     ClassElement closureClassElement =
         nestedClosureData.closureClassElement;
     FunctionElement callElement = nestedClosureData.callElement;
@@ skipping 3065 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;
   }
 }