Fix function premable for native entrypoints.

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"
@@ skipping 1299 matching lines @@
   // 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();
 }
 
 
 DEFINE_NATIVE_ENTRY(ClassMirror_name, 1) {
-  const MirrorReference& klass_ref =
-      MirrorReference::CheckedHandle(arguments->NativeArgAt(0));
-  Class& klass = Class::Handle();
-  klass ^= klass_ref.referent();
+  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
+  const Class& klass = Class::Handle(ref.GetClassReferent());
   return klass.Name();
 }
 
 
 DEFINE_NATIVE_ENTRY(ClassMirror_library, 1) {
-  const MirrorReference& klass_ref =
-      MirrorReference::CheckedHandle(arguments->NativeArgAt(0));
-  Class& klass = Class::Handle();
-  klass ^= klass_ref.referent();
-
+  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
+  const Class& klass = Class::Handle(ref.GetClassReferent());
   return CreateLibraryMirror(Library::Handle(klass.library()));
 }
 
 
 // Invoke the function, or noSuchMethod if it is null. Propagate any unhandled
 // exceptions. Wrap and propagate any compilation errors.
 static RawObject* ReflectivelyInvokeDynamicFunction(const Instance& receiver,
                                                     const Function& function,
                                                     const String& target_name,
                                                     const Array& arguments) {
@@ skipping 16 matching lines @@
     UNREACHABLE();
   }
   return result.raw();
 }
 
 
 DEFINE_NATIVE_ENTRY(InstanceMirror_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_NATIVE_ARGUMENT(Instance, reflectee, arguments->NativeArgAt(1));
+  GET_NON_NULL_NATIVE_ARGUMENT(
+      String, function_name, arguments->NativeArgAt(2));
+  GET_NON_NULL_NATIVE_ARGUMENT(
+      Array, positional_args, arguments->NativeArgAt(3));
 
-  const Instance& reflectee =
-      Instance::CheckedHandle(arguments->NativeArgAt(1));
-
-  const String& function_name =
-      String::CheckedHandle(arguments->NativeArgAt(2));
-
-  const Array& positional_args =
-      Array::CheckedHandle(arguments->NativeArgAt(3));
   intptr_t number_of_arguments = positional_args.Length();
 
   const Array& args =
       Array::Handle(Array::New(number_of_arguments + 1));  // Plus receiver.
   Object& arg = Object::Handle();
   args.SetAt(0, reflectee);
   for (int i = 0; i < number_of_arguments; i++) {
     arg = positional_args.At(i);
     args.SetAt(i + 1, arg);  // Plus receiver.
   }
@@ skipping 10 matching lines @@
                                            function,
                                            function_name,
                                            args);
 }
 
 
 DEFINE_NATIVE_ENTRY(InstanceMirror_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.
-
-  const Instance& reflectee =
-      Instance::CheckedHandle(arguments->NativeArgAt(1));
-
-  const String& getter_name =
-      String::CheckedHandle(arguments->NativeArgAt(2));
+  GET_NATIVE_ARGUMENT(Instance, reflectee, arguments->NativeArgAt(1));
+  GET_NON_NULL_NATIVE_ARGUMENT(String, getter_name, arguments->NativeArgAt(2));
 
   // Every instance field has a getter Function.  Try to find the
   // getter in any superclass and use that function to access the
   // field.
   // NB: We do not use Resolver::ResolveDynamic because we want to find private
   // members.
   Class& klass = Class::Handle(reflectee.clazz());
   String& internal_getter_name = String::Handle(Field::GetterName(getter_name));
   Function& getter = Function::Handle();
   while (!klass.IsNull()) {
@@ skipping 12 matching lines @@
                                            getter,
                                            internal_getter_name,
                                            args);
 }
 
 
 DEFINE_NATIVE_ENTRY(InstanceMirror_invokeSetter, 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.
-
-  const Instance& reflectee =
-      Instance::CheckedHandle(arguments->NativeArgAt(1));
-
-  const String& setter_name =
-      String::CheckedHandle(arguments->NativeArgAt(2));
-
-  const Instance& value = Instance::CheckedHandle(arguments->NativeArgAt(3));
+  GET_NATIVE_ARGUMENT(Instance, reflectee, arguments->NativeArgAt(1));
+  GET_NON_NULL_NATIVE_ARGUMENT(String, setter_name, arguments->NativeArgAt(2));
+  GET_NATIVE_ARGUMENT(Instance, value, arguments->NativeArgAt(3));
 
   String& internal_setter_name =
       String::Handle(Field::SetterName(setter_name));
   Function& setter = Function::Handle();
 
   Class& klass = Class::Handle(reflectee.clazz());
   Field& field = Field::Handle();
 
   while (!klass.IsNull()) {
     field = klass.LookupInstanceField(setter_name);
@@ skipping 19 matching lines @@
   args.SetAt(1, value);
 
   return ReflectivelyInvokeDynamicFunction(reflectee,
                                            setter,
                                            internal_setter_name,
                                            args);
 }
 
 
 DEFINE_NATIVE_ENTRY(ClosureMirror_apply, 2) {
-  const Instance& closure = Instance::CheckedHandle(arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(Instance, closure, arguments->NativeArgAt(0));
   ASSERT(!closure.IsNull() && closure.IsCallable(NULL, NULL));
 
   const Array& positional_args =
       Array::CheckedHandle(arguments->NativeArgAt(1));
   intptr_t number_of_arguments = positional_args.Length();
 
   // Set up arguments to include the closure as the first argument.
   const Array& args = Array::Handle(Array::New(number_of_arguments + 1));
   Object& obj = Object::Handle();
   args.SetAt(0, closure);
   for (int i = 0; i < number_of_arguments; i++) {
     obj = positional_args.At(i);
     args.SetAt(i + 1, obj);
   }
 
   obj = DartEntry::InvokeClosure(args);
   if (obj.IsError()) {
     ThrowInvokeError(Error::Cast(obj));
     UNREACHABLE();
   }
   return obj.raw();
 }
 
 
 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));
 
