Provide better error message when passing wrong number of arguments.

runtime/vm/parser.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/parser.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 1460 matching lines @@
         ResolveDynamicFunction(super_class, field_name));
     if (super_function.IsNull()) {
       ErrorMsg(field_pos, "field or getter '%s' not found in superclass",
                field_name.ToCString());
     }
     return CreateImplicitClosureNode(super_function,
                                      field_pos,
                                      implicit_argument);
   }
   // All dynamic getters take one argument and no named arguments.
-  ASSERT(super_getter.AreValidArgumentCounts(1, 0));
+  ASSERT(super_getter.AreValidArgumentCounts(1, 0, NULL));
   ArgumentListNode* getter_arguments = new ArgumentListNode(field_pos);
   getter_arguments->Add(implicit_argument);
   AstNode* super_field =
       new StaticCallNode(field_pos, super_getter, getter_arguments);
 
   if (Token::IsAssignmentOperator(CurrentToken())) {
     const String& setter_name =
         String::ZoneHandle(Field::SetterName(field_name));
     const Function& super_setter = Function::ZoneHandle(
         ResolveDynamicFunction(super_class, setter_name));
     if (super_setter.IsNull()) {
       ErrorMsg(field_pos,
                "field '%s' not assignable in superclass",
                field_name.ToCString());
     }
     // All dynamic setters take two arguments and no named arguments.
-    ASSERT(super_setter.AreValidArgumentCounts(2, 0));
+    ASSERT(super_setter.AreValidArgumentCounts(2, 0, NULL));
 
     Token::Kind assignment_op = CurrentToken();
     ConsumeToken();
     AstNode* value = ParseExpr(kAllowConst);
     value = ExpandAssignableOp(field_pos, assignment_op, super_field, value);
 
     ArgumentListNode* setter_arguments = new ArgumentListNode(field_pos);
     setter_arguments->Add(implicit_argument);
     setter_arguments->Add(value);
     super_field = new StaticCallNode(field_pos, super_setter, setter_arguments);
@@ skipping 19 matching lines @@
   // Implicit 'this' parameter is the first argument.
   AstNode* implicit_argument = new LoadLocalNode(supercall_pos, *receiver);
   arguments->Add(implicit_argument);
   // Implicit construction phase parameter is second argument.
   AstNode* phase_parameter =
       new LiteralNode(supercall_pos,
                       Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll)));
   arguments->Add(phase_parameter);
   const Function& super_ctor = Function::ZoneHandle(
       super_class.LookupConstructor(ctor_name));
-  if (super_ctor.IsNull() ||
-      !super_ctor.AreValidArguments(arguments->length(),
-                                    arguments->names())) {
+  if (super_ctor.IsNull()) {
+      ErrorMsg(supercall_pos,
+               "unresolved implicit call to super constructor '%s()'",
+               String::Handle(super_class.Name()).ToCString());
+  }
+  String& error_message = String::Handle();
+  if (!super_ctor.AreValidArguments(arguments->length(),
+                                    arguments->names(),
+                                    &error_message)) {
     ErrorMsg(supercall_pos,
-             "unresolved implicit call to super constructor '%s()'",
-             String::Handle(super_class.Name()).ToCString());
+             "invalid arguments passed to super constructor '%s()': %s",
+             String::Handle(super_class.Name()).ToCString(),
+             error_message.ToCString());
   }
   CheckFunctionIsCallable(supercall_pos, super_ctor);
   current_block_->statements->Add(
       new StaticCallNode(supercall_pos, super_ctor, arguments));
 }
 
 
 AstNode* Parser::ParseSuperInitializer(const Class& cls,
                                        LocalVariable* receiver) {
   TRACE_PARSER("ParseSuperInitializer");
@@ skipping 27 matching lines @@
                       Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll)));
   arguments->Add(phase_parameter);
   // 'this' parameter must not be accessible to the other super call arguments.
   receiver->set_invisible(true);
   ParseActualParameters(arguments, kAllowConst);
   receiver->set_invisible(false);
 
   // Resolve the constructor.
   const Function& super_ctor = Function::ZoneHandle(
       super_class.LookupConstructor(ctor_name));
