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

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.");
 
 
 // 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,
-                                      int num_arguments,
-                                      int num_named_arguments) {
+                                      const ArgumentsDescriptor& args_desc) {
   // Figure out type of receiver first.
   Class& cls = Class::Handle();
   cls = receiver.clazz();
   // For lookups treat null as an instance of class Object.
   if (cls.IsNullClass()) {
     cls = Isolate::Current()->object_store()->object_class();
   }
   ASSERT(!cls.IsNull());
 
-  return ResolveDynamicForReceiverClass(
-      cls, function_name, num_arguments, num_named_arguments);
+  return ResolveDynamicForReceiverClass(cls, function_name, args_desc);
 }
 
 
 RawFunction* Resolver::ResolveDynamicForReceiverClass(
     const Class& receiver_class,
     const String& function_name,
-    int num_arguments,
-    int num_named_arguments) {
+    const ArgumentsDescriptor& args_desc) {
 
   Function& function =
       Function::Handle(ResolveDynamicAnyArgs(receiver_class, function_name));
 
   if (function.IsNull() ||
-      !function.AreValidArgumentCounts(num_arguments,
-                                       num_named_arguments,
-                                       NULL)) {
+      !function.AreValidArguments(args_desc, NULL)) {
     // Return a null function to signal to the upper levels to dispatch to
     // "noSuchMethod" function.
     if (FLAG_trace_resolving) {
       String& error_message = String::Handle(String::New("function not found"));
       if (!function.IsNull()) {
         // Obtain more detailed error message.
-        function.AreValidArgumentCounts(num_arguments,
-                                        num_named_arguments,
-                                        &error_message);
+        function.AreValidArguments(args_desc, &error_message);
       }
       OS::Print("ResolveDynamic error '%s': %s.\n",
                 function_name.ToCString(),
                 error_message.ToCString());
     }
     return Function::null();
   }
   return function.raw();
 }
 
@@ skipping 73 matching lines @@
 
     cls = cls.SuperClass();
   }
   return function.raw();
 }
 
 
 RawFunction* Resolver::ResolveStatic(const Library& library,
                                      const String& class_name,
                                      const String& function_name,
-                                     int num_arguments,
+                                     intptr_t num_arguments,
                                      const Array& argument_names,
                                      StaticResolveType resolve_type) {
   ASSERT(!library.IsNull());
   Function& function = Function::Handle();
   if (class_name.IsNull() || (class_name.Length() == 0)) {
     // Check if we are referring to a top level function.
     const Object& object = Object::Handle(library.LookupObject(function_name));
     if (!object.IsNull() && object.IsFunction()) {
       function ^= object.raw();
       if (!function.AreValidArguments(num_arguments, argument_names, NULL)) {
@@ skipping 55 matching lines @@
       if (super_class.IsNull()) break;
     }
   }
   return function.raw();
 }
 
 
 
 RawFunction* Resolver::ResolveStatic(const Class&  cls,
                                      const String& function_name,
-                                     int num_arguments,
+                                     intptr_t num_arguments,
                                      const Array& argument_names,
                                      StaticResolveType resolve_type) {
   const Function& function = Function::Handle(
       ResolveStaticByName(cls, function_name, resolve_type));
   if (function.IsNull() ||
       !function.AreValidArguments(num_arguments, argument_names, NULL)) {
     // Return a null function to signal to the upper levels to throw a
     // resolution error or maybe throw the error right here.
     if (FLAG_trace_resolving) {
       String& error_message = String::Handle(String::New("function not found"));
       if (!function.IsNull()) {
         // Obtain more detailed error message.
         function.AreValidArguments(num_arguments,
                                    argument_names,
                                    &error_message);
       }
       OS::Print("ResolveStatic error '%s': %s.\n",
                 function_name.ToCString(),
                 error_message.ToCString());
     }
     return Function::null();
   }
   return function.raw();
 }
 
 }  // namespace dart