dart2js: Turn the CPS inlining cache into a general compilation cache.

pkg/compiler/lib/src/cps_ir/inline.dart

 // Copyright (c) 2015, 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.
 
 library cps_ir.optimization.inline;
 
 import 'cps_fragment.dart';
 import 'cps_ir_builder.dart' show ThisParameterLocal;
 import 'cps_ir_nodes.dart';
 import 'optimizers.dart';
@@ skipping 68 matching lines @@
 /// During inlining a cache is used to remember inlining decisions for shared
 /// parts of the call graph, to avoid exploring them more than once.
 ///
 /// The cache maps a tuple of (function element, call structure,
 /// abstract receiver, abstract arguments) to a boolean inlining decision and
 /// an IR function definition if the decision is positive.
 class InliningCache {
   static const int ABSENT = -1;
   static const int NO_INLINE = 0;
 
+  final Map<ExecutableElement, FunctionDefinition> unoptimized =
+      <ExecutableElement, FunctionDefinition>{};
+
   final Map<ExecutableElement, List<CacheEntry>> map =
       <ExecutableElement, List<CacheEntry>>{};
 
   // When function definitions are put into or removed from the cache, they are
   // copied because the compiler passes will mutate them.
   final CopyingVisitor copier = new CopyingVisitor();
 
   void _putInternal(ExecutableElement element, CallStructure callStructure,
       TypeMask receiver,
       List<TypeMask> arguments,
@@ skipping 38 matching lines @@
             FunctionDefinition function = copier.copy(entry.function);
             ParentVisitor.setParents(function);
             return function;
           }
           return NO_INLINE;
         }
       }
     }
     return ABSENT;
   }
+
+  /// Cache the unoptimized CPS term for a function.
+  ///
+  /// The unoptimized term should not have any inlining-context-specific
+  /// optimizations applied to it.  It will be used to compile the
+  /// non-specialized version of the function.
+  void putUnoptimized(ExecutableElement element, FunctionDefinition function) {
+    unoptimized.putIfAbsent(element, () => copier.copy(function));
+  }
+
+  /// Look up the unoptimized CPS term for a function.
+  ///
+  /// The unoptimized term will not have any inlining-context-specific
+  /// optimizations applied to it.  It can be used to compile the
+  /// non-specialized version of the function.
+  FunctionDefinition getUnoptimized(ExecutableElement element) {
+    FunctionDefinition function = unoptimized[element];
+    if (function != null) {
+      function = copier.copy(function);
+      ParentVisitor.setParents(function);
+    }
+    return function;
+  }
 }
 
 class Inliner implements Pass {
   get passName => 'Inline calls';
 
   final CpsFunctionCompiler functionCompiler;
 
   final InliningCache cache = new InliningCache();
 
   final List<StackEntry> stack = <StackEntry>[];
@@ skipping 279 matching lines @@
 
     FunctionDefinition function;
     if (callStructure != null &&
         target.functionSignature.parameterCount !=
             callStructure.argumentCount) {
       // The argument count at the call site does not match the target's
       // formal parameter count.  Build the IR term for an adapter function
       // body.
       function = buildAdapter(invoke, target);
     } else {
-      function = _inliner.functionCompiler.compileToCpsIr(target);
+      function = compileToCpsIr(target);
       void setValue(Variable variable, Reference<Primitive> value) {
         variable.type = value.definition.type;
       }
       if (invoke.callingConvention == CallingConvention.Intercepted) {
         setValue(function.thisParameter, invoke.receiver);
         function.parameters[0].type = abstractReceiverInMethod;
         for (int i = 1; i < invoke.arguments.length; ++i) {
           setValue(function.parameters[i], invoke.arguments[i]);
         }
       } else {
@@ skipping 77 matching lines @@
       // We cannot inline a constructor invocation containing type arguments
       // because CreateInstance in the body does not know the type arguments.
       // We would incorrectly instantiate a class like A instead of A<B>.
       // TODO(kmillikin): try to fix this.
       GenericType generic = node.dartType;
       if (generic.typeArguments.any((DartType t) => !t.isDynamic)) return null;
     }
     return tryInlining(node, node.target, null);
   }
 }