Change signature of noSuchMethod to take an InvocationMirror.

runtime/vm/flow_graph_builder.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/flow_graph_builder.h"
 
 #include "vm/ast_printer.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
 #include "vm/flags.h"
@@ skipping 2689 matching lines @@
 }
 
 
 // Looks up dynamic method noSuchMethod in target_class
 // (including its super class chain) and builds a static call to it.
 StaticCallInstr* EffectGraphVisitor::BuildStaticNoSuchMethodCall(
     const Class& target_class,
     AstNode* receiver,
     const String& method_name,
     ArgumentListNode* method_arguments) {
+  // Build the graph to allocate an InvocationMirror object by calling
+  // the static allocation method.
+  const String& mirror_name = String::Handle(Symbols::InvocationMirror());
+  const Library& corelib = Library::Handle(Library::CoreLibrary());
+  const Class& mirror_class = Class::Handle(
+      corelib.LookupClassAllowPrivate(mirror_name));
+  ASSERT(!mirror_class.IsNull());
+  const String& function_name = String::Handle(
+      Symbols::AllocateInvocationMirror());
+  const Function& allocation_function = Function::ZoneHandle(
+      Resolver::ResolveStaticByName(mirror_class,
+                                    function_name,
+                                    Resolver::kIsQualified));
+  ASSERT(!allocation_function.IsNull());
+
+  // Evaluate the receiver before the arguments. This will be used
+  // as an argument to the noSuchMethod call.
+  ValueGraphVisitor for_receiver(owner(), temp_index());
+  receiver->Visit(&for_receiver);
+  Append(for_receiver);
+  PushArgumentInstr* push_receiver = PushArgument(for_receiver.value());
+
+  // Allocate the arguments and pass them into the construction
+  // of the InvocationMirror.
+  const intptr_t args_pos = method_arguments->token_pos();
+  ArgumentListNode* arguments = new ArgumentListNode(args_pos);
+  // The first argument is the original method name.
+  arguments->Add(new LiteralNode(args_pos, method_name));
+  // The second argument is an array containing the original method arguments.
+  ArrayNode* args_array =
+      new ArrayNode(args_pos, Type::ZoneHandle(Type::ListInterface()));
+  for (intptr_t i = 0; i < method_arguments->length(); i++) {
+    args_array->AddElement(method_arguments->NodeAt(i));
+  }
+  arguments->Add(args_array);
+  ZoneGrowableArray<PushArgumentInstr*>* allocation_args =
+      new ZoneGrowableArray<PushArgumentInstr*>(arguments->length());
+  BuildPushArguments(*arguments, allocation_args);
+  StaticCallInstr* allocation = new StaticCallInstr(args_pos,
+                                                    allocation_function,
+                                                    Array::ZoneHandle(),
+                                                    allocation_args);
+  Value* invocation_mirror = Bind(allocation);
+  PushArgumentInstr* push_invocation_mirror = PushArgument(invocation_mirror);
+  // Lookup noSuchMethod and call it with the receiver and the InvocationMirror.
   const String& no_such_method_name =
       String::ZoneHandle(Symbols::NoSuchMethod());
   const Function& no_such_method_func = Function::ZoneHandle(
       Resolver::ResolveDynamicAnyArgs(target_class, no_such_method_name));
   // We are guaranteed to find noSuchMethod of class Object.
   ASSERT(!no_such_method_func.IsNull());
-
-  const intptr_t args_pos = method_arguments->token_pos();
-  ArgumentListNode* arguments = new ArgumentListNode(args_pos);
-  // The first argument is the receiver.
-  arguments->Add(receiver);
-  // The second argument is the original method name.
-  // TODO(regis): This will change once mirrors are supported.
-  arguments->Add(new LiteralNode(args_pos, method_name));
-  // The third argument is an array containing the original method arguments.
-  ArrayNode* args_array =
-      new ArrayNode(args_pos, Type::ZoneHandle(Type::ListInterface()));
-  for (intptr_t i = 0; i < method_arguments->length(); i++) {
-    args_array->AddElement(method_arguments->NodeAt(i));
-  }
-  arguments->Add(args_array);
-
   ZoneGrowableArray<PushArgumentInstr*>* args =
-      new ZoneGrowableArray<PushArgumentInstr*>(arguments->length());
-  BuildPushArguments(*arguments, args);
+      new ZoneGrowableArray<PushArgumentInstr*>(2);
+  args->Add(push_receiver);
+  args->Add(push_invocation_mirror);
   return new StaticCallInstr(args_pos,
                              no_such_method_func,
                              Array::ZoneHandle(),
                              args);
 }
 
 
 void EffectGraphVisitor::BuildThrowNode(ThrowNode* node) {
   // TODO(kmillikin) non-local control flow is not handled correctly
   // by the inliner.
@@ skipping 105 matching lines @@
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, function_name, reason) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, function_name, reason);
   const Error& error = Error::Handle(
       LanguageError::New(String::Handle(String::New(chars))));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
 }  // namespace dart