Add a whitelist for functions that we always want to inline.

sdk/lib/_internal/compiler/implementation/js_backend/backend.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 js_backend;
 
 const VERBOSE_OPTIMIZER_HINTS = false;
 
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked = new Set<HInstruction>();
@@ skipping 38 matching lines @@
     } else {
       canBeInlined[element] = false;
     }
   }
 }
 
 class JavaScriptBackend extends Backend {
   static final Uri DART_JS_HELPER = new Uri(scheme: 'dart', path: '_js_helper');
   static final Uri DART_INTERCEPTORS =
       new Uri(scheme: 'dart', path: '_interceptors');
+  static final Uri DART_INTERNAL =
+      new Uri(scheme: 'dart', path: '_internal');
   static final Uri DART_FOREIGN_HELPER =
       new Uri(scheme: 'dart', path: '_foreign_helper');
   static final Uri DART_JS_MIRRORS =
       new Uri(scheme: 'dart', path: '_js_mirrors');
   static final Uri DART_JS_NAMES =
       new Uri(scheme: 'dart', path: '_js_names');
   static final Uri DART_ISOLATE_HELPER =
       new Uri(scheme: 'dart', path: '_isolate_helper');
   static final Uri DART_HTML =
       new Uri(scheme: 'dart', path: 'html');
 
   static const String INVOKE_ON = '_getCachedInvocation';
   static const String START_ROOT_ISOLATE = 'startRootIsolate';
 
+
+  /// The list of functions for classes in the [internalLibrary] that we want
+  /// to inline always.  Any function in this list must be inlinable with
+  /// respect to the conditions used in [InlineWeeder.canInline], except for
+  /// size/complexity heuristics.
+  static const Map<String, List<String>> ALWAYS_INLINE =
+      const <String, List<String>> {
+    'IterableMixinWorkaround': const <String>['forEach'],
+    'ListIterator': const <String>['moveNext']
+  };
+
+  /// List if [FunctionElement]s that we want to inline always.  This list is

[Johnni Winther, 2014/09/04 07:33:40]

'List if' -> 'List of'.

[karlklose, 2014/09/04 07:54:04]

Done.

+  /// filled when resolution is complete by looking up in [internalLibrary].
+  List<FunctionElement> functionsToAlwaysInline;
+
+  /// Reference to the internal library to lookup functions to always inline.
+  LibraryElement internalLibrary;
+
+
   /// Set of classes that need to be considered for reflection although not
   /// otherwise visible during resolution.
   Iterable<ClassElement> get classesRequiredForReflection {
     // TODO(herhut): Clean this up when classes needed for rti are tracked.
     return [closureClass, jsIndexableClass];
   }
 
   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
   SsaCodeGeneratorTask generator;
@@ skipping 795 matching lines @@
       assert(traceHelper != null);
       enqueueInResolution(traceHelper, registry);
     }
     registerCheckedModeHelpers(registry);
   }
 
   onResolutionComplete() {
     super.onResolutionComplete();
     computeMembersNeededForReflection();
     rti.computeClassesNeedingRti();
+    computeFunctionsToAlwaysInline();
+  }
+
+  void computeFunctionsToAlwaysInline() {
+    functionsToAlwaysInline = <FunctionElement>[];
+    if (internalLibrary == null) return;
+
+    // Try to find all functions intended to always inline.  If their enclosing
+    // class is not resolved we skip the methods, but it is an error to mention
+    // a function or class that cannot be found.
+    for (String className in ALWAYS_INLINE.keys) {
+      ClassElement cls = find(internalLibrary, className);
+      if (cls.resolutionState != STATE_DONE) continue;
+      for (String functionName in ALWAYS_INLINE[className]) {
+        Element function = cls.lookupMember(functionName);
+        assert(invariant(cls, function is FunctionElement,
+            message: 'unable to find function $functionName in $className'));
+        functionsToAlwaysInline.add(function);
+      }
+    }
   }
 
   void registerGetRuntimeTypeArgument(Registry registry) {
     enqueueInResolution(getGetRuntimeTypeArgument(), registry);
     enqueueInResolution(getGetTypeArgumentByIndex(), registry);
     enqueueInResolution(getCopyTypeArguments(), registry);
   }
 
   void registerCallMethodWithFreeTypeVariables(
       Element callMethod,
@@ skipping 751 matching lines @@
           jsBoolClass = findClass('JSBool'),
           jsMutableArrayClass = findClass('JSMutableArray'),
           jsFixedArrayClass = findClass('JSFixedArray'),
           jsExtendableArrayClass = findClass('JSExtendableArray'),
           jsPlainJavaScriptObjectClass = findClass('PlainJavaScriptObject'),
           jsUnknownJavaScriptObjectClass = findClass('UnknownJavaScriptObject'),
         ];
 
         jsIndexableClass = findClass('JSIndexable');
         jsMutableIndexableClass = findClass('JSMutableIndexable');
+      } else if (uri == DART_INTERNAL) {
+        internalLibrary = library;

[Johnni Winther, 2014/09/04 07:33:40]

Put this in [onLibraryCreated] instead.

[karlklose, 2014/09/04 07:54:04]

Done.

       } else if (uri == DART_JS_HELPER) {
         initializeHelperClasses();
         assertMethod = findHelper('assertHelper');
 
         typeLiteralClass = findClass('TypeImpl');
         constMapLiteralClass = findClass('ConstantMap');
         typeVariableClass = findClass('TypeVariable');
 
         jsIndexingBehaviorInterface = findClass('JavaScriptIndexingBehavior');
 
@@ skipping 694 matching lines @@
   }
 }
 
 /// Records that [constant] is used by the element behind [registry].
 class Dependency {
   final Constant constant;
   final Element annotatedElement;
 
   const Dependency(this.constant, this.annotatedElement);
 }