Do less inlining in lazy initializer expressions.

pkg/compiler/lib/src/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;
 
 class SsaFunctionCompiler implements FunctionCompiler {
   SsaCodeGeneratorTask generator;
   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
@@ skipping 916 matching lines @@
 /**
  * This class builds SSA nodes for functions represented in AST.
  */
 class SsaBuilder extends ResolvedVisitor {
   final Compiler compiler;
   final JavaScriptBackend backend;
   final ConstantSystem constantSystem;
   final CodegenWorkItem work;
   final RuntimeTypes rti;
   final bool generateSourceMap;
+  bool inLazyInitializerExpression = false;
 
   /* This field is used by the native handler. */
   final NativeEmitter nativeEmitter;
 
   final HGraph graph = new HGraph();
 
   /**
    * The current block to add instructions to. Might be null, if we are
    * visiting dead code, but see [isReachable].
    */
@@ skipping 321 matching lines @@
             && returnType.isEmpty
             && !returnType.isNullable) {
           isReachable = false;
           return false;
         }
       }
 
       return true;
     }
 
+    bool reductiveHeuristic() {
+      // The call is on a path which is executed rarely, so inline only if it
+      // does not make the program larger.
+      if (isCalledOnce(element)) {
+        return InlineWeeder.canBeInlined(function.node, -1, false);
+      }
+      // TODO(sra): Measure if inlining would 'reduce' the size.  One desirable
+      // case we miss my doing nothing is inlining very simple constructors
+      // where all fields are initialized with values from the arguments at this
+      // call site.  The code is slightly larger (`new Foo(1)` vs `Foo$(1)`) but
+      // that usually means the factory constructor is left unused and not
+      // emitted.
+      return false;
+    }
+
     bool heuristicSayGoodToGo() {
-      // Don't inline recursivly
+      // Don't inline recursively
       if (inliningStack.any((entry) => entry.function == function)) {
         return false;
       }
 
-      if (inExpressionOfThrow) return false;
+      if (element.isSynthesized) return true;
 
-      if (element.isSynthesized) return true;
+      if (inExpressionOfThrow || inLazyInitializerExpression) {
+        return reductiveHeuristic();
+      }
 
       if (cachedCanBeInlined == true) return cachedCanBeInlined;
 
       if (backend.functionsToAlwaysInline.contains(function)) {
         // Inline this function regardless of it's size.
         assert(InlineWeeder.canBeInlined(function.node, -1, false,
                                          allowLoops: true));
         return true;
       }
 
       int numParameters = function.functionSignature.parameterCount;
       int maxInliningNodes;
       bool useMaxInliningNodes = true;
       if (insideLoop) {
         maxInliningNodes = InlineWeeder.INLINING_NODES_INSIDE_LOOP +
             InlineWeeder.INLINING_NODES_INSIDE_LOOP_ARG_FACTOR * numParameters;
       } else {
         maxInliningNodes = InlineWeeder.INLINING_NODES_OUTSIDE_LOOP +
             InlineWeeder.INLINING_NODES_OUTSIDE_LOOP_ARG_FACTOR * numParameters;
       }
 
       // If a method is called only once, and all the methods in the
       // inlining stack are called only once as well, we know we will
       // save on output size by inlining this method.
-      TypesInferrer inferrer = compiler.typesTask.typesInferrer;
-      if (inferrer.isCalledOnce(element) && allInlinedFunctionsCalledOnce) {
+      if (isCalledOnce(element)) {
         useMaxInliningNodes = false;
       }
       bool canInline;
       ast.FunctionExpression functionNode = function.node;
       canInline = InlineWeeder.canBeInlined(
           functionNode, maxInliningNodes, useMaxInliningNodes);
       if (canInline) {
         backend.inlineCache.markAsInlinable(element, insideLoop: insideLoop);
       } else {
         backend.inlineCache.markAsNonInlinable(element, insideLoop: insideLoop);
@@ skipping 34 matching lines @@
       return true;
     }
 
     return false;
   }
 
   bool get allInlinedFunctionsCalledOnce {
     return inliningStack.isEmpty || inliningStack.last.allFunctionsCalledOnce;
   }
 
+  bool isCalledOnce(Element element) {
+    if (!allInlinedFunctionsCalledOnce) return false;
+    TypesInferrer inferrer = compiler.typesTask.typesInferrer;
+    return inferrer.isCalledOnce(element);
+  }
+
   inlinedFrom(Element element, f()) {
     assert(element is FunctionElement || element is VariableElement);
     return compiler.withCurrentElement(element, () {
       // The [sourceElementStack] contains declaration elements.
       sourceElementStack.add(element.declaration);
       var result = f();
       sourceElementStack.removeLast();
       return result;
     });
   }
@@ skipping 135 matching lines @@
     // Add the parameter as the last instruction of the entry block.
     // If the method is intercepted, we want the actual receiver
     // to be the first parameter.
     graph.entry.addBefore(graph.entry.last, parameter);
     HInstruction value = potentiallyCheckOrTrustType(parameter, field.type);
     add(new HFieldSet(field, thisInstruction, value));
     return closeFunction();
   }
 
   HGraph buildLazyInitializer(VariableElement variable) {
+    inLazyInitializerExpression = true;
     ast.Node node = variable.node;
     openFunction(variable, node);
     assert(invariant(variable, variable.initializer != null,
         message: "Non-constant variable $variable has no initializer."));
     visit(variable.initializer);
     HInstruction value = pop();
     value = potentiallyCheckOrTrustType(value, variable.type);
     closeAndGotoExit(new HReturn(value));
     return closeFunction();
   }
@@ skipping 5091 matching lines @@
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
     ClassElement cls = backend.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls, classWorld)));
   }
 }