-  if (super_ctor.IsNull() ||
-      !super_ctor.AreValidArguments(arguments->length(),
-                                    arguments->names())) {
+  if (super_ctor.IsNull()) {
     ErrorMsg(supercall_pos,
              "super class constructor '%s' not found",
              ctor_name.ToCString());
   }
+  String& error_message = String::Handle();
+  if (!super_ctor.AreValidArguments(arguments->length(),
+                                    arguments->names(),
+                                    &error_message)) {
+    ErrorMsg(supercall_pos,
+             "invalid arguments passed to super class constructor '%s': %s",
+             ctor_name.ToCString(),
+             error_message.ToCString());
+  }
   CheckFunctionIsCallable(supercall_pos, super_ctor);
   return new StaticCallNode(supercall_pos, super_ctor, arguments);
 }
 
 
 AstNode* Parser::ParseInitializer(const Class& cls, LocalVariable* receiver) {
   TRACE_PARSER("ParseInitializer");
   const intptr_t field_pos = TokenPos();
   if (CurrentToken() == Token::kTHIS) {
     ConsumeToken();
@@ skipping 147 matching lines @@
   // Construction phase parameter is second argument.
   LocalVariable* phase_param = LookupPhaseParameter();
   ASSERT(phase_param != NULL);
   AstNode* phase_argument = new LoadLocalNode(call_pos, *phase_param);
   arguments->Add(phase_argument);
   ParseActualParameters(arguments, kAllowConst);
 
   // Resolve the constructor.
   const Function& redirect_ctor = Function::ZoneHandle(
       cls.LookupConstructor(ctor_name));
-  if (redirect_ctor.IsNull() ||
-      !redirect_ctor.AreValidArguments(arguments->length(),
-                                       arguments->names())) {
-    ErrorMsg(call_pos, "constructor '%s' not found",
-             ctor_name.ToCString());
+  if (redirect_ctor.IsNull()) {
+    ErrorMsg(call_pos, "constructor '%s' not found", ctor_name.ToCString());
+  }
+  String& error_message = String::Handle();
+  if (!redirect_ctor.AreValidArguments(arguments->length(),
+                                       arguments->names(),
+                                       &error_message)) {
+    ErrorMsg(call_pos,
+             "invalid arguments passed to constructor '%s': %s",
+             ctor_name.ToCString(),
+             error_message.ToCString());
   }
   CheckFunctionIsCallable(call_pos, redirect_ctor);
   current_block_->statements->Add(
       new StaticCallNode(call_pos, redirect_ctor, arguments));
 }
 
 
 SequenceNode* Parser::MakeImplicitConstructor(const Function& func) {
   ASSERT(func.IsConstructor());
   const intptr_t ctor_pos = TokenPos();
@@ skipping 240 matching lines @@
         if (arg->IsLoadLocalNode()) {
           const LocalVariable& temp = arg->AsLoadLocalNode()->local();
           super_call_args->Add(new LoadLocalNode(TokenPos(), temp));
         } else if (arg->IsStoreLocalNode()) {
           const LocalVariable& temp = arg->AsStoreLocalNode()->local();
           super_call_args->Add(new LoadLocalNode(TokenPos(), temp));
         }
       }
     }
     ASSERT(super_ctor.AreValidArguments(super_call_args->length(),
-                                        super_call_args->names()));
+                                        super_call_args->names(),
+                                        NULL));
     current_block_->statements->Add(
         new StaticCallNode(TokenPos(), super_ctor, super_call_args));
   }
 
   if (CurrentToken() == Token::kLBRACE) {
     ConsumeToken();
     ParseStatementSequence();
     ExpectToken(Token::kRBRACE);
   } else if (CurrentToken() == Token::kARROW) {
     ErrorMsg("constructors may not return a value");
@@ skipping 5863 matching lines @@
     const String& external_constructor_name =
         (named_constructor ? constructor_name : type_class_name);
     Function& constructor = Function::ZoneHandle(
         type_class.LookupConstructor(constructor_name));
     if (constructor.IsNull()) {
       ErrorMsg(type_pos,
                "interface '%s' has no constructor named '%s'",
                type_class_name.ToCString(),
                external_constructor_name.ToCString());
     }
-    if (!constructor.AreValidArguments(arguments_length, arguments->names())) {
+    String& error_message = String::Handle();
+    if (!constructor.AreValidArguments(arguments_length,
+                                       arguments->names(),
+                                       &error_message)) {
       ErrorMsg(call_pos,
                "invalid arguments passed to constructor '%s' "
-               "for interface '%s'",
+               "for interface '%s': %s",
                external_constructor_name.ToCString(),
-               type_class_name.ToCString());
+               type_class_name.ToCString(),
+               error_message.ToCString());
     }
     if (!type_class.HasFactoryClass()) {
       ErrorMsg(type_pos,
                "cannot allocate interface '%s' without factory class",
                type_class_name.ToCString());
     }
     if (!type_class.HasResolvedFactoryClass()) {
       // This error can occur only with bootstrap classes.
       const UnresolvedClass& unresolved =
           UnresolvedClass::Handle(type_class.UnresolvedFactoryClass());
@@ skipping 29 matching lines @@
     arguments_length -= 1;
   }
   if (constructor.IsNull()) {
     const String& external_constructor_name =
         (named_constructor ? constructor_name : constructor_class_name);
     ErrorMsg(type_pos,
              "class '%s' has no constructor or factory named '%s'",
              String::Handle(constructor_class.Name()).ToCString(),
              external_constructor_name.ToCString());
   }
-  if (!constructor.AreValidArguments(arguments_length, arguments->names())) {
+  String& error_message = String::Handle();
+  if (!constructor.AreValidArguments(arguments_length,
+                                     arguments->names(),
+                                     &error_message)) {
     const String& external_constructor_name =
         (named_constructor ? constructor_name : constructor_class_name);
     ErrorMsg(call_pos,
-             "invalid arguments passed to constructor '%s' for class '%s'",
+             "invalid arguments passed to constructor '%s' for class '%s': %s",
              external_constructor_name.ToCString(),
-             String::Handle(constructor_class.Name()).ToCString());
+             String::Handle(constructor_class.Name()).ToCString(),
+             error_message.ToCString());
   }
 
   // Now that the constructor to be called is identified, finalize the type
   // argument vector to be passed.
   // The type argument vector of the parsed type was finalized in ParseType.
   // If the constructor class was changed from the interface class to the
   // factory class, we need to finalize the type argument vector again, because
   // it may be longer due to the factory class extending a class, or/and because
   // the bounds on the factory class may be tighter than on the interface.
   if (constructor_class.raw() != type_class.raw()) {
@@ skipping 638 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart