Make reflective invocations raise NoSuchMethodErrors in the cases where non-reflective invocations …

runtime/lib/mirrors.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 "include/dart_api.h"
 #include "include/dart_debugger_api.h"
 #include "include/dart_mirrors_api.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_api_state.h"  // TODO(11742): Remove with CreateMirrorRef.
 #include "vm/bootstrap_natives.h"
 #include "vm/dart_entry.h"
 #include "vm/exceptions.h"
 #include "vm/message.h"
 #include "vm/port.h"
 #include "vm/resolver.h"
 #include "vm/symbols.h"
+#include "lib/invocation_mirror.h"
 
 namespace dart {
 
 static RawInstance* CreateMirror(const String& mirror_class_name,
                                  const Array& constructor_arguments) {
   const Library& mirrors_lib = Library::Handle(Library::MirrorsLibrary());
   const String& constructor_name = Symbols::Dot();
 
   const Object& result = Object::Handle(
       DartLibraryCalls::InstanceCreate(mirrors_lib,
@@ skipping 1197 matching lines @@
   if (error.IsLanguageError()) {
     // A compilation error that was delayed by lazy compilation.
     const LanguageError& compilation_error = LanguageError::Cast(error);
     String& message = String::Handle(compilation_error.message());
     ThrowMirroredCompilationError(message);
   }
   UNREACHABLE();
 }
 
 
-static RawFunction* ResolveConstructor(const char* current_func,
-                                       const Class& cls,
-                                       const String& class_name,
-                                       const String& constr_name,
-                                       int num_args) {
-  // The constructor must be present in the interface.
-  const Function& constructor =
-      Function::Handle(cls.LookupFunctionAllowPrivate(constr_name));
-  if (constructor.IsNull() ||
-      (!constructor.IsConstructor() && !constructor.IsFactory())) {
-    const String& lookup_class_name = String::Handle(cls.Name());
-    if (!class_name.Equals(lookup_class_name)) {
-      // When the class name used to build the constructor name is
-      // different than the name of the class in which we are doing
-      // the lookup, it can be confusing to the user to figure out
-      // what's going on.  Be a little more explicit for these error
-      // messages.
-      const String& message = String::Handle(
-          String::NewFormatted(
-              "%s: could not find factory '%s' in class '%s'.",
-              current_func,
-              constr_name.ToCString(),
-              lookup_class_name.ToCString()));
-      ThrowMirroredCompilationError(message);
-      UNREACHABLE();
-    } else {
-      const String& message = String::Handle(
-          String::NewFormatted("%s: could not find constructor '%s'.",
-                               current_func, constr_name.ToCString()));
-      ThrowMirroredCompilationError(message);
-      UNREACHABLE();
-    }
-  }
-  int extra_args = (constructor.IsConstructor() ? 2 : 1);
-  String& error_message = String::Handle();
-  if (!constructor.AreValidArgumentCounts(num_args + extra_args,
-                                          0,
-                                          &error_message)) {
-    const String& message = String::Handle(
-        String::NewFormatted("%s: wrong argument count for "
-                             "constructor '%s': %s.",
-                             current_func,
-                             constr_name.ToCString(),
-                             error_message.ToCString()));
-    ThrowMirroredCompilationError(message);
-    UNREACHABLE();
-  }
-  return constructor.raw();
-}
-
-
 static bool FieldIsUninitialized(const Field& field) {
   ASSERT(!field.IsNull());
 
   // Return getter method for uninitialized fields, rather than the
   // field object, since the value in the field object will not be
   // initialized until the first time the getter is invoked.
   const Instance& value = Instance::Handle(field.value());
   ASSERT(value.raw() != Object::transition_sentinel().raw());
   return value.raw() == Object::sentinel().raw();
 }
@@ skipping 220 matching lines @@
 
   obj = DartEntry::InvokeClosure(args);
   if (obj.IsError()) {
     ThrowInvokeError(Error::Cast(obj));
     UNREACHABLE();
   }
   return obj.raw();
 }
 
 
+static void ThrowNoSuchMethod(const Instance& receiver,
+                              const String& function_name,
+                              const Function& function,
+                              const InvocationMirror::Call call,
+                              const InvocationMirror::Type type) {
+  const Smi& invocation_type = Smi::Handle(Smi::New(
+      InvocationMirror::EncodeType(call, type)));
+
+  const Array& args = Array::Handle(Array::New(6));
+  args.SetAt(0, receiver);
+  args.SetAt(1, function_name);
+  args.SetAt(2, invocation_type);
+  if (!function.IsNull()) {
+    const int total_num_parameters = function.NumParameters();
+    const Array& array = Array::Handle(Array::New(total_num_parameters));
+    String& param_name = String::Handle();
+    for (int i = 0; i < total_num_parameters; i++) {
+      param_name = function.ParameterNameAt(i);
+      array.SetAt(i, param_name);
+    }
+    args.SetAt(5, array);
+  }
+
+  Exceptions::ThrowByType(Exceptions::kNoSuchMethod, args);
+  UNREACHABLE();
+}
+
+
+static void ThrowNoSuchMethod(const Class& klass,
+                              const String& function_name,
+                              const Function& function,
+                              const InvocationMirror::Call call,
+                              const InvocationMirror::Type type) {
+  AbstractTypeArguments& type_arguments = AbstractTypeArguments::Handle();
+  Type& pre_type = Type::Handle(
+      Type::New(klass, type_arguments, Scanner::kDummyTokenIndex));
+  pre_type.SetIsFinalized();
+  AbstractType& runtime_type = AbstractType::Handle(pre_type.Canonicalize());
+
+  ThrowNoSuchMethod(runtime_type,
+                    function_name,
+                    function,
+                    call,
+                    type);
+  UNREACHABLE();
+}
+
+
+static void ThrowNoSuchMethod(const Library& library,
+                              const String& function_name,
+                              const Function& function,
+                              const InvocationMirror::Call call,
+                              const InvocationMirror::Type type) {
+  ThrowNoSuchMethod(Instance::null_instance(),
+                    function_name,
+                    function,
+                    call,
+                    type);
+  UNREACHABLE();
+}
+
+
 DEFINE_NATIVE_ENTRY(ClassMirror_invoke, 4) {
   // Argument 0 is the mirror, which is unused by the native. It exists
   // because this native is an instance method in order to be polymorphic
   // with its cousins.
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
   const Class& klass = Class::Handle(ref.GetClassReferent());
   GET_NON_NULL_NATIVE_ARGUMENT(
       String, function_name, arguments->NativeArgAt(2));
   GET_NON_NULL_NATIVE_ARGUMENT(
       Array, positional_args, arguments->NativeArgAt(3));
 
   intptr_t number_of_arguments = positional_args.Length();
 
-  // TODO(11771): This won't find private members.
   const Function& function = Function::Handle(
-        Resolver::ResolveStatic(klass,
-                                function_name,
-                                number_of_arguments,
-                                Object::empty_array(),
-                                Resolver::kIsQualified));
-  if (function.IsNull()) {
-    const String& klass_name = String::Handle(klass.Name());
-    const String& message = String::Handle(
-      String::NewFormatted("%s: did not find static method '%s.%s'.",
-                           "ClassMirror_invoke",
-                           klass_name.ToCString(),
-                           function_name.ToCString()));
-    ThrowMirroredCompilationError(message);
+      klass.LookupStaticFunctionAllowPrivate(function_name));
+
+  if (function.IsNull() ||
+      !function.AreValidArgumentCounts(number_of_arguments,
+                                       /* named_args */ 0,
+                                       NULL)) {
+    ThrowNoSuchMethod(klass,
+                      function_name,
+                      function,
+                      InvocationMirror::kStatic,
+                      InvocationMirror::kMethod);
     UNREACHABLE();
   }
+
   Object& result = Object::Handle(DartEntry::InvokeFunction(function,
                                                             positional_args));
   if (result.IsError()) {
     ThrowInvokeError(Error::Cast(result));
     UNREACHABLE();
   }
   return result.raw();
 }
 
 
 DEFINE_NATIVE_ENTRY(ClassMirror_invokeGetter, 3) {
   // Argument 0 is the mirror, which is unused by the native. It exists
   // because this native is an instance method in order to be polymorphic
   // with its cousins.
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
   const Class& klass = Class::Handle(ref.GetClassReferent());
   GET_NON_NULL_NATIVE_ARGUMENT(String, getter_name, arguments->NativeArgAt(2));
 
   // Note static fields do not have implicit getters.
   const Field& field = Field::Handle(klass.LookupStaticField(getter_name));
   if (field.IsNull() || FieldIsUninitialized(field)) {
     const String& internal_getter_name = String::Handle(
         Field::GetterName(getter_name));
     const Function& getter = Function::Handle(
         klass.LookupStaticFunctionAllowPrivate(internal_getter_name));
 
     if (getter.IsNull()) {
-      const String& message = String::Handle(
-        String::NewFormatted("%s: did not find static getter '%s'.",
-                             "ClassMirror_invokeGetter",
-                             getter_name.ToCString()));
-      ThrowMirroredCompilationError(message);
+      ThrowNoSuchMethod(klass,
+                        getter_name,
+                        getter,
+                        InvocationMirror::kStatic,
+                        InvocationMirror::kGetter);
       UNREACHABLE();
     }
 
     // Invoke the getter and return the result.
     Object& result = Object::Handle(
         DartEntry::InvokeFunction(getter, Object::empty_array()));
     if (result.IsError()) {
       ThrowInvokeError(Error::Cast(result));
       UNREACHABLE();
     }
@@ skipping 14 matching lines @@
 
   // Check for real fields and user-defined setters.
   const Field& field = Field::Handle(klass.LookupStaticField(setter_name));
   if (field.IsNull()) {
     const String& internal_setter_name = String::Handle(
       Field::SetterName(setter_name));
     const Function& setter = Function::Handle(
       klass.LookupStaticFunctionAllowPrivate(internal_setter_name));
 
     if (setter.IsNull()) {
-      const String& message = String::Handle(
-        String::NewFormatted("%s: did not find static setter '%s'.",
-                             "ClassMirror_invokeSetter",
-                             setter_name.ToCString()));
-      ThrowMirroredCompilationError(message);
+      ThrowNoSuchMethod(klass,
+                        setter_name,
+                        setter,
+                        InvocationMirror::kStatic,
+                        InvocationMirror::kSetter);
       UNREACHABLE();
     }
 
     // Invoke the setter and return the result.
     const int kNumArgs = 1;
     const Array& args = Array::Handle(Array::New(kNumArgs));
     args.SetAt(0, value);
 
     Object& result = Object::Handle(
         DartEntry::InvokeFunction(setter, args));
@@ skipping 33 matching lines @@
   // unnamed constructor for class 'A' is labeled 'A.'.
   // This convention prevents users from explicitly calling constructors.
   const String& klass_name = String::Handle(klass.Name());
   String& internal_constructor_name =
       String::Handle(String::Concat(klass_name, Symbols::Dot()));
   if (!constructor_name.IsNull()) {
     internal_constructor_name =
         String::Concat(internal_constructor_name, constructor_name);
   }
 
-  const Function& constructor =
-      Function::Handle(ResolveConstructor("ClassMirror_invokeConstructor",
-                                          klass,
-                                          klass_name,
-                                          internal_constructor_name,
-                                          number_of_arguments));
+  Function& constructor = Function::Handle(
+      klass.LookupFunctionAllowPrivate(internal_constructor_name));
+
+  if (constructor.IsNull() ||
+     (!constructor.IsConstructor() && !constructor.IsFactory()) ||
+     !constructor.AreValidArgumentCounts(number_of_arguments +
+                                         constructor.NumImplicitParameters(),
+                                         /* named args */ 0,
+                                         NULL)) {
+    // Pretend we didn't find the constructor at all when the arity is wrong
+    // so as to produce the same NoSuchMethodError as the non-reflective case.
+    constructor = Function::null();
+    ThrowNoSuchMethod(klass,
+                      internal_constructor_name,
+                      constructor,
+                      InvocationMirror::kConstructor,
+                      InvocationMirror::kMethod);
+    UNREACHABLE();
+  }
 
   const Object& result =
       Object::Handle(DartEntry::InvokeConstructor(klass,
                                                   constructor,
                                                   positional_args));
   if (result.IsError()) {
     ThrowInvokeError(Error::Cast(result));
     UNREACHABLE();
   }
   // Factories may return null.
   ASSERT(result.IsInstance() || result.IsNull());
   return result.raw();
 }
 
 
 DEFINE_NATIVE_ENTRY(LibraryMirror_invoke, 4) {
   // Argument 0 is the mirror, which is unused by the native. It exists
   // because this native is an instance method in order to be polymorphic
   // with its cousins.
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
   const Library& library = Library::Handle(ref.GetLibraryReferent());
   GET_NON_NULL_NATIVE_ARGUMENT(
       String, function_name, arguments->NativeArgAt(2));
   GET_NON_NULL_NATIVE_ARGUMENT(
       Array, positional_args, arguments->NativeArgAt(3));
 
   intptr_t number_of_arguments = positional_args.Length();
 
-
   String& ambiguity_error_msg = String::Handle(isolate);
   const Function& function = Function::Handle(
       library.LookupFunctionAllowPrivate(function_name, &ambiguity_error_msg));
 
-  if (function.IsNull()) {
-    if (ambiguity_error_msg.IsNull()) {
-      const String& message = String::Handle(
-        String::NewFormatted("%s: did not find top-level function '%s'.",
-                             "LibraryMirror_invoke",
-                             function_name.ToCString()));
-      ThrowMirroredCompilationError(message);
-    } else {
-      ThrowMirroredCompilationError(ambiguity_error_msg);
-    }
+  if (function.IsNull() && !ambiguity_error_msg.IsNull()) {
+    ThrowMirroredCompilationError(ambiguity_error_msg);
     UNREACHABLE();
   }
 
-  // LookupFunctionAllowPrivate does not check argument arity, so we
-  // do it here.
-  String& error_message = String::Handle();
-  if (!function.AreValidArgumentCounts(number_of_arguments,
-                                       /* num_named_args */ 0,
-                                       &error_message)) {
-    const String& message = String::Handle(
-      String::NewFormatted("%s: wrong argument count for function '%s': %s.",
-                           "LibraryMirror_invoke",
-                           function_name.ToCString(),
-                           error_message.ToCString()));
-    ThrowMirroredCompilationError(message);
+  if (function.IsNull() ||
+     !function.AreValidArgumentCounts(number_of_arguments,
+                                      0,
+                                      NULL) ) {
+    ThrowNoSuchMethod(library,
+                      function_name,
+                      function,
+                      InvocationMirror::kTopLevel,
+                      InvocationMirror::kMethod);
     UNREACHABLE();
   }
 
   const Object& result = Object::Handle(
       DartEntry::InvokeFunction(function, positional_args));
   if (result.IsError()) {
     ThrowInvokeError(Error::Cast(result));
     UNREACHABLE();
   }
   return result.raw();
@@ skipping 36 matching lines @@
     if (result.IsError()) {
       ThrowInvokeError(Error::Cast(result));
       UNREACHABLE();
     }
     return result.raw();
   }
   if (!field.IsNull()) {
     return field.value();
   }
   if (ambiguity_error_msg.IsNull()) {
-    const String& message = String::Handle(
-        String::NewFormatted("%s: did not find top-level variable '%s'.",
-                             "LibraryMirror_invokeGetter",
-                             getter_name.ToCString()));
-    ThrowMirroredCompilationError(message);
+    ThrowNoSuchMethod(library,
+                      getter_name,
+                      getter,
+                      InvocationMirror::kTopLevel,
+                      InvocationMirror::kGetter);
   } else {
     ThrowMirroredCompilationError(ambiguity_error_msg);
   }
   UNREACHABLE();
   return Instance::null();
 }
 
 
 DEFINE_NATIVE_ENTRY(LibraryMirror_invokeSetter, 4) {
   // Argument 0 is the mirror, which is unused by the native. It exists
@@ skipping 12 matching lines @@
       library.LookupFieldAllowPrivate(setter_name, &ambiguity_error_msg));
 
   if (field.IsNull() && ambiguity_error_msg.IsNull()) {
     const String& internal_setter_name =
         String::Handle(Field::SetterName(setter_name));
     const Function& setter = Function::Handle(
         library.LookupFunctionAllowPrivate(internal_setter_name,
                                            &ambiguity_error_msg));
     if (setter.IsNull()) {
       if (ambiguity_error_msg.IsNull()) {
-        const String& message = String::Handle(
-          String::NewFormatted("%s: did not find top-level variable '%s'.",
-                               "LibraryMirror_invokeSetter",
-                               setter_name.ToCString()));
-        ThrowMirroredCompilationError(message);
+        ThrowNoSuchMethod(library,
+                          setter_name,
+                          setter,
+                          InvocationMirror::kTopLevel,
+                          InvocationMirror::kSetter);
       } else {
         ThrowMirroredCompilationError(ambiguity_error_msg);
       }
       UNREACHABLE();
     }
 
     // Invoke the setter and return the result.
     const int kNumArgs = 1;
     const Array& args = Array::Handle(Array::New(kNumArgs));
     args.SetAt(0, value);
@@ skipping 64 matching lines @@
 
 DEFINE_NATIVE_ENTRY(VariableMirror_type, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
   const Field& field = Field::Handle(ref.GetFieldReferent());
 
   const AbstractType& type = AbstractType::Handle(field.type());
   return CreateTypeMirror(type);
 }
 
 }  // namespace dart