Support for inlining small methods (independent of they're called inside a loop or not)

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;
 
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked;
 
   JavaScriptItemCompilationContext()
@@ skipping 104 matching lines @@
                                    List<jsAst.Expression> arguments) {
     DartType type = node.typeExpression;
     assert(type.isMalformed);
     String reasons = Types.fetchReasonsFromMalformedType(type);
     arguments.add(js.string('$type'));
     // TODO(johnniwinther): Handle escaping correctly.
     arguments.add(js.string(reasons));
   }
 }
 
+/*
+ * Invariants:
+ *   canInline(function) implies canInline(function, insideLoop:true)
+ *   !canInline(function, insideLoop: true) implies !canInline(function)
+ */
+class FunctionInlineCache {
+  final Map<FunctionElement, bool> canBeInlined =
+      new Map<FunctionElement, bool>();
+
+  final Map<FunctionElement, bool> canBeInlinedInsideLoop =
+      new Map<FunctionElement, bool>();
+
+  // Returns [:true:]/[:false:] if we have a cached decision.
+  // Returns [:null:] otherwise.
+  bool canInline(FunctionElement element, {bool insideLoop}) {
+    return insideLoop ? canBeInlinedInsideLoop[element] : canBeInlined[element];
+  }
+
+  void markAsInlinable(FunctionElement element, {bool insideLoop}) {
+    if (insideLoop) {
+      canBeInlinedInsideLoop[element] = true;
+    } else {
+      // If we can inline a function outside a loop then we should do it inside
+      // a loop as well.
+      canBeInlined[element] = true;
+      canBeInlinedInsideLoop[element] = true;
+    }
+  }
+
+  void markAsNonInlinable(FunctionElement element, {bool insideLoop}) {
+    if (insideLoop) {
+      // If we can't inline a function inside a loop, then we should not inline
+      // it outside a loop either.
+      canBeInlined[element] = false;
+      canBeInlinedInsideLoop[element] = false;
+    } else {
+      canBeInlined[element] = false;
+    }
+  }
+}
+
 
 class JavaScriptBackend extends Backend {
   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
   SsaCodeGeneratorTask generator;
   CodeEmitterTask emitter;
 
   /**
    * The generated code as a js AST for compiled methods.
    */
   Map<Element, jsAst.Expression> get generatedCode {
     return compiler.enqueuer.codegen.generatedCode;
   }
 
   /**
    * The generated code as a js AST for compiled bailout methods.
    */
   final Map<Element, jsAst.Expression> generatedBailoutCode =
       new Map<Element, jsAst.Expression>();
 
-  /**
-   * Keep track of which function elements are simple enough to be
-   * inlined in callers.
-   */
-  final Map<FunctionElement, bool> canBeInlined =
-      new Map<FunctionElement, bool>();
+  FunctionInlineCache inlineCache = new FunctionInlineCache();
 
   ClassElement jsInterceptorClass;
   ClassElement jsStringClass;
   ClassElement jsArrayClass;
   ClassElement jsNumberClass;
   ClassElement jsIntClass;
   ClassElement jsDoubleClass;
   ClassElement jsNullClass;
   ClassElement jsBoolClass;
   ClassElement jsUnknownClass;
@@ skipping 268 matching lines @@
         compiler.findInterceptor(const SourceString('setDispatchProperty'));
     getNativeInterceptorMethod =
         compiler.findInterceptor(const SourceString('getNativeInterceptor'));
     initializeDispatchPropertyMethod =
         compiler.findInterceptor(
             new SourceString(emitter.nameOfDispatchPropertyInitializer));
     defineNativeMethodsFinishMethod =
         compiler.findHelper(const SourceString('defineNativeMethodsFinish'));
 
     // These methods are overwritten with generated versions.
-    canBeInlined[getInterceptorMethod] = false;
-    canBeInlined[getDispatchPropertyMethod] = false;
-    canBeInlined[setDispatchPropertyMethod] = false;
+    inlineCache.markAsNonInlinable(getInterceptorMethod, insideLoop: true);
+    inlineCache.markAsNonInlinable(getDispatchPropertyMethod, insideLoop: true);
+    inlineCache.markAsNonInlinable(setDispatchPropertyMethod, insideLoop: true);
 
     List<ClassElement> classes = [
       jsInterceptorClass =
           compiler.findInterceptor(const SourceString('Interceptor')),
       jsStringClass = compiler.findInterceptor(const SourceString('JSString')),
       jsArrayClass = compiler.findInterceptor(const SourceString('JSArray')),
       // The int class must be before the double class, because the
       // emitter relies on this list for the order of type checks.
       jsIntClass = compiler.findInterceptor(const SourceString('JSInt')),
       jsDoubleClass = compiler.findInterceptor(const SourceString('JSDouble')),
@@ skipping 990 matching lines @@
   }
 }
 
 /// Records that [type] is used by [user.element].
 class Dependency {
   final DartType type;
   final TreeElements user;
 
   const Dependency(this.type, this.user);
 }