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 1109 matching lines @@
 
   const Object& result = Object::Handle(
       DartEntry::InvokeClosure(instance,
                                function_args,
                                args_descriptor));
   CheckResultError(result);
   arguments.SetReturn(result);
 }
 
 
+static const char* CreateMethodExtractorName(const Function& closure_function) {

[srdjan, 2013/01/16 22:08:56]

ASSERT(closure_function.IsClosureFunction()) ... also below.

[Vyacheslav Egorov (Google), 2013/01/17 12:46:38]

This method died.

+  const char* kFormat = "[MethodExtractor:%s]";
+  const char* function_name =
+      String::Handle(closure_function.name()).ToCString();
+  intptr_t len = OS::SNPrint(NULL, 0, kFormat, function_name) + 1;
+  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+  OS::SNPrint(chars, len, kFormat, function_name);
+  return chars;
+}
+
+
+static RawFunction* GetMethodExtractor(const Function& closure_function) {

[srdjan, 2013/01/16 22:08:56]

Please add a brief comment what a method extractor is for.

[Vyacheslav Egorov (Google), 2013/01/17 12:46:38]

Done.

+  Function& extractor = Function::Handle(closure_function.method_extractor());
+  if (extractor.IsNull()) {
+    const char* name = CreateMethodExtractorName(closure_function);
+
+    const Class& owner = Class::Handle(closure_function.Owner());
+    extractor ^= Function::New(String::Handle(Symbols::New(name)),
+                               RawFunction::kMethodExtractor,
+                               false,  // Not static.
+                               false,  // Not const.
+                               false,  // Not abstract.
+                               false,  // Not external.
+                               owner,
+                               0);  // No token position.
+    // Initialize function's signature.
+    const intptr_t kNumParameters = 1;
+    extractor.set_num_fixed_parameters(kNumParameters);
+    extractor.SetNumOptionalParameters(0, 0);
+    extractor.set_parameter_types(Array::Handle(Array::New(kNumParameters,
+                                                           Heap::kOld)));
+    extractor.set_parameter_names(Array::Handle(Array::New(kNumParameters,
+                                                           Heap::kOld)));
+    extractor.SetParameterTypeAt(0, Type::Handle(Type::DynamicType()));
+    extractor.SetParameterNameAt(0, Symbols::This());
+    extractor.set_result_type(Type::Handle(Type::DynamicType()));
+
+    extractor.set_extracted_method_closure(closure_function);
+
+    Compiler::CompileFunction(extractor);
+  }
+  return extractor.raw();
+}
+
+
 // 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(GetMethodExtractor(closure_function)));
   return closure.raw();
 }
 
 
 // An instance call of the form o.f(...) could not be resolved.  Check if
 // there is a getter with the same name.  If so, invoke it.  If the value is
 // a closure, invoke it with the given arguments.  If the value is a
 // non-closure, attempt to invoke "call" on it.
 static bool ResolveCallThroughGetter(const Instance& receiver,
                                      const Class& receiver_class,
@@ skipping 57 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 503 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