Create and cache method extraction stub in the ICData.

runtime/vm/resolver.cc

 // Copyright (c) 2011, 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/resolver.h"
 
 #include "vm/flags.h"
 #include "vm/isolate.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
+#include "vm/symbols.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, trace_resolving, false, "Trace resolving.");
 
 
 // The actual names of named arguments are not checked by the dynamic resolver,
 // but by the method entry code. It is important that the dynamic resolver
 // checks that no named arguments are passed to a method that does not accept
 // them, since the entry code of such a method does not check for named
@@ skipping 43 matching lines @@
       OS::Print("ResolveDynamic error '%s': %s.\n",
                 function_name.ToCString(),
                 error_message.ToCString());
     }
     return Function::null();
   }
   return function.raw();
 }
 
 
+// Method extractors are used to create implicit closures from methods.
+// When an expression obj.M is evaluated for the first time and receiver obj
+// does not have a getter called M but has a method called M then an extractor
+// is created and injected as a getter (under the name get:M) into the class
+// ownining method M.
+static RawFunction* CreateMethodExtractor(const String& getter_name,
+                                          const Function& method) {
+  const Function& closure_function =
+      Function::Handle(method.ImplicitClosureFunction());
+
+  const Class& owner = Class::Handle(closure_function.Owner());
+  Function& extractor = Function::Handle(
+    Function::New(String::Handle(Symbols::New(getter_name)),
+                  RawFunction::kMethodExtractor,
+                  false,  // Not static.
+                  false,  // Not const.
+                  false,  // Not abstract.
+                  false,  // Not external.
+                  owner,
+                  0));  // No token position.
+
+  // Initialize signature: receiver is a single fixed parameter.
+  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);
+
+  owner.AddFunction(extractor);
+
+  return extractor.raw();
+}
+
+
 RawFunction* Resolver::ResolveDynamicAnyArgs(
     const Class& receiver_class,
     const String& function_name) {
   Class& cls = Class::Handle(receiver_class.raw());
   if (FLAG_trace_resolving) {
     OS::Print("ResolveDynamic '%s' for class %s\n",
               function_name.ToCString(),
               String::Handle(cls.Name()).ToCString());
   }
+
+  const bool is_getter = Field::IsGetterName(function_name);
+  String& field_name = String::Handle();
+  if (is_getter) {
+    field_name ^= Field::NameFromGetter(function_name);
+  }
+
   // Now look for an instance function whose name matches function_name
   // in the class.
-  Function& function =
-      Function::Handle(cls.LookupDynamicFunction(function_name));
-  while (function.IsNull()) {
+  Function& function = Function::Handle();
+  while (function.IsNull() && !cls.IsNull()) {
+    function ^= cls.LookupDynamicFunction(function_name);
+
+    // Getter invocation might actually be a method extraction.
+    if (is_getter && function.IsNull()) {
+      function ^= cls.LookupDynamicFunction(field_name);
+      if (!function.IsNull()) {
+        // We were looking for the getter but found a method with the same name.
+        // Create a method extractor and return it.
+        function ^= CreateMethodExtractor(function_name, function);
+      }
+    }
+
     cls = cls.SuperClass();
-    if (cls.IsNull()) break;
-    function = cls.LookupDynamicFunction(function_name);
   }
   return function.raw();
 }
 
 
 RawFunction* Resolver::ResolveStatic(const Library& library,
                                      const String& class_name,
                                      const String& function_name,
                                      int num_arguments,
                                      const Array& argument_names,
@@ skipping 91 matching lines @@
       OS::Print("ResolveStatic error '%s': %s.\n",
                 function_name.ToCString(),
                 error_message.ToCString());
     }
     return Function::null();
   }
   return function.raw();
 }
 
 }  // namespace dart