Create and cache method extraction stub in the ICData.

runtime/vm/code_generator.cc

 // 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.
 
 #include "vm/code_generator.h"
 
 #include "vm/assembler_macros.h"
 #include "vm/ast.h"
 #include "vm/bigint_operations.h"
 #include "vm/code_patcher.h"
@@ skipping 1079 matching lines @@
   ic_data.AddCheck(class_ids, target_function);
 }
 
 
 // An instance call could not be resolved by an IC miss handler.  Check if
 // it was a getter call and if there is an instance function with the same
 // name.  If so, create and return an implicit closure from the function.
 // Otherwise return null.
 static RawInstance* ResolveImplicitClosure(const Instance& receiver,
                                            const Class& receiver_class,
-                                           const String& target_name) {
+                                           const String& target_name,
+                                           const ICData& ic_data) {
   // 1. Check if was a getter call.
   if (!Field::IsGetterName(target_name)) return Instance::null();
 
   // 2. Check if there is an instance function with the same name.
   String& function_name = String::Handle(Field::NameFromGetter(target_name));
   function_name = Symbols::New(function_name);
   const Function& function = Function::Handle(
       Resolver::ResolveDynamicAnyArgs(receiver_class, function_name));
   if (function.IsNull()) return Instance::null();
 
   // Create a closure object for the implicit closure function.
   const Function& closure_function =
       Function::Handle(function.ImplicitClosureFunction());
   const Context& context = Context::Handle(Context::New(1));
   context.SetAt(0, receiver);
   const Instance& closure =
       Instance::Handle(Closure::New(closure_function, context));
   if (receiver_class.HasTypeArguments()) {
     const AbstractTypeArguments& type_arguments =
         AbstractTypeArguments::Handle(receiver.GetTypeArguments());
     closure.SetTypeArguments(type_arguments);
   }
+
+  ASSERT(ic_data.num_args_tested() == 1);
+  ic_data.AddReceiverCheck(
+      receiver_class.id(),
+      Function::Handle(StubCode::GetMethodExtractor(closure_function)));
   return closure.raw();
 }
 
 
 static RawInstructions* EnsureCompiled(const Function& function) {
   if (!function.HasCode()) {
     const Error& error = Error::Handle(Compiler::CompileFunction(function));
     if (!error.IsNull()) {
       Exceptions::PropagateError(error);
     }
@@ skipping 264 matching lines @@
 
   Class& receiver_class = Class::Handle(receiver.clazz());
   // For lookups treat null as an instance of class Object.
   if (receiver_class.IsNullClass()) {
     receiver_class = isolate->object_store()->object_class();
   }
   const String& target_name = String::Handle(ic_data.target_name());
 
   Instance& closure = Instance::Handle(ResolveImplicitClosure(receiver,
                                                               receiver_class,
-                                                              target_name));
+                                                              target_name,
+                                                              ic_data));
   if (!closure.IsNull()) {
     arguments.SetReturn(closure);
     return;
   }
 
   Object& result = Object::Handle();
   if (!ResolveCallThroughGetter(receiver,
                                 receiver_class,
                                 target_name,
                                 args_descriptor,
@@ skipping 537 matching lines @@
     return;
   }
   HeapTrace* heap_trace = Isolate::Current()->heap()->trace();
   heap_trace->TraceStoreIntoObject(RawObject::ToAddr(object),
                                    field_addr,
                                    RawObject::ToAddr(value));
 }
 END_LEAF_RUNTIME_ENTRY
 
 }  // namespace dart