Change resolving of instance methods to check early for name mismatch.

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/bigint_operations.h"
 #include "vm/code_patcher.h"
@@ skipping 783 matching lines @@
 }
 
 
 // Resolves and compiles the target function of an instance call, updates
 // function cache of the receiver's class and returns the compiled code or null.
 // Only the number of named arguments is checked, but not the actual names.
 RawCode* ResolveCompileInstanceCallTarget(const Instance& receiver,
                                           const ICData& ic_data) {
   ArgumentsDescriptor
       arguments_descriptor(Array::Handle(ic_data.arguments_descriptor()));
-  intptr_t num_arguments = arguments_descriptor.Count();
-  int num_named_arguments = arguments_descriptor.NamedCount();
   String& function_name = String::Handle(ic_data.target_name());
   ASSERT(function_name.IsSymbol());
 
   Function& function = Function::Handle();
   function = Resolver::ResolveDynamic(receiver,
                                       function_name,
-                                      num_arguments,
-                                      num_named_arguments);
+                                      arguments_descriptor);
   if (function.IsNull()) {
     return Code::null();
   } else {
     if (!function.HasCode()) {
       const Error& error = Error::Handle(Compiler::CompileFunction(function));
       if (!error.IsNull()) {
         Exceptions::PropagateError(error);
       }
     }
     return function.CurrentCode();
@@ skipping 232 matching lines @@
   // For lookups treat null as an instance of class Object.
   if (is_null) {
     cls = isolate->object_store()->object_class();
   }
   ASSERT(!cls.IsNull());
   if (FLAG_trace_ic || FLAG_trace_ic_miss_in_optimized) {
     OS::PrintErr("Megamorphic IC miss, class=%s, function=%s\n",
                  cls.ToCString(), name.ToCString());
   }
 
-  intptr_t arg_count =
-      Smi::Cast(Object::Handle(descriptor.At(0))).Value();
-  intptr_t named_arg_count =
-      arg_count - Smi::Cast(Object::Handle(descriptor.At(1))).Value();
+  ArgumentsDescriptor args_desc(descriptor);
   const Function& target = Function::Handle(
       Resolver::ResolveDynamicForReceiverClass(cls,
                                                name,
-                                               arg_count,
-                                               named_arg_count));
+                                               args_desc));
 
   Instructions& instructions = Instructions::Handle();
   if (!target.IsNull()) {
     if (!target.HasCode()) {
       const Error& error = Error::Handle(Compiler::CompileFunction(target));
       if (!error.IsNull()) {
         Exceptions::PropagateError(error);
       }
     }
     ASSERT(target.HasCode());
@@ skipping 20 matching lines @@
   ASSERT(arguments.ArgCount() ==
       kUpdateICDataTwoArgsRuntimeEntry.argument_count());
   const Instance& receiver = Instance::CheckedHandle(arguments.ArgAt(0));
   const Instance& arg1 = Instance::CheckedHandle(arguments.ArgAt(1));
   const String& target_name = String::CheckedHandle(arguments.ArgAt(2));
   const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(3));
   GrowableArray<const Instance*> args(2);
   args.Add(&receiver);
   args.Add(&arg1);
   const intptr_t kNumArguments = 2;
-  const intptr_t kNumNamedArguments = 0;
-  Function& target_function = Function::Handle();
-  target_function = Resolver::ResolveDynamic(receiver,
-                                             target_name,
-                                             kNumArguments,
-                                             kNumNamedArguments);
+    ArgumentsDescriptor args_desc(
+        Array::Handle(ArgumentsDescriptor::New(kNumArguments)));
+  const Function& target_function = Function::Handle(
+      Resolver::ResolveDynamic(receiver,
+                               target_name,
+                               args_desc));
   ASSERT(!target_function.IsNull());
   GrowableArray<intptr_t> class_ids(kNumArguments);
   ASSERT(ic_data.num_args_tested() == kNumArguments);
   class_ids.Add(receiver.GetClassId());
   class_ids.Add(arg1.GetClassId());
   ic_data.AddCheck(class_ids, target_function);
 }
 
 
 // Invoke appropriate noSuchMethod function.
@@ skipping 51 matching lines @@
 static bool ResolveCallThroughGetter(const Instance& receiver,
                                      const Class& receiver_class,
                                      const String& target_name,
                                      const Array& arguments_descriptor,
                                      const Array& arguments,
                                      const ICData& ic_data,
                                      Object* result) {
   // 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;
-  const int kNumNamedArguments = 0;
+  ArgumentsDescriptor args_desc(
+      Array::Handle(ArgumentsDescriptor::New(kNumArguments)));
   const Function& getter = Function::Handle(
       Resolver::ResolveDynamicForReceiverClass(receiver_class,
                                                getter_name,
-                                               kNumArguments,
-                                               kNumNamedArguments));
+                                               args_desc));
   if (getter.IsNull() || getter.IsMethodExtractor()) {
     return false;
   }
 
   const Function& target_function =
       Function::Handle(receiver_class.GetInvocationDispatcher(
           target_name,
           arguments_descriptor,
           RawFunction::kInvokeFieldDispatcher));
   // Update IC data.
@@ skipping 683 matching lines @@
 //   Arg1: Value that is being stored.
 DEFINE_RUNTIME_ENTRY(UpdateFieldCid, 2) {
   ASSERT(arguments.ArgCount() == kUpdateFieldCidRuntimeEntry.argument_count());
   const Field& field = Field::CheckedHandle(arguments.ArgAt(0));
   const Object& value = Object::Handle(arguments.ArgAt(1));
 
   field.UpdateCid(value.GetClassId());
 }
 
 }  // namespace dart