Implement the invoke methods (invoke, getField, setField, newInstance, apply) as internal natives.

runtime/lib/mirrors.cc

Index: runtime/lib/mirrors.cc
===================================================================
--- runtime/lib/mirrors.cc	(revision 24895)
+++ runtime/lib/mirrors.cc	(working copy)
@@ -13,6 +13,7 @@
 #include "vm/message.h"
 #include "vm/port.h"
 #include "vm/resolver.h"
+#include "vm/symbols.h"
 
 namespace dart {
 
@@ -952,6 +953,7 @@
     return member_map;
   }
   Dart_Handle args[] = {
+    CreateMirrorReference(lib),
     CreateVMReference(lib),
     Dart_LibraryName(lib),
     Dart_LibraryUrl(lib),
@@ -1121,7 +1123,7 @@
 }
 
 
-static Dart_Handle CreateMirroredError(Dart_Handle error) {
+static Dart_Handle CreateHandledMirroredError(Dart_Handle error) {
   ASSERT(Dart_IsError(error));
   if (Dart_IsUnhandledExceptionError(error)) {
     Dart_Handle exc = Dart_ErrorGetException(error);
@@ -1242,18 +1244,18 @@
   Dart_ExitScope();
 }
 
-void NATIVE_ENTRY_FUNCTION(LocalObjectMirrorImpl_invoke)(
+
+void NATIVE_ENTRY_FUNCTION(LocalClosureMirrorImpl_apply)(
     Dart_NativeArguments args) {
   Dart_EnterScope();
   Dart_Handle mirror = Dart_GetNativeArgument(args, 0);
-  Dart_Handle member_name = Dart_GetNativeArgument(args, 1);
   // The arguments are either simple values or instance mirrors.
-  Dart_Handle positional_arguments = Dart_GetNativeArgument(args, 2);
-  Dart_Handle async = Dart_GetNativeArgument(args, 3);
+  Dart_Handle positional_arguments = Dart_GetNativeArgument(args, 1);
+  Dart_Handle async = Dart_GetNativeArgument(args, 2);
 
   Dart_Handle reflectee = UnwrapMirror(mirror);
+  GrowableArray<Dart_Handle> invoke_args;
   Dart_Handle result;
-  GrowableArray<Dart_Handle> invoke_args;
   if (Dart_IdentityEquals(async, Dart_True())) {
     result = UnwrapArgList(positional_arguments, &invoke_args);
   } else {
@@ -1262,14 +1264,12 @@
   if (Dart_IsError(result)) {
     Dart_PropagateError(result);
   }
-  result = Dart_Invoke(reflectee,
-                       member_name,
-                       invoke_args.length(),
-                       invoke_args.data());
+  result =
+      Dart_InvokeClosure(reflectee, invoke_args.length(), invoke_args.data());
   if (Dart_IsError(result)) {
-    // Instead of propagating the error from an invoke directly, we
+    // Instead of propagating the error from an apply directly, we
     // provide reflective access to the error.
-    Dart_PropagateError(CreateMirroredError(result));
+    Dart_PropagateError(CreateHandledMirroredError(result));
   }
 
   Dart_Handle wrapped_result = CreateInstanceMirror(result);
@@ -1281,153 +1281,704 @@
 }
 
 
-void NATIVE_ENTRY_FUNCTION(LocalObjectMirrorImpl_getField)(
-    Dart_NativeArguments args) {
-  Dart_EnterScope();
-  Dart_Handle mirror = Dart_GetNativeArgument(args, 0);
-  Dart_Handle fieldName = Dart_GetNativeArgument(args, 1);
+void HandleMirrorsMessage(Isolate* isolate,
+                          Dart_Port reply_port,
+                          const Instance& message) {
+  UNIMPLEMENTED();
+}
 
-  Dart_Handle reflectee = UnwrapMirror(mirror);
-  Dart_Handle result = Dart_GetField(reflectee, fieldName);
-  if (Dart_IsError(result)) {
-    // Instead of propagating the error from a GetField directly, we
-    // provide reflective access to the error.
-    Dart_PropagateError(CreateMirroredError(result));
-  }
 
-  Dart_Handle wrapped_result = CreateInstanceMirror(result);
-  if (Dart_IsError(wrapped_result)) {
-    Dart_PropagateError(wrapped_result);
-  }
-  Dart_SetReturnValue(args, wrapped_result);
-  Dart_ExitScope();
+// TODO(11742): This is transitional.
+static RawInstance* Reflect(const Instance& reflectee) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  return Instance::RawCast(
+      Api::UnwrapHandle(
+          CreateInstanceMirror(
+              Api::NewHandle(isolate, reflectee.raw()))));
 }
 
 
-void NATIVE_ENTRY_FUNCTION(LocalObjectMirrorImpl_setField)(
-    Dart_NativeArguments args) {
-  Dart_EnterScope();
-  Dart_Handle mirror = Dart_GetNativeArgument(args, 0);
-  Dart_Handle fieldName = Dart_GetNativeArgument(args, 1);
-  Dart_Handle value = Dart_GetNativeArgument(args, 2);
-  Dart_Handle async = Dart_GetNativeArgument(args, 3);
+// This is based on the embedding API, but direct use of the cid outside of
+// object.h/.c is questionable.
+static bool IsApiError(const Object& object) {
+  return object.GetClassId() == kApiErrorCid;
+}
+static bool IsCompilationError(const Object& object) {
+  return object.GetClassId() == kLanguageErrorCid;
+}
 
-  Dart_Handle reflectee = UnwrapMirror(mirror);
-  Dart_Handle set_arg;
-  if (Dart_IdentityEquals(async, Dart_True())) {
-    set_arg = UnwrapArg(value);
+
+static RawError* CreateMirroredError(const Error& error) {

[siva, 2013/07/11 23:50:59]

Why can't this just be
void ThrowMirroredError(const Error& error);

[rmacnak, 2013/07/12 00:04:09]

Good point.

+  if (error.IsUnhandledException()) {
+    const UnhandledException& unhandled_ex = UnhandledException::Cast(error);
+    Instance& exc = Instance::Handle(unhandled_ex.exception());
+    Instance& stack = Instance::Handle(unhandled_ex.stacktrace());
+
+    Object& exc_string_or_error =
+        Object::Handle(DartLibraryCalls::ToString(exc));
+    Instance& exc_string = Instance::Handle();
+    if (exc_string_or_error.IsError()) {
+      exc_string ^= Instance::null();
+    } else {
+      exc_string ^= exc_string_or_error.raw();
+    }
+
+    Instance& mirror_on_exc = Instance::Handle(Reflect(exc));
+
+    Array& args = Array::Handle(Array::New(3));
+    args.SetAt(0, mirror_on_exc);
+    args.SetAt(1, exc_string);
+    args.SetAt(2, stack);
+
+    Instance& mirrored_exc = Instance::CheckedHandle(
+        DartLibraryCalls::ExceptionCreate(
+            Library::Handle(Library::MirrorsLibrary()),
+            String::Handle(String::New("MirroredUncaughtExceptionError")),
+            Symbols::Dot(),  // The unnamed constructor.
+            args));
+
+    return UnhandledException::New(mirrored_exc, stack);

[siva, 2013/07/11 23:50:59]

Here you would call:
Exceptions::ThrowByType(kMirroredUncaughtExceptionError, args);

+  } else if (IsApiError(error) ||
+             IsCompilationError(error)) {
+    String& message = String::Handle();
+    if (IsApiError(error)) {
+      message ^= ApiError::Cast(error).message();
+    } else {
+      message ^= LanguageError::Cast(error).message();
+    }
+
+    Array& args = Array::Handle(Array::New(1));
+    args.SetAt(0, message);
+
+    Instance& mirrored_exc = Instance::CheckedHandle(
+        DartLibraryCalls::ExceptionCreate(
+            Library::Handle(Library::MirrorsLibrary()),
+            String::Handle(String::New("MirroredCompilationError")),
+            Symbols::Dot(),  // The unnamed constructor.
+            args));
+
+    const Instance& stack = Instance::Handle();
+    return UnhandledException::New(mirrored_exc, stack);

[siva, 2013/07/11 23:50:59]

Here you would call
Exceptions::ThrowByType(kMirroredCompilationError, args);

   } else {
-    set_arg = value;
+    UNREACHABLE();
+    return Error::null();
   }
-  if (Dart_IsError(set_arg)) {
-    Dart_PropagateError(set_arg);
+}
+
+
+static RawObject* 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()));
+      return ApiError::New(message);
+    } else {
+      const String& message = String::Handle(
+          String::NewFormatted("%s: could not find constructor '%s'.",
+                               current_func, constr_name.ToCString()));
+      return ApiError::New(message);
+    }
   }
-  Dart_Handle result = Dart_SetField(reflectee, fieldName, set_arg);
-  if (Dart_IsError(result)) {
-    // Instead of propagating the error from a SetField directly, we
-    // provide reflective access to the error.
-    Dart_PropagateError(CreateMirroredError(result));
+  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()));
+    return ApiError::New(message);
   }
+  return constructor.raw();
+}
 
