Handle field-invocation and method-extraction in the runtime when --lazy_dispatchers=false.

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"
 #include "vm/object_store.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, trace_resolving, false, "Trace resolving.");
-
+DECLARE_FLAG(bool, lazy_dispatchers);
 
 // 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
 // arguments. The dynamic resolver actually checks that a valid number of named
 // arguments is passed in.
 RawFunction* Resolver::ResolveDynamic(const Instance& receiver,
                                       const String& function_name,
                                       const ArgumentsDescriptor& args_desc) {
@@ skipping 31 matching lines @@
 }
 
 
 // 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.
@@ skipping 38 matching lines @@
 
   // 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 (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);
-        return function.raw();
+    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);
+          return function.raw();
+        }
       }
     }
     cls = cls.SuperClass();
   }
   return function.raw();
 }
 
 
 RawFunction* Resolver::ResolveStatic(const Library& library,
                                      const String& class_name,
@@ skipping 104 matching lines @@
       OS::Print("ResolveStaticAllowPrivate error '%s': %s.\n",
                 function_name.ToCString(),
                 error_message.ToCString());
     }
     return Function::null();
   }
   return function.raw();
 }
 
 }  // namespace dart