Provide better error message when passing wrong number of arguments.

runtime/vm/object.cc

 // Copyright (c) 2012, 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/object.h"
 
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 3672 matching lines @@
 void Function::set_is_native(bool value) const {
   raw_ptr()->is_native_ = value;
 }
 
 
 intptr_t Function::NumberOfParameters() const {
   return num_fixed_parameters() + num_optional_parameters();
 }
 
 
+intptr_t Function::NumberOfImplicitParameters() const {
+  if (kind() == RawFunction::kConstructor) {
+    if (is_static()) {
+      ASSERT(IsFactory());
+      return 1;  // Type arguments.
+    } else {
+      ASSERT(IsConstructor());
+      return 2;  // Instance, phase.
+    }
+  }
+  if (!is_static()) {
+    return 1;  // Receiver.
+  }
+  return 0;  // No implicit parameters.
+}
+
+
 bool Function::AreValidArgumentCounts(int num_arguments,
-                                      int num_named_arguments) const {
+                                      int num_named_arguments,
+                                      char* message_buffer,
+                                      intptr_t message_buffer_size) const {
   if (num_arguments > NumberOfParameters()) {
+    if (message_buffer_size > 0) {

[srdjan, 2012/07/12 00:06:37]

|| message_buffer == NULL

[regis, 2012/07/12 17:37:36]

OS::SNPrint will work with a NULL buffer, as long as size is 0. So, an
ASSERT(message_buffer != NULL) if the size > 0 would prevent bad callers.

Since I will now use a String, this is not relevant anymore.

+      // Hide implicit parameters to the user.
+      const intptr_t num_hidden_params = NumberOfImplicitParameters();
+      OS::SNPrint(message_buffer,
+                  message_buffer_size,
+                  "%d passed, %s%d expected",
+                  num_arguments - num_hidden_params,
+                  num_optional_parameters() > 0 ? "at most " : "",
+                  NumberOfParameters() - num_hidden_params);
+    }
     return false;  // Too many arguments.
   }
   const int num_positional_args = num_arguments - num_named_arguments;
   if (num_positional_args < num_fixed_parameters()) {
+    if (message_buffer_size > 0) {

[srdjan, 2012/07/12 00:06:37]

ditto

[regis, 2012/07/12 17:37:36]

ditto

+      // Hide implicit parameters to the user.
+      const intptr_t num_hidden_params = NumberOfImplicitParameters();
+      OS::SNPrint(message_buffer,
+                  message_buffer_size,
+                  "%d %spassed, %d expected",
+                  num_positional_args - num_hidden_params,
+                  num_optional_parameters() > 0 ? "positional " : "",
+                  num_fixed_parameters() - num_hidden_params);
+    }
     return false;  // Too few arguments.
   }
   return true;
 }
 
 
-// TODO(regis): Return some sort of diagnosis information so that we
-// can improve the error messages generated by the parser.
 bool Function::AreValidArguments(int num_arguments,
-                                 const Array& argument_names) const {
+                                 const Array& argument_names,
+                                 char* message_buffer,
+                                 intptr_t message_buffer_size) const {
   const int num_named_arguments =
       argument_names.IsNull() ? 0 : argument_names.Length();
-  if (!AreValidArgumentCounts(num_arguments, num_named_arguments)) {
+  if (!AreValidArgumentCounts(num_arguments,
+                              num_named_arguments,
+                              message_buffer,
+                              message_buffer_size)) {
     return false;
   }
   // Verify that all argument names are valid parameter names.
   String& argument_name = String::Handle();
   String& parameter_name = String::Handle();
   for (int i = 0; i < num_named_arguments; i++) {
     argument_name ^= argument_names.At(i);
     ASSERT(argument_name.IsSymbol());
     bool found = false;
     const int num_positional_args = num_arguments - num_named_arguments;
     const int num_parameters = NumberOfParameters();
     for (int j = num_positional_args; !found && (j < num_parameters); j++) {
       parameter_name ^= ParameterNameAt(j);
       ASSERT(argument_name.IsSymbol());
       if (argument_name.Equals(parameter_name)) {
         found = true;
       }
     }
     if (!found) {
+      if (message_buffer_size > 0) {

[srdjan, 2012/07/12 00:06:37]

|| (message_buffer == NULL)

[regis, 2012/07/12 17:37:36]

ditto

+        OS::SNPrint(message_buffer,
+                    message_buffer_size,
+                    "no optional formal parameter named '%s'",
+                    argument_name.ToCString());
+      }
       return false;
     }
   }
   return true;
 }
 
 
 // Helper allocating a C string buffer in the zone, printing the fully qualified
 // name of a function in it, and replacing ':' by '_' to make sure the
 // constructed name is a valid C++ identifier for debugging purpose.
@@ skipping 6913 matching lines @@
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart