Change signature of noSuchMethod to take an InvocationMirror.

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 1295 matching lines @@
   String& name = String::Handle(class_name.raw());
   if (class_name.CharAt(0) == Scanner::kPrivateIdentifierStart) {
     // Private identifiers are mangled on a per script basis.
     name = String::Concat(name, String::Handle(core_lib.private_key()));
     name = Symbols::New(name);
   }
   return core_lib.LookupClass(name);
 }
 
 
+StaticCallNode* Parser::BuildInvocationMirrorAllocation(
+    intptr_t call_pos,
+    const String& function_name,
+    const ArgumentListNode& function_args) {
+  const intptr_t args_pos = function_args.token_pos();
+  // Build arguments to the call to the static
+  // InvocationMirror._allocateInvocationMirror method.
+  ArgumentListNode* arguments = new ArgumentListNode(args_pos);
+  // The first argument is the original function name.
+  arguments->Add(new LiteralNode(args_pos, function_name));
+  // The second argument is an array containing the original function arguments.
+  ArrayNode* args_array = new ArrayNode(
+      args_pos, Type::ZoneHandle(Type::ListInterface()));
+  for (intptr_t i = 1; i < function_args.length(); i++) {
+    args_array->AddElement(function_args.NodeAt(i));
+  }
+  arguments->Add(args_array);
+  // Lookup the static InvocationMirror._allocateInvocationMirror method.
+  const Class& mirror_class = Class::Handle(
+      LookupCoreClass(String::Handle(Symbols::InvocationMirror())));
+  ASSERT(!mirror_class.IsNull());
+  const String& allocation_function_name =
+      String::Handle(Symbols::AllocateInvocationMirror());
+  const Function& allocation_function = Function::ZoneHandle(
+      mirror_class.LookupStaticFunction(allocation_function_name));
+  ASSERT(!allocation_function.IsNull());
+  return new StaticCallNode(call_pos, allocation_function, arguments);
+}
+
+
 ArgumentListNode* Parser::BuildNoSuchMethodArguments(
+    intptr_t call_pos,
     const String& function_name,
     const ArgumentListNode& function_args) {
   ASSERT(function_args.length() >= 1);  // The receiver is the first argument.
   const intptr_t args_pos = function_args.token_pos();
   ArgumentListNode* arguments = new ArgumentListNode(args_pos);
   arguments->Add(function_args.NodeAt(0));
-  // The second argument is the original function name.
-  // TODO(regis): This will change once mirrors are supported.
-  arguments->Add(new LiteralNode(args_pos, function_name));
-  // The third argument is an array containing the original function arguments.
-  ArrayNode* args_array = new ArrayNode(
-      args_pos, Type::ZoneHandle(Type::ListInterface()));
-  for (intptr_t i = 1; i < function_args.length(); i++) {
-    args_array->AddElement(function_args.NodeAt(i));
-  }
-  arguments->Add(args_array);
+  // The second argument is the invocation mirror.
+  arguments->Add(BuildInvocationMirrorAllocation(
+      call_pos, function_name, function_args));
   return arguments;
 }
 
 
 AstNode* Parser::ParseSuperCall(const String& function_name) {
   TRACE_PARSER("ParseSuperCall");
   ASSERT(CurrentToken() == Token::kLPAREN);
   const intptr_t supercall_pos = TokenPos();
 
   const bool kResolveGetter = true;
@@ skipping 15 matching lines @@
                                             super_class,
                                             function_name);
     EnsureExpressionTemp();
     return new ClosureCallNode(supercall_pos, closure, arguments);
   }
   // 'this' parameter is the first argument to super call.
   AstNode* receiver = LoadReceiver(supercall_pos);
   arguments->Add(receiver);
   ParseActualParameters(arguments, kAllowConst);
   if (is_no_such_method) {
-    arguments = BuildNoSuchMethodArguments(function_name, *arguments);
+    arguments = BuildNoSuchMethodArguments(
+        supercall_pos, function_name, *arguments);
   }
   return new StaticCallNode(supercall_pos, super_function, arguments);
 }
 
 
 // Simple test if a node is side effect free.
 static bool IsSimpleLocalOrLiteralNode(AstNode* node) {
   if (node->IsLiteralNode()) {
     return true;
   }
@@ skipping 18 matching lines @@
     const Function& super_operator = Function::ZoneHandle(
         GetSuperFunction(super_pos,
                          operator_function_name,
                          kResolveGetter,
                          &is_no_such_method));
     ArgumentListNode* op_arguments = new ArgumentListNode(super_pos);
     AstNode* receiver = LoadReceiver(super_pos);
     op_arguments->Add(receiver);
     CheckFunctionIsCallable(super_pos, super_operator);
     if (is_no_such_method) {
-      op_arguments = BuildNoSuchMethodArguments(operator_function_name,
-                                                *op_arguments);
+      op_arguments = BuildNoSuchMethodArguments(
+          super_pos, operator_function_name, *op_arguments);
     }
     super_op = new StaticCallNode(super_pos, super_operator, op_arguments);
   } else {
     ErrorMsg(super_pos, "illegal super operator call");
   }
   return super_op;
 }
 
 
 AstNode* Parser::ParseSuperOperator() {
@@ skipping 35 matching lines @@
     ASSERT(Token::Precedence(op) >= Token::Precedence(Token::kBIT_OR));
     AstNode* other_operand = ParseBinaryExpr(Token::Precedence(op) + 1);
 
     ArgumentListNode* op_arguments = new ArgumentListNode(operator_pos);
     AstNode* receiver = LoadReceiver(operator_pos);
     op_arguments->Add(receiver);
     op_arguments->Add(other_operand);
 
     CheckFunctionIsCallable(operator_pos, super_operator);
     if (is_no_such_method) {
-      op_arguments = BuildNoSuchMethodArguments(operator_function_name,
-                                                *op_arguments);
+      op_arguments = BuildNoSuchMethodArguments(
+          operator_pos, operator_function_name, *op_arguments);
     }
     super_op = new StaticCallNode(operator_pos, super_operator, op_arguments);
     if (negate_result) {
       super_op = new UnaryOpNode(operator_pos, Token::kNOT, super_op);
     }
   }
   return super_op;
 }
 
 
@@ skipping 8362 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart