[vm] Support implicit dynamic calls

According to the spec, a call in the form

  e(a0,...,aN)

where static type of 'e' is 'dynamic' should succeed only if
(1) 'e' evaluates to a function, or
(2) runtime type of 'e' has a 'call' *method*.

If runtime type of 'e' has a 'call' getter this invocation should
fail with NSM.

This behavior is different from 'e.call(a0,...,aN)' which accepts
'call' getters.

---

In order to implement this behavior in the VM, a special
'dyn:implicit:call' selector is added. It behaves similarly to
'dyn:call' except when looking for a getter target.

This selector is used when CFE sets FlagImplicitCall on a
DynamicInvocation node.


TEST=co19/Language/Expressions/Function_Invocation/Function_Expression_Invocation/call_A04_t01
TEST=co19/Language/Expressions/Function_Invocation/Function_Expression_Invocation/call_A04_t02

Fixes #59965
Issue #59952
Issue #51517
Issue dart-lang/language#3482

Change-Id: Ic45f7743ad75571476642dcec9c91e6a77e8e321
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/407161
Reviewed-by: Slava Egorov <[email protected]>
Commit-Queue: Alexander Markov <[email protected]>
Reviewed-by: Ryan Macnak <[email protected]>

Author: alexmarkov

runtime/vm/compiler/aot/precompiler.cc

