VM: Precompile method extractors for implicit and explicit closurization.

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/dart_entry.h"
 #include "vm/flags.h"
 #include "vm/isolate.h"
 #include "vm/object.h"
@@ skipping 41 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
-// owning method M.
-static RawFunction* CreateMethodExtractor(const String& getter_name,
-                                          const Function& method) {
-  ASSERT(FLAG_lazy_dispatchers);
-  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.
-                  false,  // Not native.
-                  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(Object::extractor_parameter_types());
-  extractor.set_parameter_names(Object::extractor_parameter_names());
-  extractor.set_result_type(Type::Handle(Type::DynamicType()));
-
-  extractor.set_extracted_method_closure(closure_function);
-  extractor.set_is_debuggable(false);
-  extractor.set_is_visible(false);
-
-  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);
 
     if (field_name.CharAt(0) == '#') {
       if (!FLAG_lazy_dispatchers) {
         return Function::null();
       }
 
       // Resolving a getter "get:#..." is a request to closurize an instance
       // property of the receiver object. It can be of the form:
       //  - get:#id, which closurizes a method or getter id
       //  - get:#set:id, which closurizes a setter id
       //  - get:#operator, eg. get:#<<, which closurizes an operator method.
       // If the property can be resolved, a method extractor function
       // "get:#..." is created and injected into the receiver's class.
-      String& property_name = String::Handle(String::SubString(field_name, 1));
-      ASSERT(!Field::IsGetterName(property_name));
+      field_name = String::SubString(field_name, 1);
+      ASSERT(!Field::IsGetterName(field_name));
 
       String& property_getter_name = String::Handle();
-      if (!Field::IsSetterName(property_name)) {
+      if (!Field::IsSetterName(field_name)) {
         // If this is not a setter, we need to look for both the regular
         // name and the getter name. (In the case of an operator, this
         // code will also try to resolve for example get:<< and will fail,
         // but that's harmless.)
-        property_getter_name = Field::GetterName(property_name);
+        property_getter_name = Field::GetterName(field_name);
       }
 
       Function& function = Function::Handle();
       while (!cls.IsNull()) {
-        function = cls.LookupDynamicFunction(property_name);
+        function = cls.LookupDynamicFunction(field_name);
         if (!function.IsNull()) {
-          return CreateMethodExtractor(function_name, function);
+          return function.GetMethodExtractor(function_name);
         }
         if (!property_getter_name.IsNull()) {
           function = cls.LookupDynamicFunction(property_getter_name);
           if (!function.IsNull()) {
-            return CreateMethodExtractor(function_name, function);
+            return function.GetMethodExtractor(function_name);
           }
         }
         cls = cls.SuperClass();
       }
       return Function::null();
     }
   }
 
   // Now look for an instance function whose name matches function_name
   // in the class.
   Function& function = Function::Handle();
   while (!cls.IsNull()) {
     function ^= cls.LookupDynamicFunction(function_name);
     if (!function.IsNull()) {
       return function.raw();
     }
     // Getter invocation might actually be a method extraction.
     if (FLAG_lazy_dispatchers) {
       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);
+          // The extractor does not exist yet, so using GetMethodExtractor is
+          // not necessary here.
+          function ^= function.CreateMethodExtractor(function_name);
           return function.raw();
         }
       }
     }
     cls = cls.SuperClass();
   }
   return function.raw();
 }
 
 
@@ skipping 106 matching lines @@
       OS::Print("ResolveStaticAllowPrivate error '%s': %s.\n",
                 function_name.ToCString(),
                 error_message.ToCString());
     }
     return Function::null();
   }
   return function.raw();
 }
 
 }  // namespace dart