Evaluates arguments before throwing a NoSuchMethodError in constructor

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 "lib/invocation_mirror.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 7188 matching lines @@
     ASSERT(is_malbounded);
   }
   arguments->Add(new LiteralNode(type_pos, String::ZoneHandle(
       Symbols::New(error.ToErrorCString()))));
   return MakeStaticCall(Symbols::TypeError(),
                         PrivateCoreLibName(Symbols::ThrowNew()),
                         arguments);
 }
 
 
-// TODO(regis): Providing the argument values is not always feasible, since
-// evaluating them could throw an error.
-// Should NoSuchMethodError reflect the argument count and names instead of
-// argument values? Or should the spec specify a different evaluation order?
 AstNode* Parser::ThrowNoSuchMethodError(intptr_t call_pos,
                                         const Class& cls,
                                         const String& function_name,
+                                        ArgumentListNode* actuals,

[regis, 2013/08/28 21:10:54]

function_arguments

[zra, 2013/08/28 22:47:00]

Done.

                                         InvocationMirror::Call im_call,
                                         InvocationMirror::Type im_type) {
   ArgumentListNode* arguments = new ArgumentListNode(call_pos);
   // Object receiver.
   // TODO(regis): For now, we pass a class literal of the unresolved
   // method's owner, but this is not specified and will probably change.
   Type& type = Type::ZoneHandle(
       Type::New(cls, TypeArguments::Handle(), call_pos, Heap::kOld));
   type ^= ClassFinalizer::FinalizeType(
       current_class(), type, ClassFinalizer::kCanonicalize);
   arguments->Add(new LiteralNode(call_pos, type));
   // String memberName.
   arguments->Add(new LiteralNode(
       call_pos, String::ZoneHandle(Symbols::New(function_name))));
   // Smi invocation_type.
   if (cls.IsTopLevel()) {
     ASSERT(im_call == InvocationMirror::kStatic ||
            im_call == InvocationMirror::kTopLevel);
     im_call = InvocationMirror::kTopLevel;
   }
   arguments->Add(new LiteralNode(call_pos, Smi::ZoneHandle(
       Smi::New(InvocationMirror::EncodeType(im_call, im_type)))));
   // List arguments.
-  arguments->Add(new LiteralNode(call_pos, Array::ZoneHandle()));
+  if (actuals == NULL) {
+    arguments->Add(new LiteralNode(call_pos, Array::ZoneHandle()));
+  } else {
+    ArrayNode* array = new ArrayNode(
+        call_pos, Type::ZoneHandle(Type::ArrayType()), actuals->nodes());
+    arguments->Add(array);
+  }
   // List argumentNames.
-  arguments->Add(new LiteralNode(call_pos, Array::ZoneHandle()));
+  if (actuals == NULL) {
+    arguments->Add(new LiteralNode(call_pos, Array::ZoneHandle()));
+  } else {
+    arguments->Add(new LiteralNode(call_pos, actuals->names()));
+  }
   // List existingArgumentNames.
   // Check if there exists a function with the same name.
   Function& function =
      Function::Handle(cls.LookupStaticFunction(function_name));
   if (function.IsNull()) {
-    // TODO(srdjan): Store argument values into the argument list.
     arguments->Add(new LiteralNode(call_pos, Array::ZoneHandle()));
   } else {
     const int total_num_parameters = function.NumParameters();
     Array& array =
         Array::ZoneHandle(Array::New(total_num_parameters, Heap::kOld));
     // Skip receiver.
     for (int i = 0; i < total_num_parameters; i++) {
       array.SetAt(i, String::Handle(function.ParameterNameAt(i)));
     }
     arguments->Add(new LiteralNode(call_pos, array));
@@ skipping 483 matching lines @@
   TRACE_PARSER("ParseActualParameters");
   ASSERT(CurrentToken() == Token::kLPAREN);
   const bool saved_mode = SetAllowFunctionLiterals(true);
   ArgumentListNode* arguments;
   if (implicit_arguments == NULL) {
     arguments = new ArgumentListNode(TokenPos());
   } else {
     arguments = implicit_arguments;
   }
   const GrowableObjectArray& names =
-      GrowableObjectArray::Handle(GrowableObjectArray::New());
+      GrowableObjectArray::Handle(GrowableObjectArray::New(Heap::kOld));
   bool named_argument_seen = false;
   if (LookaheadToken(1) != Token::kRPAREN) {
     String& arg_name = String::Handle();
     do {
       ASSERT((CurrentToken() == Token::kLPAREN) ||
              (CurrentToken() == Token::kCOMMA));
       ConsumeToken();
       if (IsIdentifier() && (LookaheadToken(1) == Token::kCOLON)) {
         named_argument_seen = true;
         // The canonicalization of the arguments descriptor array built in
@@ skipping 68 matching lines @@
       }
     } else {
       EnsureSavedCurrentContext();
       closure = GenerateStaticFieldLookup(field, call_pos);
       return new ClosureCallNode(call_pos, closure, arguments);
     }
     // Could not resolve static method: throw a NoSuchMethodError.
     return ThrowNoSuchMethodError(ident_pos,
                                   cls,
                                   func_name,
+                                  arguments,
                                   InvocationMirror::kStatic,
                                   InvocationMirror::kMethod);
   } else if (cls.IsTopLevel() &&
       (cls.library() == Library::CoreLibrary()) &&
       (func.name() == Symbols::Identical().raw())) {
     // This is the predefined toplevel function identical(a,b). Create
     // a comparison node instead.
     ASSERT(num_arguments == 2);
     return new ComparisonNode(ident_pos,
                               Token::kEQ_STRICT,
@@ skipping 1902 matching lines @@
             call_pos,
             "class '%s' has no constructor or factory named '%s'",
             String::Handle(type_class.Name()).ToCString(),
             external_constructor_name.ToCString());
         const Error& error = Error::Handle(type.malformed_error());
         ErrorMsg(error);
       }
       return ThrowNoSuchMethodError(call_pos,
                                     type_class,
                                     external_constructor_name,
+                                    arguments,
                                     InvocationMirror::kConstructor,
                                     InvocationMirror::kMethod);
     } else if (constructor.IsRedirectingFactory()) {
       ClassFinalizer::ResolveRedirectingFactory(type_class, constructor);
       Type& redirect_type = Type::Handle(constructor.RedirectionType());
       if (!redirect_type.IsMalformed() && !redirect_type.IsInstantiated()) {
         // The type arguments of the redirection type are instantiated from the
         // type arguments of the parsed type of the 'new' or 'const' expression.
         Error& malformed_error = Error::Handle();
         redirect_type ^= redirect_type.InstantiateFrom(type_arguments,
@@ skipping 47 matching lines @@
       ErrorMsg(call_pos,
                "invalid arguments passed to constructor '%s' "
                "for class '%s': %s",
                external_constructor_name.ToCString(),
                String::Handle(type_class.Name()).ToCString(),
                error_message.ToCString());
     }
     return ThrowNoSuchMethodError(call_pos,
                                   type_class,
                                   external_constructor_name,
+                                  arguments,
                                   InvocationMirror::kConstructor,
                                   InvocationMirror::kMethod);
   }
 
   // Return a throw in case of a malformed type or report a compile-time error
   // if the constructor is const.
   if (type.IsMalformed()) {
     if (is_const) {
       const Error& error = Error::Handle(type.malformed_error());
       ErrorMsg(error);
@@ skipping 633 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart