- Improve the message for NoSuchMethodErrors that are

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 "lib/invocation_mirror.h"
 #include "vm/ast_printer.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
 #include "vm/flags.h"
 #include "vm/il_printer.h"
 #include "vm/intermediate_language.h"
 #include "vm/longjump.h"
 #include "vm/object_store.h"
 #include "vm/os.h"
 #include "vm/parser.h"
@@ skipping 2350 matching lines @@
       // 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.
 
       // Throw a NoSuchMethodError.
-      StaticCallInstr* call = BuildThrowNoSuchMethodError(node->token_pos(),
-                                                          node->cls(),
-                                                          getter_name);
+      StaticCallInstr* call = BuildThrowNoSuchMethodError(
+          node->token_pos(),
+          node->cls(),
+          getter_name,
+          InvocationMirror::EncodeType(
+              node->cls().IsTopLevel() ?
+                  InvocationMirror::kTopLevel :
+                  InvocationMirror::kStatic,
+              InvocationMirror::kGetter));
       ReturnDefinition(call);
       return;
     }
   }
   ASSERT(!getter_function.IsNull());
   StaticCallInstr* call = new StaticCallInstr(node->token_pos(),
                                               getter_function,
                                               Array::ZoneHandle(),  // No names.
                                               arguments);
   ReturnDefinition(call);
@@ skipping 21 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.
-      call = BuildThrowNoSuchMethodError(node->token_pos(),
-                                         node->cls(),
-                                         setter_name);
+      call = BuildThrowNoSuchMethodError(
+          node->token_pos(),
+          node->cls(),
+          setter_name,
+          InvocationMirror::EncodeType(
+            node->cls().IsTopLevel() ?
+                InvocationMirror::kTopLevel :
+                InvocationMirror::kStatic,
+            InvocationMirror::kGetter));
     }
   } else {
     if (is_super_setter) {
       // Add receiver of instance getter.
       ValueGraphVisitor for_receiver(owner(), temp_index());
       node->receiver()->Visit(&for_receiver);
       Append(for_receiver);
       arguments->Add(PushArgument(for_receiver.value()));
     }
     ValueGraphVisitor for_value(owner(), temp_index());
@@ skipping 656 matching lines @@
   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) {
+    const String& function_name,
+    int invocation_type) {
   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));
+  // Smi invocation_type.
+  Value* invocation_type_value = Bind(new ConstantInstr(
+      Smi::ZoneHandle(Smi::New(invocation_type))));
+  arguments->Add(PushArgument(invocation_type_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()));
@@ skipping 120 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