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

sdk/lib/_internal/compiler/implementation/enqueue.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 dart2js;
 
 class EnqueueTask extends CompilerTask {
   final ResolutionEnqueuer resolution;
   final CodegenEnqueuer codegen;
 
@@ skipping 219 matching lines @@
         enableNoSuchMethod(member);
       }
       if (member.name == Compiler.CALL_OPERATOR_NAME &&
           !cls.typeVariables.isEmpty) {
         registerGenericCallMethod(member, compiler.globalDependencies);
       }
       // If there is a property access with the same name as a method we
       // need to emit the method.
       if (universe.hasInvokedGetter(member, compiler)) {
         registerClosurizedMember(member, compiler.globalDependencies);
-        // We will emit a closure, so make sure the closure class is
-        // generated.
-        registerInstantiatedClass(compiler.boundClosureClass,
-                                  // Precise dependency is not important here.
-                                  compiler.globalDependencies);
         return addToWorkList(member);
       }
       // Store the member in [instanceFunctionsByName] to catch
       // getters on the function.
       Link<Element> members = instanceFunctionsByName.putIfAbsent(
           memberName, () => const Link<Element>());
       instanceFunctionsByName[memberName] = members.prepend(member);
       if (universe.hasInvocation(member, compiler)) {
         return addToWorkList(member);
       }
@@ skipping 200 matching lines @@
           }
         }
         addToWorkList(member);
         return true;
       }
       return false;
     });
     if (selector.isGetter()) {
       processInstanceFunctions(methodName, (Element member) {
         if (selector.appliesUnnamed(member, compiler)) {
-          // We will emit a closure, so make sure the bound closure class is
-          // generated.
-          registerInstantiatedClass(compiler.boundClosureClass,
-                                    // Precise dependency is not important here.
-                                    compiler.globalDependencies);
+          registerBoundClosure();
           return true;
         }
         return false;
       });
     }
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
@@ skipping 66 matching lines @@
   void registerAsCheck(DartType type, TreeElements elements) {
     registerIsCheck(type, elements);
     compiler.backend.registerAsCheck(type, elements);
   }
 
   void registerGenericCallMethod(Element element, TreeElements elements) {
     compiler.backend.registerGenericCallMethod(element, this, elements);
     universe.genericCallMethods.add(element);
   }
 
+  void registerBoundClosure() {
+    registerInstantiatedClass(compiler.boundClosureClass,
+                              // Precise dependency is not important here.
+                              compiler.globalDependencies);
+  }
+
   void registerClosurizedMember(Element element, TreeElements elements) {
     if (element.computeType(compiler).containsTypeVariables) {
       registerClosurizedGenericMember(element, elements);
+    } else {
+      registerBoundClosure();
     }
     universe.closurizedMembers.add(element);
   }
 
   void registerClosurizedGenericMember(Element element, TreeElements elements) {
+    registerBoundClosure();
     compiler.backend.registerGenericClosure(element, this, elements);
     universe.closurizedGenericMembers.add(element);
   }
 
   void forEach(f(WorkItem work));
 
   void forEachPostProcessTask(f(PostProcessTask work)) {}
 
   void logSummary(log(message)) {
     _logSpecificSummary(log);
@@ skipping 189 matching lines @@
     while(!queue.isEmpty) {
       // TODO(johnniwinther): Find an optimal process order for codegen.
       f(queue.removeLast());
     }
   }
 
   void _logSpecificSummary(log(message)) {
     log('Compiled ${generatedCode.length} methods.');
   }
 }