@@ -993,6 +993,7 @@ void Precompiler::AddCalleesOfHelper(const Object& entry,
       const auto& call_site = UnlinkedCall::Cast(entry);
       // A dynamic call.
       *temp_selector = call_site.target_name();
+      *temp_selector = Function::DropImplicitCallPrefix(*temp_selector).ptr();
       AddSelector(*temp_selector);
       if (IsPotentialClosureCall(*temp_selector)) {
         const Array& arguments_descriptor =
@@ -1005,6 +1006,7 @@ void Precompiler::AddCalleesOfHelper(const Object& entry,
       // A dynamic call.
       const auto& cache = MegamorphicCache::Cast(entry);
       *temp_selector = cache.target_name();
+      *temp_selector = Function::DropImplicitCallPrefix(*temp_selector).ptr();
       AddSelector(*temp_selector);
       if (IsPotentialClosureCall(*temp_selector)) {
         const Array& arguments_descriptor =

runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc

@@ -2818,7 +2818,10 @@ Fragment StreamingFlowGraphBuilder::BuildMethodInvocation(TokenPosition* p,
   // read flags.
   const uint8_t flags = ReadFlags();
   bool is_invariant = false;
-  if (!is_dynamic) {
+  bool is_implicit_call = false;
+  if (is_dynamic) {
+    is_implicit_call = (flags & kDynamicInvocationFlagImplicitCall) != 0;
+  } else {
     is_invariant = (flags & kInstanceInvocationFlagInvariant) != 0;
   }
 
@@ -2939,14 +2942,17 @@ Fragment StreamingFlowGraphBuilder::BuildMethodInvocation(TokenPosition* p,
   //     at the entry because the parameter is marked covariant, neither of
   //     those cases require a dynamic invocation forwarder.
   const Function* direct_call_target = &direct_call.target_;
-  if (H.IsRoot(itarget_name) &&
-      (name.ptr() != Symbols::EqualOperator().ptr())) {
+  if (is_dynamic && (name.ptr() != Symbols::EqualOperator().ptr())) {
     mangled_name = &String::ZoneHandle(
         Z, Function::CreateDynamicInvocationForwarderName(name));
     if (!direct_call_target->IsNull()) {
       direct_call_target = &Function::ZoneHandle(
           direct_call_target->GetDynamicInvocationForwarder(*mangled_name));
     }
+    if (is_implicit_call) {
+      ASSERT(mangled_name->ptr() == Symbols::DynamicCall().ptr());
+      mangled_name = &Symbols::DynamicImplicitCall();
+    }
   }
 
   if (!direct_call_target->IsNull()) {

runtime/vm/compiler/frontend/kernel_to_il.cc

@@ -3640,6 +3640,7 @@ FlowGraph* FlowGraphBuilder::BuildGraphOfInvokeFieldDispatcher(
   const Class& owner = Class::Handle(Z, function.Owner());
   ASSERT(!owner.IsNull());
   auto& field_name = String::Handle(Z, function.name());
+  ASSERT(field_name.ptr() != Symbols::DynamicImplicitCall().ptr());
   // If the field name has a dyn: tag, then remove it. We don't add dynamic
   // invocation forwarders for field getters used for invoking, we just use
   // the tag in the name of the invoke field dispatcher to detect dynamic calls.

runtime/vm/object.cc

@@ -3989,6 +3989,7 @@ FunctionPtr Class::CreateInvocationDispatcher(
     const String& target_name,
     const Array& args_desc,
     UntaggedFunction::Kind kind) const {
+  ASSERT(target_name.ptr() != Symbols::DynamicImplicitCall().ptr());
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   FunctionType& signature = FunctionType::Handle(zone, FunctionType::New());
@@ -4329,12 +4330,22 @@ bool Function::IsDynamicInvocationForwarderName(StringPtr name) {
 }
 
 StringPtr Function::DemangleDynamicInvocationForwarderName(const String& name) {
+  if (name.ptr() == Symbols::DynamicImplicitCall().ptr()) {
+    return Symbols::call().ptr();
+  }
   const intptr_t kDynamicPrefixLength = 4;  // "dyn:"
   ASSERT(Symbols::DynamicPrefix().Length() == kDynamicPrefixLength);
   return Symbols::New(Thread::Current(), name, kDynamicPrefixLength,
                       name.Length() - kDynamicPrefixLength);
 }
 
+const String& Function::DropImplicitCallPrefix(const String& name) {
+  if (name.ptr() == Symbols::DynamicImplicitCall().ptr()) {
+    return Symbols::DynamicCall();
+  }
+  return name;
+}
+
 StringPtr Function::CreateDynamicInvocationForwarderName(const String& name) {
   return Symbols::FromConcat(Thread::Current(), Symbols::DynamicPrefix(), name);
 }
@@ -4395,6 +4406,7 @@ FunctionPtr Function::CreateDynamicInvocationForwarder(
 FunctionPtr Function::GetDynamicInvocationForwarder(
     const String& mangled_name) const {
   ASSERT(IsDynamicInvocationForwarderName(mangled_name));
+  ASSERT(mangled_name.ptr() != Symbols::DynamicImplicitCall().ptr());
   auto thread = Thread::Current();
   auto zone = thread->zone();
   const Class& owner = Class::Handle(zone, Owner());
@@ -10806,12 +10818,6 @@ bool Function::IsClosureCallDispatcher() const {
   return name() == Symbols::call().ptr();
 }
 
-bool Function::IsClosureCallGetter() const {
-  if (!IsGetterFunction()) return false;
-  if (!Class::IsClosureClass(Owner())) return false;
-  return name() == Symbols::GetCall().ptr();
-}
-
 FunctionPtr Function::ImplicitClosureFunction() const {
   // Return the existing implicit closure function if any.
   if (implicit_closure_function() != Function::null()) {

runtime/vm/object.h

@@ -3343,10 +3343,6 @@ class Function : public Object {
   // Function interface for closures.
   bool IsClosureCallDispatcher() const;
 
-  // Returns true if this function is _Closure.get:call, which returns the
-  // closure object for invocation.
-  bool IsClosureCallGetter() const;
-
   bool IsDynamicInvocationForwarder() const {
     return kind() == UntaggedFunction::kDynamicInvocationForwarder;
   }
@@ -4063,6 +4059,7 @@ class Function : public Object {
   static bool IsDynamicInvocationForwarderName(StringPtr name);
 
   static StringPtr DemangleDynamicInvocationForwarderName(const String& name);
+  static const String& DropImplicitCallPrefix(const String& name);
 
   static StringPtr CreateDynamicInvocationForwarderName(const String& name);
 

runtime/vm/resolver.cc

@@ -40,6 +40,8 @@ static FunctionPtr ResolveDynamicAnyArgsWithCustomLookup(
                 zone,
                 Function::DemangleDynamicInvocationForwarderName(function_name))
           : &function_name;
+  const String& dispatcher_name =
+      Function::DropImplicitCallPrefix(function_name);
 
   const bool is_getter = Field::IsGetterName(*demangled_name);
   const String* const method_name_to_extract =
@@ -53,7 +55,7 @@ static FunctionPtr ResolveDynamicAnyArgsWithCustomLookup(
     if (is_dyn_call) {
       // If a dyn:* forwarder already exists, return it.
       function = cls.GetInvocationDispatcher(
-          function_name, Array::null_array(),
+          dispatcher_name, Array::null_array(),
           UntaggedFunction::kDynamicInvocationForwarder,
           /*create_if_absent=*/false);
       if (!function.IsNull()) return function.ptr();
@@ -67,7 +69,7 @@ static FunctionPtr ResolveDynamicAnyArgsWithCustomLookup(
 #if !defined(DART_PRECOMPILED_RUNTIME)
     if (allow_add && is_dyn_call && !function.IsNull()) {
       // In JIT mode, lazily create a dyn:* forwarder if one is required.
-      function = function.GetDynamicInvocationForwarder(function_name);
+      function = function.GetDynamicInvocationForwarder(dispatcher_name);
     }
 #endif
     if (!function.IsNull()) return function.ptr();

runtime/vm/runtime_entry.cc

@@ -1700,9 +1700,10 @@ static bool ResolveCallThroughGetter(const Class& receiver_class,
   // We do this on the target_name, _not_ on the demangled name, so that
   // FlowGraphBuilder::BuildGraphOfInvokeFieldDispatcher can detect dynamic
   // calls from the dyn: tag on the name of the dispatcher.
+  const String& dispatcher_name = Function::DropImplicitCallPrefix(target_name);
   const Function& target_function =
       Function::Handle(receiver_class.GetInvocationDispatcher(
-          target_name, arguments_descriptor,
+          dispatcher_name, arguments_descriptor,
           UntaggedFunction::kInvokeFieldDispatcher, create_if_absent));
   ASSERT(!create_if_absent || !target_function.IsNull());
   if (FLAG_trace_ic) {
@@ -1728,13 +1729,15 @@ FunctionPtr InlineCacheMissHelper(const Class& receiver_class,
         Function::DemangleDynamicInvocationForwarderName(target_name));
   }
   const bool is_getter = Field::IsGetterName(*demangled);
+  const bool is_dyn_implicit_call =
+      target_name.ptr() == Symbols::DynamicImplicitCall().ptr();
   Function& result = Function::Handle();
 #if defined(DART_PRECOMPILED_RUNTIME)
   const bool create_if_absent = false;
 #else
   const bool create_if_absent = true;
 #endif
-  if (is_getter ||
+  if (is_getter || (is_dyn_implicit_call && !receiver_class.IsClosureClass()) ||
       !ResolveCallThroughGetter(receiver_class, target_name, *demangled,
                                 args_descriptor, &result)) {
     ArgumentsDescriptor desc(args_descriptor);
@@ -2915,6 +2918,8 @@ static ObjectPtr InvokeCallThroughGetterOrNoSuchMethod(
     const Array& orig_arguments_desc) {
   const bool is_dynamic_call =
       Function::IsDynamicInvocationForwarderName(target_name);
+  const bool is_dyn_implicit_call =
+      target_name.ptr() == Symbols::DynamicImplicitCall().ptr();
   String& demangled_target_name = String::Handle(zone, target_name.ptr());
   if (is_dynamic_call) {
     demangled_target_name =
@@ -2976,7 +2981,7 @@ static ObjectPtr InvokeCallThroughGetterOrNoSuchMethod(
     }
 
     // Dynamic call sites have to use the dynamic getter as well (if it was
-    // created).
+    // created), unless its a dynamic implicit call to 'call'.
     const auto& getter_name =
         String::Handle(zone, Field::GetterName(demangled_target_name));
     const auto& dyn_getter_name = String::Handle(
@@ -3003,31 +3008,34 @@ static ObjectPtr InvokeCallThroughGetterOrNoSuchMethod(
         }
       }
 
-      // If there is a getter we need to call-through-getter.
-      if (is_dynamic_call) {
-        function = Resolver::ResolveDynamicFunction(zone, cls, dyn_getter_name);
-      }
-      if (function.IsNull()) {
-        function = Resolver::ResolveDynamicFunction(zone, cls, 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(
-            zone, DartEntry::InvokeFunction(function, getter_arguments));
-        if (getter_result.IsError()) {
-          return getter_result.ptr();
+      if (!is_dyn_implicit_call) {
+        // If there is a getter we need to call-through-getter.
+        if (is_dynamic_call) {
+          function =
+              Resolver::ResolveDynamicFunction(zone, cls, dyn_getter_name);
         }
-        ASSERT(getter_result.IsNull() || getter_result.IsInstance());
+        if (function.IsNull()) {
+          function = Resolver::ResolveDynamicFunction(zone, cls, 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(
+              zone, DartEntry::InvokeFunction(function, getter_arguments));
+          if (getter_result.IsError()) {
+            return getter_result.ptr();
+          }
+          ASSERT(getter_result.IsNull() || getter_result.IsInstance());
 
-        orig_arguments.SetAt(args_desc.FirstArgIndex(), getter_result);
-        return DartEntry::InvokeClosure(thread, orig_arguments,
-                                        orig_arguments_desc);
+          orig_arguments.SetAt(args_desc.FirstArgIndex(), getter_result);
+          return DartEntry::InvokeClosure(thread, orig_arguments,
+                                          orig_arguments_desc);
+        }
       }
       cls = cls.SuperClass();
     }
 
-    if (receiver.IsRecord()) {
+    if (receiver.IsRecord() && !is_dyn_implicit_call) {
       const Record& record = Record::Cast(receiver);
       const intptr_t field_index =
           record.GetFieldIndexByName(thread, demangled_target_name);

runtime/vm/symbols.h

@@ -94,6 +94,7 @@ class ObjectPointerVisitor;
   V(DynamicCallCurrentParamIndexVar, ":dyn_call_current_param_index")          \
   V(DynamicCallCurrentTypeParamVar, ":dyn_call_current_type_param")            \
   V(DynamicCallFunctionTypeArgsVar, ":dyn_call_function_type_args")            \
+  V(DynamicImplicitCall, "dyn:implicit:call")                                  \
   V(DynamicPrefix, "dyn:")                                                     \
   V(EntryPointsTemp, ":entry_points_temp")                                     \
   V(EqualOperator, "==")                                                       \