-  const MirrorReference& klass_ref =
-      MirrorReference::CheckedHandle(arguments->NativeArgAt(1));
-  Class& klass = Class::Handle();
-  klass ^= klass_ref.referent();
-
-  const String& function_name =
-      String::CheckedHandle(arguments->NativeArgAt(2));
-
-  const Array& positional_args =
-      Array::CheckedHandle(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()) {
@@ skipping 13 matching lines @@
     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.
-
-  const MirrorReference& klass_ref =
-      MirrorReference::CheckedHandle(arguments->NativeArgAt(1));
-  Class& klass = Class::Handle();
-  klass ^= klass_ref.referent();
-
-  const String& getter_name =
-      String::CheckedHandle(arguments->NativeArgAt(2));
+  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()) {
@@ skipping 15 matching lines @@
     return result.raw();
   }
   return field.value();
 }
 
 
 DEFINE_NATIVE_ENTRY(ClassMirror_invokeSetter, 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.
-
-  const MirrorReference& klass_ref =
-      MirrorReference::CheckedHandle(arguments->NativeArgAt(1));
-  Class& klass = Class::Handle();
-  klass ^= klass_ref.referent();
-
-  const String& setter_name =
-      String::CheckedHandle(arguments->NativeArgAt(2));
-
-  const Instance& value = Instance::CheckedHandle(arguments->NativeArgAt(3));
+  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
+  const Class& klass = Class::Handle(ref.GetClassReferent());
+  GET_NON_NULL_NATIVE_ARGUMENT(String, setter_name, arguments->NativeArgAt(2));
+  GET_NATIVE_ARGUMENT(Instance, value, arguments->NativeArgAt(3));
 
   // 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()) {
@@ skipping 27 matching lines @@
     ThrowMirroredCompilationError(message);
     UNREACHABLE();
   }
 
   field.set_value(value);
   return value.raw();
 }
 
 
 DEFINE_NATIVE_ENTRY(ClassMirror_invokeConstructor, 3) {
-  const MirrorReference& klass_ref =
-      MirrorReference::CheckedHandle(arguments->NativeArgAt(0));
-  Class& klass = Class::Handle();
-  klass ^= klass_ref.referent();
-
-  const String& constructor_name =
-      String::CheckedHandle(arguments->NativeArgAt(1));
-
-  const Array& positional_args =
-      Array::CheckedHandle(arguments->NativeArgAt(2));
+  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
+  const Class& klass = Class::Handle(ref.GetClassReferent());
+  GET_NON_NULL_NATIVE_ARGUMENT(
+      String, constructor_name, arguments->NativeArgAt(1));
+  GET_NON_NULL_NATIVE_ARGUMENT(
+      Array, positional_args, arguments->NativeArgAt(2));
 
   intptr_t number_of_arguments = positional_args.Length();
 
   // By convention, the static function implementing a named constructor 'C'
   // for class 'A' is labeled 'A.C', and the static function implementing the
   // 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()));
@@ skipping 20 matching lines @@
   // 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));
 
-  const MirrorReference& library_ref =
-      MirrorReference::CheckedHandle(arguments->NativeArgAt(1));
-  Library& library = Library::Handle();
-  library ^= library_ref.referent();
-
-  const String& function_name =
-      String::CheckedHandle(arguments->NativeArgAt(2));
-
-  const Array& positional_args =
-      Array::CheckedHandle(arguments->NativeArgAt(3));
   intptr_t number_of_arguments = positional_args.Length();
 
 
   const Function& function = Function::Handle(
       library.LookupFunctionAllowPrivate(function_name));
 
   if (function.IsNull()) {
     const String& message = String::Handle(
       String::NewFormatted("%s: did not find top-level function '%s'.",
                            "LibraryMirror_invoke",
@@ skipping 24 matching lines @@
     UNREACHABLE();
   }
   return result.raw();
 }
 
 
 DEFINE_NATIVE_ENTRY(LibraryMirror_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.
-
-  const MirrorReference& library_ref =
-      MirrorReference::CheckedHandle(arguments->NativeArgAt(1));
-  Library& library = Library::Handle();
-  library ^= library_ref.referent();
-
-  const String& getter_name =
-      String::CheckedHandle(arguments->NativeArgAt(2));
+  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
+  const Library& library = Library::Handle(ref.GetLibraryReferent());
+  GET_NON_NULL_NATIVE_ARGUMENT(String, getter_name, arguments->NativeArgAt(2));
 
   // To access a top-level we may need to use the Field or the
   // getter Function.  The getter function may either be in the
   // library or in the field's owner class, depending.
   const Field& field =
       Field::Handle(library.LookupFieldAllowPrivate(getter_name));
   Function& getter = Function::Handle();
   if (field.IsNull()) {
     // No field found.  Check for a getter in the lib.
     const String& internal_getter_name =
@@ skipping 27 matching lines @@
     UNREACHABLE();
     return Instance::null();
   }
 }
 
 
 DEFINE_NATIVE_ENTRY(LibraryMirror_invokeSetter, 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.
-
-  const MirrorReference& library_ref =
-      MirrorReference::CheckedHandle(arguments->NativeArgAt(1));
-  Library& library = Library::Handle();
-  library ^= library_ref.referent();
-
-  const String& setter_name =
-      String::CheckedHandle(arguments->NativeArgAt(2));
-
-  const Instance& value = Instance::CheckedHandle(arguments->NativeArgAt(3));
+  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
+  const Library& library = Library::Handle(ref.GetLibraryReferent());
+  GET_NON_NULL_NATIVE_ARGUMENT(String, setter_name, arguments->NativeArgAt(2));
+  GET_NATIVE_ARGUMENT(Instance, value, arguments->NativeArgAt(3));
 
   // To access a top-level we may need to use the Field or the
   // setter Function.  The setter function may either be in the
   // library or in the field's owner class, depending.
   const Field& field =
       Field::Handle(library.LookupFieldAllowPrivate(setter_name));
 
   if (field.IsNull()) {
     const String& internal_setter_name =
         String::Handle(Field::SetterName(setter_name));
@@ skipping 30 matching lines @@
     ThrowMirroredCompilationError(message);
     UNREACHABLE();
   }
 
   field.set_value(value);
   return value.raw();
 }
 
 
 DEFINE_NATIVE_ENTRY(MethodMirror_name, 1) {
-  const MirrorReference& func_ref =
-      MirrorReference::CheckedHandle(arguments->NativeArgAt(0));
-  Function& func = Function::Handle();
-  func ^= func_ref.referent();
+  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
+  const Function& func = Function::Handle(ref.GetFunctionReferent());
   return func.UserVisibleName();
 }
 
 
 DEFINE_NATIVE_ENTRY(MethodMirror_owner, 1) {
-  const MirrorReference& func_ref =
-      MirrorReference::CheckedHandle(arguments->NativeArgAt(0));
-  Function& func = Function::Handle();
-  func ^= func_ref.referent();
+  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
+  const Function& func = Function::Handle(ref.GetFunctionReferent());
   if (func.IsNonImplicitClosureFunction()) {
     return CreateMethodMirror(Function::Handle(
-        func.parent_function()), Instance::Handle());
+        func.parent_function()), Object::null_instance());
   }
   const Class& owner = Class::Handle(func.Owner());
   if (owner.IsTopLevel()) {
     return CreateLibraryMirror(Library::Handle(owner.library()));
   }
-  return CreateClassMirror(owner, Instance::Handle());
+  return CreateClassMirror(owner, Object::null_instance());
 }
 
 
 DEFINE_NATIVE_ENTRY(MethodMirror_return_type, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
   const Function& func = Function::Handle(ref.GetFunctionReferent());
   // We handle constructors in Dart code.
   ASSERT(!func.IsConstructor());
   const AbstractType& return_type = AbstractType::Handle(func.result_type());
   return CreateTypeMirror(return_type);
 }
 
 }  // namespace dart