-  Dart_Handle wrapped_result = CreateInstanceMirror(result);
-  if (Dart_IsError(wrapped_result)) {
-    Dart_PropagateError(wrapped_result);
-  }
-  Dart_SetReturnValue(args, wrapped_result);
-  Dart_ExitScope();
+
+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();
 }
 
 
-void NATIVE_ENTRY_FUNCTION(LocalClosureMirrorImpl_apply)(
-    Dart_NativeArguments args) {
-  Dart_EnterScope();
-  Dart_Handle mirror = Dart_GetNativeArgument(args, 0);
-  // The arguments are either simple values or instance mirrors.
-  Dart_Handle positional_arguments = Dart_GetNativeArgument(args, 1);
-  Dart_Handle async = Dart_GetNativeArgument(args, 2);
+DEFINE_NATIVE_ENTRY(ClassMirror_name, 1) {
+  const MirrorReference& klass_ref =
+      MirrorReference::CheckedHandle(arguments->NativeArgAt(0));
+  Class& klass = Class::Handle();
+  klass ^= klass_ref.referent();
+  return klass.Name();
+}
 
-  Dart_Handle reflectee = UnwrapMirror(mirror);
-  GrowableArray<Dart_Handle> invoke_args;
-  Dart_Handle result;
-  if (Dart_IdentityEquals(async, Dart_True())) {
-    result = UnwrapArgList(positional_arguments, &invoke_args);
+
+DEFINE_NATIVE_ENTRY(InstanceMirror_invoke, 4) {

[siva, 2013/07/11 23:50:59]

Argument 0 is not used at all in these methods, should these just be static
methods (here and all the native methods below).

[rmacnak, 2013/07/12 00:04:09]

Argument 0 is the mirror. These natives are polymorphic w/r/t ObjectMirror.

+  const Instance& receiver = 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();
+
+
+  intptr_t num_receiver = 1;  // 1 for instance methods
+  const Array& args =
+      Array::Handle(Array::New(number_of_arguments + num_receiver));
+  Object& arg = Object::Handle();
+  for (int i = 0; i < number_of_arguments; i++) {
+    arg = positional_args.At(i);
+    args.SetAt((i + num_receiver), arg);
+  }
+  args.SetAt(0, receiver);
+
+  // TODO(11771): This won't find private members.
+  const Function& function = Function::Handle(
+        Resolver::ResolveDynamic(receiver,
+                                 function_name,
+                                 (number_of_arguments + 1),
+                                 Resolver::kIsQualified));
+
+  Object& result = Object::Handle();

[siva, 2013/07/11 23:50:59]

Can you share the 'arg' handle above and the 'result' handle here
by just naming it 'obj'.

+
+  if (function.IsNull()) {
+      const Array& args_descriptor =
+          Array::Handle(ArgumentsDescriptor::New(args.Length()));
+     result = DartEntry::InvokeNoSuchMethod(receiver,
+                                            function_name,
+                                            args,
+                                            args_descriptor);
   } else {
-    result = UnpackLocalArgList(positional_arguments, &invoke_args);
+    result = DartEntry::InvokeFunction(function, args);
   }
-  if (Dart_IsError(result)) {
-    Dart_PropagateError(result);
+
+  if (result.IsError()) {
+    Error& mirrored_error =
+        Error::Handle(CreateMirroredError(Error::Cast(result)));
+    Exceptions::PropagateError(mirrored_error);
+    UNREACHABLE();

[siva, 2013/07/11 23:50:59]

ThrowMirroredError(Error::Cast(result));

   }
-  result =
-      Dart_InvokeClosure(reflectee, invoke_args.length(), invoke_args.data());
-  if (Dart_IsError(result)) {
-    // Instead of propagating the error from an apply directly, we
-    // provide reflective access to the error.
-    Dart_PropagateError(CreateMirroredError(result));
+  return result.raw();
+}
+
+
+DEFINE_NATIVE_ENTRY(InstanceMirror_invokeGetter, 3) {
+  const Instance& receiver = Instance::CheckedHandle(arguments->NativeArgAt(1));
+
+  const String& getter_name =
+      String::CheckedHandle(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(receiver.clazz());
+  String& internal_getter_name = String::Handle(Field::GetterName(getter_name));
+  Function& getter = Function::Handle();
+  while (!klass.IsNull()) {
+    getter = klass.LookupDynamicFunctionAllowPrivate(internal_getter_name);
+    if (!getter.IsNull()) {
+      break;
+    }
+    klass = klass.SuperClass();
   }
 
-  Dart_Handle wrapped_result = CreateInstanceMirror(result);
-  if (Dart_IsError(wrapped_result)) {
-    Dart_PropagateError(wrapped_result);
+  Object& result = Object::Handle();
+
+  // Invoke the getter or DNU and return the result.
+  const int kNumArgs = 1;
+  const Array& args = Array::Handle(Array::New(kNumArgs));
+  args.SetAt(0, receiver);
+
+  if (getter.IsNull()) {
+    const Array& args_descriptor =
+        Array::Handle(ArgumentsDescriptor::New(args.Length()));
+    result = DartEntry::InvokeNoSuchMethod(receiver,
+                                             internal_getter_name,
+                                             args,
+                                             args_descriptor);
+  } else {
+    result = DartEntry::InvokeFunction(getter, args);
   }
-  Dart_SetReturnValue(args, wrapped_result);
-  Dart_ExitScope();
+
+  if (result.IsError()) {
+    Error& mirrored_error =
+        Error::Handle(CreateMirroredError(Error::Cast(result)));
+    Exceptions::PropagateError(mirrored_error);
+    UNREACHABLE();
+  }
+  return result.raw();
 }
 
 
-void NATIVE_ENTRY_FUNCTION(LocalClassMirrorImpl_invokeConstructor)(
-    Dart_NativeArguments args) {
-  Dart_EnterScope();
-  Dart_Handle klass_mirror = Dart_GetNativeArgument(args, 0);
-  Dart_Handle constructor_name = Dart_GetNativeArgument(args, 1);
-  // The arguments are either simple values or instance mirrors.
-  Dart_Handle positional_arguments = Dart_GetNativeArgument(args, 2);
-  Dart_Handle async = Dart_GetNativeArgument(args, 3);
+DEFINE_NATIVE_ENTRY(InstanceMirror_invokeSetter, 4) {
+  const Instance& receiver = Instance::CheckedHandle(arguments->NativeArgAt(1));
 
-  Dart_Handle klass = UnwrapMirror(klass_mirror);
-  GrowableArray<Dart_Handle> invoke_args;
-  Dart_Handle result;
-  if (Dart_IdentityEquals(async, Dart_True())) {
-    result = UnwrapArgList(positional_arguments, &invoke_args);
+  const String& setter_name =
+      String::CheckedHandle(arguments->NativeArgAt(2));
+
+  const Instance& value = Instance::CheckedHandle(arguments->NativeArgAt(3));
+
+  String& internal_setter_name =
+      String::Handle(Field::SetterName(setter_name));
+  Function& setter = Function::Handle();
+
+  if (receiver.IsNull()) {
+    // null's class doesn't handle lookups gracefully, fall through to the DNU
+    // case.
   } else {
-    result = UnpackLocalArgList(positional_arguments, &invoke_args);
+    Class& klass = Class::Handle(receiver.clazz());
+    Field& field = Field::Handle();
+
+    while (!klass.IsNull()) {
+      field = klass.LookupInstanceField(setter_name);
+      if (!field.IsNull() && field.is_final()) {
+        const String& message = String::Handle(
+            String::NewFormatted("%s: cannot set final field '%s'.",
+                                 "InstanceMirror_invokeSetter",
+                                 setter_name.ToCString()));
+        Error& error = Error::Handle(ApiError::New(message));
+        error = CreateMirroredError(error);
+        Exceptions::PropagateError(error);
+        UNREACHABLE();

[siva, 2013/07/11 23:50:59]

Instead of this elaborate scheme of first creating an ApiError and then morphing
it into an unhandled exception using CreateMirroredError why don't you add a
type kMirroredCompilationError to exceptions.h
and use
Exceptions::ThrowByType(kMirroredCompilationError, args);
here.

+      }
+      setter = klass.LookupDynamicFunctionAllowPrivate(internal_setter_name);
+      if (!setter.IsNull()) {
+        break;
+      }
+      klass = klass.SuperClass();
+    }
   }
-  if (Dart_IsError(result)) {
-    Dart_PropagateError(result);
+
+  Object& result = Object::Handle();
+
+  // Invoke the setter and return the result.
+  const int kNumArgs = 2;
+  const Array& args = Array::Handle(Array::New(kNumArgs));
+  args.SetAt(0, receiver);
+  args.SetAt(1, value);
+  if (setter.IsNull()) {
+    const Array& args_descriptor =
+        Array::Handle(ArgumentsDescriptor::New(args.Length()));
+    result =  DartEntry::InvokeNoSuchMethod(receiver,
+                                            internal_setter_name,
+                                            args,
+                                            args_descriptor);
+  } else {
+    result = DartEntry::InvokeFunction(setter, args);
   }
-  result = Dart_New(klass,
-                    constructor_name,
-                    invoke_args.length(),
-                    invoke_args.data());
-  if (Dart_IsError(result)) {
-    // Instead of propagating the error from an invoke directly, we
-    // provide reflective access to the error.
-    Dart_PropagateError(CreateMirroredError(result));
+
+  if (result.IsError()) {
+    Error& mirrored_error =
+        Error::Handle(CreateMirroredError(Error::Cast(result)));
+    Exceptions::PropagateError(mirrored_error);
+    UNREACHABLE();
   }
+  return result.raw();
+}
 
-  Dart_Handle wrapped_result = CreateInstanceMirror(result);
-  if (Dart_IsError(wrapped_result)) {
-    Dart_PropagateError(wrapped_result);
+
+DEFINE_NATIVE_ENTRY(ClassMirror_invoke, 4) {

[siva, 2013/07/11 23:50:59]

Argument 0 is not used at all here, maybe this should just be a static native
methods then?

+  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()) {
+    const String& klass_name = String::Handle(klass.Name());
+    const String& message = String::Handle(
+      String::NewFormatted("%s: did not find %d-arg static method '%s.%s'.",
+                           "ClassMirror_invoke",
+                           number_of_arguments,
+                           klass_name.ToCString(),
+                           function_name.ToCString()));
+    Error& error = Error::Handle(ApiError::New(message));
+    error = CreateMirroredError(error);
+    Exceptions::PropagateError(error);

[siva, 2013/07/11 23:50:59]

Instead of this elaborate scheme of first creating an ApiError and then morphing
it into an unhandled exception using CreateMirroredError why don't you add a
type kMirroredCompilationError to exceptions.h
and use
Exceptions::ThrowByType(kMirroredCompilationError, args);
here.

+    UNREACHABLE();
   }
-  Dart_SetReturnValue(args, wrapped_result);
-  Dart_ExitScope();
+  Object& result = Object::Handle(DartEntry::InvokeFunction(function,
+                                                            positional_args));
+  if (result.IsError()) {
+    Error& mirrored_error =
+        Error::Handle(CreateMirroredError(Error::Cast(result)));
+    Exceptions::PropagateError(mirrored_error);
+    UNREACHABLE();
+  }
+  return result.raw();
 }
 
 
-void HandleMirrorsMessage(Isolate* isolate,
-                          Dart_Port reply_port,
-                          const Instance& message) {
-  UNIMPLEMENTED();
+DEFINE_NATIVE_ENTRY(ClassMirror_invokeGetter, 3) {
+  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));
+
+  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()));
+      Error& error = Error::Handle(ApiError::New(message));
+      error = CreateMirroredError(error);
+      Exceptions::PropagateError(error);
+      UNREACHABLE();
+    }
+
+    // Invoke the getter and return the result.
+    Object& result = Object::Handle(
+        DartEntry::InvokeFunction(getter, Object::empty_array()));
+    if (result.IsError()) {
+      Error& mirrored_error =
+          Error::Handle(CreateMirroredError(Error::Cast(result)));
+      Exceptions::PropagateError(mirrored_error);
+      UNREACHABLE();
+    }
+    return result.raw();
+  }
+  return field.value();
 }
 
 
-DEFINE_NATIVE_ENTRY(ClassMirror_name, 1) {
+DEFINE_NATIVE_ENTRY(ClassMirror_invokeSetter, 4) {
   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));
+
+  // 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()));
+      Error& error = Error::Handle(ApiError::New(message));
+      error = CreateMirroredError(error);
+      Exceptions::PropagateError(error);
+      UNREACHABLE();
+    }
+
+    // Invoke the getter 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));
+    if (result.IsError()) {
+      Error& mirrored_error =
+          Error::Handle(CreateMirroredError(Error::Cast(result)));
+      Exceptions::PropagateError(mirrored_error);
+      UNREACHABLE();
+    }
+    return result.raw();
+  }
+
+  if (field.is_final()) {
+    const String& message = String::Handle(
+        String::NewFormatted("%s: cannot set final field '%s'.",
+                             "ClassMirror_invokeSetter",
+                             setter_name.ToCString()));
+    Error& error = Error::Handle(ApiError::New(message));
+    error = CreateMirroredError(error);
+    Exceptions::PropagateError(error);
+    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();
-  return klass.Name();
+
+  const String& constructor_name =
+      String::CheckedHandle(arguments->NativeArgAt(1));
+
+  const Array& positional_args =
+      Array::CheckedHandle(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.
+  String& klass_name = String::Handle(klass.Name());
+  String& internal_constructor_name =
+      String::Handle(String::Concat(klass_name, Symbols::Dot()));
+  internal_constructor_name =
+      String::Concat(internal_constructor_name, constructor_name);
+
+  Object& constructor = Object::Handle();
+  constructor = ResolveConstructor("ClassMirror_invokeConstructor",
+                                   klass,
+                                   klass_name,
+                                   internal_constructor_name,
+                                   number_of_arguments);
+  if (constructor.IsError()) {
+    Exceptions::PropagateError(Error::Cast(constructor));
+    UNREACHABLE();
+  }
+  ASSERT(constructor.IsFunction());
+
+  Object& result =
+      Object::Handle(DartEntry::InvokeConstructor(klass,
+                                                  Function::Cast(constructor),
+                                                  positional_args));
+  if (result.IsError()) {
+    Error& mirrored_error =
+        Error::Handle(CreateMirroredError(Error::Cast(result)));
+    Exceptions::PropagateError(mirrored_error);
+    UNREACHABLE();
+  }
+  // Factories may return null.
+  ASSERT(result.IsInstance() || result.IsNull());
+  return result.raw();
 }
 
+DEFINE_NATIVE_ENTRY(LibraryMirror_invoke, 4) {
+  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();
+
+
+  Function& function = Function::Handle();
+  function = library.LookupFunctionAllowPrivate(function_name);
+
+  if (function.IsNull()) {
+    const String& message = String::Handle(
+      String::NewFormatted("%s: did not find top-level function '%s'.",
+                           "LibraryMirror_invoke",
+                           function_name.ToCString()));
+    Error& error = Error::Handle(ApiError::New(message));
+    error = CreateMirroredError(error);
+    Exceptions::PropagateError(error);
+    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()));
+    Error& error = Error::Handle(ApiError::New(message));
+    error = CreateMirroredError(error);
+    Exceptions::PropagateError(error);
+    UNREACHABLE();
+  }
+
+  Object& result = Object::Handle(DartEntry::InvokeFunction(function,
+                                                            positional_args));
+  if (result.IsError()) {
+    Error& mirrored_error =
+        Error::Handle(CreateMirroredError(Error::Cast(result)));
+    Exceptions::PropagateError(mirrored_error);
+    UNREACHABLE();
+  }
+  return result.raw();
+}
+
+
+DEFINE_NATIVE_ENTRY(LibraryMirror_invokeGetter, 3) {
+  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));
+
+  // 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.
+  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 =
+        String::Handle(Field::GetterName(getter_name));
+    getter = library.LookupFunctionAllowPrivate(internal_getter_name);
+  } else if (FieldIsUninitialized(field)) {
+    // A field was found.  Check for a getter in the field's owner classs.
+    const Class& klass = Class::Handle(field.owner());
+    const String& internal_getter_name =
+        String::Handle(Field::GetterName(getter_name));
+    getter = klass.LookupStaticFunctionAllowPrivate(internal_getter_name);
+  }
+
+  if (!getter.IsNull()) {
+    // Invoke the getter and return the result.
+    Object& result = Object::Handle(
+        DartEntry::InvokeFunction(getter, Object::empty_array()));
+    if (result.IsError()) {
+      Error& mirrored_error =
+          Error::Handle(CreateMirroredError(Error::Cast(result)));
+      Exceptions::PropagateError(mirrored_error);
+      UNREACHABLE();
+    }
+    return result.raw();
+  } else if (!field.IsNull()) {
+      return field.value();
+  } else {
+    const String& message = String::Handle(
+        String::NewFormatted("%s: did not find top-level variable '%s'.",
+                             "LibraryMirror_invokeGetter",
+                             getter_name.ToCString()));
+      Error& error = Error::Handle(ApiError::New(message));
+      error = CreateMirroredError(error);
+      Exceptions::PropagateError(error);
+      UNREACHABLE();
+      return Instance::null();
+  }
+}
+
+
+DEFINE_NATIVE_ENTRY(LibraryMirror_invokeSetter, 4) {
+  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));
+
+  // 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.
+  Field& field = Field::Handle(library.LookupFieldAllowPrivate(setter_name));
+
+  if (field.IsNull()) {
+    const String& internal_setter_name =
+        String::Handle(Field::SetterName(setter_name));
+    const Function& setter = Function::Handle(
+        library.LookupFunctionAllowPrivate(internal_setter_name));
+
+    if (setter.IsNull()) {
+      const String& message = String::Handle(
+        String::NewFormatted("%s: did not find top-level variable '%s'.",
+                             "LibraryMirror_invokeSetter",
+                             setter_name.ToCString()));
+      Error& error = Error::Handle(ApiError::New(message));
+      error = CreateMirroredError(error);
+      Exceptions::PropagateError(error);
+      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));
+    if (result.IsError()) {
+      Error& mirrored_error =
+          Error::Handle(CreateMirroredError(Error::Cast(result)));
+      Exceptions::PropagateError(mirrored_error);
+      UNREACHABLE();
+    }
+    return result.raw();
+  }
+
+  if (field.is_final()) {
+    const String& message = String::Handle(
+      String::NewFormatted("%s: cannot set final top-level variable '%s'.",
+                           "LibraryMirror_invokeSetter",
+                           setter_name.ToCString()));
+    Error& error = Error::Handle(ApiError::New(message));
+    error = CreateMirroredError(error);
+    Exceptions::PropagateError(error);
+    UNREACHABLE();
+  }
+
+  field.set_value(value);
+  return value.raw();
+}
+
+
 DEFINE_NATIVE_ENTRY(MethodMirror_name, 1) {
   const MirrorReference& func_ref =
       MirrorReference::CheckedHandle(arguments->NativeArgAt(0));