Remove NoSuchMethodErrorImplementation class and use NoSuchMethodError from core

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 2128 matching lines @@
       // expression (the parser has not distinguished between left and right
       // hand side yet at this stage). If the parser establishes later that the
       // field access is part of a left hand side expression, the
       // StaticGetterNode is transformed into a StaticSetterNode referring to
       // the existing static setter.
       // However, if the field reference appears in a right hand side
       // expression, no such transformation occurs and we land here with a
       // StaticGetterNode missing a getter function, so we throw a
       // NoSuchMethodError.
 
-      // Location argument.
-      Value* call_pos = Bind(
-          new ConstantInstr(Smi::ZoneHandle(Smi::New(node->token_pos()))));
-      arguments->Add(PushArgument(call_pos));
-      // Function name argument.
-      const String& method_name = String::ZoneHandle(Symbols::New(getter_name));
-      Value* method_name_value = Bind(new ConstantInstr(method_name));
-      arguments->Add(PushArgument(method_name_value));
-      const String& cls_name = String::Handle(Symbols::NoSuchMethodError());
-      const String& func_name = String::Handle(Symbols::ThrowNew());
-      const Class& cls = Class::Handle(
-          Library::Handle(Library::CoreLibrary()).LookupClass(cls_name));
-      ASSERT(!cls.IsNull());
-      getter_function = Resolver::ResolveStatic(cls,
-                                                func_name,
-                                                arguments->length(),
-                                                Array::ZoneHandle(),
-                                                Resolver::kIsQualified);
-      ASSERT(!getter_function.IsNull());
+      // Throw a NoSuchMethodError.
+      StaticCallInstr* call = BuildThrowNoSuchMethodError(node->token_pos(),
+                                                          node->cls(),
+                                                          getter_name);
+      ReturnDefinition(call);
+      return;
     }
   }
+  ASSERT(!getter_function.IsNull());
   StaticCallInstr* call = new StaticCallInstr(node->token_pos(),
                                               getter_function,
                                               Array::ZoneHandle(),  // No names.
                                               arguments);
   ReturnDefinition(call);
 }
 
 
 void EffectGraphVisitor::BuildStaticSetter(StaticSetterNode* node,
                                            bool result_is_needed) {
@@ skipping 16 matching lines @@
       // Resolve and call noSuchMethod.
       ArgumentListNode* arguments = new ArgumentListNode(node->token_pos());
       arguments->Add(node->receiver());
       arguments->Add(node->value());
       call = BuildStaticNoSuchMethodCall(node->cls(),
                                          node->receiver(),
                                          setter_name,
                                          arguments);
     } else {
       // Throw a NoSuchMethodError.
-      // Location argument.
-      Value* call_pos = Bind(
-          new ConstantInstr(Smi::ZoneHandle(Smi::New(node->token_pos()))));
-      arguments->Add(PushArgument(call_pos));
-      // Function name argument.
-      const String& method_name = String::ZoneHandle(Symbols::New(setter_name));
-      Value* method_name_value = Bind(new ConstantInstr(method_name));
-      arguments->Add(PushArgument(method_name_value));
-      const String& cls_name = String::Handle(Symbols::NoSuchMethodError());
-      const String& func_name = String::Handle(Symbols::ThrowNew());
-      const Class& cls = Class::Handle(
-          Library::Handle(Library::CoreLibrary()).LookupClass(cls_name));
-      ASSERT(!cls.IsNull());
-      setter_function = Resolver::ResolveStatic(cls,
-                                                func_name,
-                                                arguments->length(),
-                                                Array::ZoneHandle(),
-                                                Resolver::kIsQualified);
-      ASSERT(!setter_function.IsNull());
-      call = new StaticCallInstr(node->token_pos(),
-                                 setter_function,
-                                 Array::ZoneHandle(),  // No names.
-                                 arguments);
+      call = BuildThrowNoSuchMethodError(node->token_pos(),
+                                         node->cls(),
+                                         setter_name);
     }
   } else {
     if (is_super_setter) {
       // Add receiver of instance getter.
       ValueGraphVisitor for_receiver(owner(), temp_index(), loop_depth());
       node->receiver()->Visit(&for_receiver);
       Append(for_receiver);
       arguments->Add(PushArgument(for_receiver.value()));
     }
     ValueGraphVisitor for_value(owner(), temp_index(), loop_depth());
@@ skipping 658 matching lines @@
       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);
 }
 
 
+StaticCallInstr* EffectGraphVisitor::BuildThrowNoSuchMethodError(
+    intptr_t token_pos,
+    const Class& function_class,
+    const String& function_name) {
+  ZoneGrowableArray<PushArgumentInstr*>* arguments =
+      new ZoneGrowableArray<PushArgumentInstr*>();
+  // 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(function_class,
+                TypeArguments::Handle(),
+                token_pos,
+                Heap::kOld));
+  type ^= ClassFinalizer::FinalizeType(
+      function_class, type, ClassFinalizer::kCanonicalize);
+  Value* receiver_value = Bind(new ConstantInstr(type));
+  arguments->Add(PushArgument(receiver_value));
+  // String memberName.
+  const String& member_name = String::ZoneHandle(Symbols::New(function_name));
+  Value* member_name_value = Bind(new ConstantInstr(member_name));
+  arguments->Add(PushArgument(member_name_value));
+  // List arguments.
+  Value* arguments_value = Bind(new ConstantInstr(Array::ZoneHandle()));
+  arguments->Add(PushArgument(arguments_value));
+  // List argumentNames.
+  Value* argument_names_value =
+      Bind(new ConstantInstr(Array::ZoneHandle()));
+  arguments->Add(PushArgument(argument_names_value));
+  // List existingArgumentNames.
+  Value* existing_argument_names_value =
+      Bind(new ConstantInstr(Array::ZoneHandle()));
+  arguments->Add(PushArgument(existing_argument_names_value));
+  // Resolve and call NoSuchMethodError._throwNew.
+  const String& cls_name = String::Handle(Symbols::NoSuchMethodError());
+  const String& func_name = String::Handle(Symbols::ThrowNew());
+  const Class& cls = Class::Handle(
+      Library::Handle(Library::CoreLibrary()).LookupClass(cls_name));
+  ASSERT(!cls.IsNull());
+  const Function& func = Function::ZoneHandle(
+      Resolver::ResolveStatic(cls,
+                              func_name,
+                              arguments->length(),
+                              Array::ZoneHandle(),
+                              Resolver::kIsQualified));
+  ASSERT(!func.IsNull());
+  return new StaticCallInstr(token_pos,
+                             func,
+                             Array::ZoneHandle(),  // No names.
+                             arguments);
+}
+
+
 void EffectGraphVisitor::BuildThrowNode(ThrowNode* node) {
   // TODO(kmillikin) non-local control flow is not handled correctly
   // by the inliner.
   InlineBailout("EffectGraphVisitor::BuildThrowNode (exception)");
   ValueGraphVisitor for_exception(owner(), temp_index(), loop_depth());
   node->exception()->Visit(&for_exception);
   Append(for_exception);
   PushArgument(for_exception.value());
   Instruction* instr = NULL;
   if (node->stacktrace() == NULL) {
@@ skipping 101 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