Precompile invoke-field-dispatchers for closures.

runtime/vm/precompiler.cc

 // 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.
 
 #include "vm/precompiler.h"
 
 #include "vm/compiler.h"
 #include "vm/isolate.h"
 #include "vm/log.h"
 #include "vm/longjump.h"
@@ skipping 383 matching lines @@
           if (!target.is_static()) {
             // Super call (should not enqueue selector) or dynamic call with a
             // CHA prediction (should enqueue selector).
             selector = call_site.target_name();
             AddSelector(selector);
           }
         } else {
           // A dynamic call.
           selector = call_site.target_name();
           AddSelector(selector);
+          if (selector.raw() == Symbols::Call().raw()) {
+            // Potential closure call.
+            AddClosureCall(call_site);
+          }
         }
       } else if (entry.IsField()) {
         // Potential need for field initializer.
         field ^= entry.raw();
         AddField(field);
       } else if (entry.IsInstance()) {
         // Potential const object.
         cls = entry.clazz();
         AddClass(cls);
       }
     }
   }
 }
 
 
+void Precompiler::AddClosureCall(const ICData& call_site) {
+  const Array& arguments_descriptor =
+      Array::Handle(Z, call_site.arguments_descriptor());
+  const Type& function_impl =
+      Type::Handle(Z, I->object_store()->function_impl_type());
+  const Class& cache_class =
+      Class::Handle(Z, function_impl.type_class());
+  const Function& dispatcher = Function::Handle(Z,
+      cache_class.GetInvocationDispatcher(Symbols::Call(),
+                                          arguments_descriptor,
+                                          RawFunction::kInvokeFieldDispatcher,
+                                          true /* create_if_absent */));
+  AddFunction(dispatcher);
+}
+
+
 void Precompiler::AddField(const Field& field) {
   if (field.is_static()) {
     // Potential const object. Uninitialized field will harmlessly do a
     // redundant add of the Null class.
     const Object& value = Object::Handle(Z, field.StaticValue());
     const Class& cls = Class::Handle(Z, value.clazz());
     AddClass(cls);
 
     if (field.has_initializer()) {
       if (field.HasPrecompiledInitializer()) return;
@@ skipping 191 matching lines @@
         for (intptr_t j = 0; j < closures.Length(); j++) {
           function ^= closures.At(j);
           ASSERT(function.HasCode());
         }
       }
     }
   }
 }
 
 }  // namespace dart