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

runtime/vm/code_generator.cc

 // Copyright (c) 2013, 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.h"
 #include "vm/ast.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
@@ skipping 706 matching lines @@
 
 // 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,
                                      const String& target_name,
                                      const Array& arguments_descriptor,
                                      Function* result) {
+  ASSERT(FLAG_lazy_dispatchers);
   // 1. Check if there is a getter with the same name.
   const String& getter_name = String::Handle(Field::GetterName(target_name));
   const int kNumArguments = 1;
   ArgumentsDescriptor args_desc(
       Array::Handle(ArgumentsDescriptor::New(kNumArguments)));
   const Function& getter = Function::Handle(
       Resolver::ResolveDynamicForReceiverClass(receiver_class,
                                                getter_name,
                                                args_desc));
   if (getter.IsNull() || getter.IsMethodExtractor()) {
@@ skipping 20 matching lines @@
   }
   *result = target_function.raw();
   return true;
 }
 
 
 // Handle other invocations (implicit closures, noSuchMethod).
 RawFunction* InlineCacheMissHelper(
     const Instance& receiver,
     const ICData& ic_data) {
+  if (!FLAG_lazy_dispatchers) {
+    return Function::null();  // We'll handle it in the runtime.
+  }
+
   const Array& args_descriptor = Array::Handle(ic_data.arguments_descriptor());
 
   const Class& receiver_class = Class::Handle(receiver.clazz());
   const String& target_name = String::Handle(ic_data.target_name());
 
   Function& result = Function::Handle();
   if (!ResolveCallThroughGetter(receiver,
                                 receiver_class,
                                 target_name,
                                 args_descriptor,
                                 &result)) {
-    if (!FLAG_lazy_dispatchers) {
-      return result.raw();  // Return null.
-    }
     ArgumentsDescriptor desc(args_descriptor);
     const Function& target_function =
         Function::Handle(receiver_class.GetInvocationDispatcher(
             target_name,
             args_descriptor,
             RawFunction::kNoSuchMethodDispatcher));
     if (FLAG_trace_ic) {
       OS::PrintErr("NoSuchMethod IC miss: adding <%s> id:%" Pd " -> <%s>\n",
           Class::Handle(receiver.clazz()).ToCString(),
           receiver.GetClassId(),
@@ skipping 244 matching lines @@
 // Arg1: IC data
 // Arg2: arguments descriptor array
 // Arg3: arguments array
 DEFINE_RUNTIME_ENTRY(InvokeNoSuchMethodDispatcher, 4) {
   ASSERT(!FLAG_lazy_dispatchers);
   const Instance& receiver = Instance::CheckedHandle(arguments.ArgAt(0));
   const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(1));
   const Array& orig_arguments_desc = Array::CheckedHandle(arguments.ArgAt(2));
   const Array& orig_arguments = Array::CheckedHandle(arguments.ArgAt(3));
   const String& target_name = String::Handle(ic_data.target_name());
+
+  Class& cls = Class::Handle(receiver.clazz());
+  Function& function = Function::Handle();
+
+  // Ugh. Dart distinguishes getters and regular methods and allows their calls
+  // to mix with conversions, and its selectors are independent of arity. So do
+  // a zigzagged lookup to see if this call failed because of an arity mismatch,
+  // need for conversion, or there really is no such method.
+
+  const bool is_getter = Field::IsGetterName(target_name);
+  if (is_getter) {
+    // o.foo failed, closurize o.foo() if it exists
+    const String& field_name =
+      String::Handle(Field::NameFromGetter(target_name));
+    while (!cls.IsNull()) {
+      function ^= cls.LookupDynamicFunction(field_name);
+      if (!function.IsNull()) {
+        const Function& closure_function =
+            Function::Handle(function.ImplicitClosureFunction());
+        const Object& result =
+            Object::Handle(closure_function.ImplicitInstanceClosure(receiver));
+        arguments.SetReturn(result);
+        return;
+      }
+      cls = cls.SuperClass();
+    }
+  } else {
+    // o.foo(...) failed, invoke noSuchMethod is foo exists but has the wrong
+    // number of arguments, or try (o.foo).call(...)
+
+    if ((target_name.raw() == Symbols::Call().raw()) && receiver.IsClosure()) {
+      // Special case: closures are implemented with a call getter instead of a
+      // call method and with lazy dispatchers the field-invocation-dispatcher
+      // would perform the closure call.

[rmacnak, 2015/06/19 17:02:49]

In fact, every closure call goes through the runtime :(

[Florian Schneider, 2015/06/29 10:37:53]

Yes, that's a bit unfortunate. Let's discuss how to improve on this.

[rmacnak, 2015/06/29 21:54:19]

It may be enough to just emit the field-invocation methods for all signature
classes in precompilation.

+      const Object& result =
+        Object::Handle(DartEntry::InvokeClosure(orig_arguments,
+                                                orig_arguments_desc));
+      CheckResultError(result);
+      arguments.SetReturn(result);
+      return;
+    }
+
+    const String& getter_name = String::Handle(Field::GetterName(target_name));
+    while (!cls.IsNull()) {
+      function ^= cls.LookupDynamicFunction(target_name);
+      if (!function.IsNull()) {
+        ArgumentsDescriptor args_desc(orig_arguments_desc);
+        ASSERT(!function.AreValidArguments(args_desc, NULL));
+        break;  // mismatch, invoke noSuchMethod
+      }
+      function ^= cls.LookupDynamicFunction(getter_name);
+      if (!function.IsNull()) {
+        const Array& getter_arguments = Array::Handle(Array::New(1));
+        getter_arguments.SetAt(0, receiver);
+        const Object& getter_result =
+          Object::Handle(DartEntry::InvokeFunction(function,
+                                                   getter_arguments));
+        CheckResultError(getter_result);
+        ASSERT(getter_result.IsNull() || getter_result.IsInstance());
+
+        orig_arguments.SetAt(0, getter_result);
+        const Object& call_result =
+          Object::Handle(DartEntry::InvokeClosure(orig_arguments,
+                                                  orig_arguments_desc));
+        CheckResultError(call_result);
+        arguments.SetReturn(call_result);
+        return;
+      }
+      cls = cls.SuperClass();
+    }
+  }
+
   // Handle noSuchMethod invocation.
   const Object& result = Object::Handle(
       DartEntry::InvokeNoSuchMethod(receiver,
                                     target_name,
                                     orig_arguments,
                                     orig_arguments_desc));
   CheckResultError(result);
   arguments.SetReturn(result);
 }
 
@@ skipping 661 matching lines @@
   const intptr_t elm_size = old_data.ElementSizeInBytes();
   const TypedData& new_data =
       TypedData::Handle(TypedData::New(cid, new_size, Heap::kOld));
   TypedData::Copy(new_data, 0, old_data, 0, old_size * elm_size);
   typed_data_cell.SetAt(0, new_data);
   arguments.SetReturn(new_data);
 }
 
 
 }  // namespace dart