Implement method and variable reflection in dart:mirrors.

runtime/vm/dart_api_impl.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 "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/dart.h"
@@ skipping 16 matching lines @@
 #include "vm/timer.h"
 #include "vm/unicode.h"
 #include "vm/verifier.h"
 
 namespace dart {
 
 DECLARE_FLAG(bool, print_class_table);
 
 ThreadLocalKey Api::api_native_key_ = Thread::kUnsetThreadLocalKey;
 
+
 const char* CanonicalFunction(const char* func) {
   if (strncmp(func, "dart::", 6) == 0) {
     return func + 6;
   } else {
     return func;
   }
 }
 
+
 #define RETURN_TYPE_ERROR(isolate, dart_handle, type)                          \
   do {                                                                         \
     const Object& tmp =                                                        \
         Object::Handle(isolate, Api::UnwrapHandle((dart_handle)));             \
     if (tmp.IsNull()) {                                                        \
       return Api::NewError("%s expects argument '%s' to be non-null.",         \
                            CURRENT_FUNC, #dart_handle);                        \
     } else if (tmp.IsError()) {                                                \
       return dart_handle;                                                      \
     } else {                                                                   \
       return Api::NewError("%s expects argument '%s' to be of type %s.",       \
                            CURRENT_FUNC, #dart_handle, #type);                 \
     }                                                                          \
   } while (0)
 
 
+#define RETURN_NULL_ERROR(parameter)                                           \
+  return Api::NewError("%s expects argument '%s' to be non-null.",             \
+                       CURRENT_FUNC, #parameter);
+
+
+// Takes a vm internal name and makes it suitable for external user.
+//
+// Examples:
+//
+// Internal getter and setter prefices are removed:
+//
+//   get:foo -> foo
+//   set:foo -> foo
+//
+// Private name mangling is removed, possibly twice:
+//
+//   _ReceivePortImpl@6be832b -> _ReceivePortImpl
+//   _ReceivePortImpl@6be832b._internal@6be832b -> +ReceivePortImpl._internal
+//
+// The trailing . on the default constructor name is dropped:
+//
+//   List. -> List
+//
+// And so forth:
+//
+//   get:foo@6be832b -> foo
+//   _MyClass@6b3832b. -> _MyClass
+//   _MyClass@6b3832b.named -> _MyClass.named
+//
+static RawString* IdentifierPrettyName(Isolate* isolate, const String& name) {
+  intptr_t len = name.Length();
+  intptr_t start = 0;
+  intptr_t at_pos = len;   // Position of '@' in the name.
+  intptr_t dot_pos = len;  // Position of '.' in the name.
+
+  for (int i = 0; i < name.Length(); i++) {
+    if (name.CharAt(i) == ':') {
+      ASSERT(start == 0);
+      start = i + 1;
+    } else if (name.CharAt(i) == '@') {
+      ASSERT(at_pos == len);
+      at_pos = i;
+    } else if (name.CharAt(i) == '.') {
+      dot_pos = i;
+      break;
+    }
+  }
+  intptr_t limit = (at_pos < dot_pos ? at_pos : dot_pos);
+  if (start == 0 && limit == len) {
+    // This name is fine as it is.
+    return name.raw();
+  }
+
+  String& result = String::Handle(isolate);
+  result = String::SubString(name, start, (limit - start));
+
+  // Look for a second '@' now to correctly handle names like
+  // "_ReceivePortImpl@6be832b._internal@6be832b".
+  at_pos = len;
+  for (int i = dot_pos; i < name.Length(); i++) {
+    if (name.CharAt(i) == '@') {
+      ASSERT(at_pos == len);
+      at_pos = i;
+    }
+  }
+
+  intptr_t suffix_len = at_pos - dot_pos;
+  if (suffix_len <= 1) {
+    // The constructor name is of length 0 or 1.  That means that
+    // either this isn't a constructor or that this is an unnamed
+    // constructor.  In either case, we're done.
+    return result.raw();
+  }
+
+  const String& suffix =
+      String::Handle(isolate, String::SubString(name, dot_pos, suffix_len));
+  return String::Concat(result, suffix);
+}
+
+
 // Return error if isolate is in an inconsistent state.
 // Return NULL when no error condition exists.
 //
 // TODO(turnidge): Make this function return an error handle directly
 // rather than returning an error string.  The current behavior can
 // cause compilation errors to appear to be api errors.
 const char* CheckIsolateState(Isolate* isolate, bool generating_snapshot) {
   bool success = true;
   if (!ClassFinalizer::AllClassesFinalized()) {
     success = (generating_snapshot) ?
@@ skipping 30 matching lines @@
   ApiLocalScope* scope = state->top_scope();
   ASSERT(scope != NULL);
   LocalHandles* local_handles = scope->local_handles();
   ASSERT(local_handles != NULL);
   LocalHandle* ref = local_handles->AllocateHandle();
   ref->set_raw(raw);
   return reinterpret_cast<Dart_Handle>(ref);
 }
 
 RawObject* Api::UnwrapHandle(Dart_Handle object) {
-#ifdef DEBUG
+#if defined(DEBUG)
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   ASSERT(state->IsValidPrologueWeakPersistentHandle(object) ||
          state->IsValidWeakPersistentHandle(object) ||
          state->IsValidPersistentHandle(object) ||
          state->IsValidLocalHandle(object));
   ASSERT(FinalizablePersistentHandle::raw_offset() == 0 &&
          PersistentHandle::raw_offset() == 0 &&
@@ skipping 446 matching lines @@
 
 DART_EXPORT Dart_Handle Dart_NewWeakReferenceSet(Dart_Handle* keys,
                                                  intptr_t num_keys,
                                                  Dart_Handle* values,
                                                  intptr_t num_values) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   if (keys == NULL) {
-    return Api::NewError("%s expects argument 'keys' to be non-null.",
-                         CURRENT_FUNC);
+    RETURN_NULL_ERROR(keys);
   }
   if (num_keys <= 0) {
     return Api::NewError(
         "%s expects argument 'num_keys' to be greater than 0.",
         CURRENT_FUNC);
   }
   if (values == NULL) {
-    return Api::NewError("%s expects argument 'values' to be non-null.",
-                         CURRENT_FUNC);
+    RETURN_NULL_ERROR(values);
   }
   if (num_values <= 0) {
     return Api::NewError(
         "%s expects argument 'num_values' to be greater than 0.",
         CURRENT_FUNC);
   }
 
   WeakReference* reference = new WeakReference(keys, num_keys,
                                                values, num_values);
   state->DelayWeakReference(reference);
@@ skipping 64 matching lines @@
   callbacks.Remove(callback);
   return Api::Success(isolate);
 }
 
 
 DART_EXPORT Dart_Handle Dart_HeapProfile(Dart_HeapProfileWriteCallback callback,
                                          void* stream) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   if (callback == NULL) {
-    return Api::NewError("%s expects argument 'callback' to be non-null.",
-                         CURRENT_FUNC);
+    RETURN_NULL_ERROR(callback);
   }
   isolate->heap()->Profile(callback, stream);
   return Api::Success(isolate);
 }
 
 // --- Initialization and Globals ---
 
 
 DART_EXPORT bool Dart_Initialize(Dart_IsolateCreateCallback create,
                                  Dart_IsolateInterruptCallback interrupt,
@@ skipping 122 matching lines @@
   return reinterpret_cast<uint8_t*>(new_ptr);
 }
 
 
 DART_EXPORT Dart_Handle Dart_CreateSnapshot(uint8_t** buffer,
                                             intptr_t* size) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   TIMERSCOPE(time_creating_snapshot);
   if (buffer == NULL) {
-    return Api::NewError("%s expects argument 'buffer' to be non-null.",
-                         CURRENT_FUNC);
+    RETURN_NULL_ERROR(buffer);
   }
   if (size == NULL) {
-    return Api::NewError("%s expects argument 'size' to be non-null.",
-                         CURRENT_FUNC);
+    RETURN_NULL_ERROR(size);
   }
   const char* msg = CheckIsolateState(isolate,
                                       ClassFinalizer::kGeneratingSnapshot);
   if (msg != NULL) {
     return Api::NewError(msg);
   }
   // Since this is only a snapshot the root library should not be set.
   isolate->object_store()->set_root_library(Library::Handle(isolate));
   SnapshotWriter writer(Snapshot::kFull, buffer, ApiReallocate);
   writer.WriteFullSnapshot();
   *size = writer.BytesWritten();
   return Api::Success(isolate);
 }
 
 
 DART_EXPORT Dart_Handle Dart_CreateScriptSnapshot(uint8_t** buffer,
                                                   intptr_t* size) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   TIMERSCOPE(time_creating_snapshot);
   if (buffer == NULL) {
-    return Api::NewError("%s expects argument 'buffer' to be non-null.",
-                         CURRENT_FUNC);
+    RETURN_NULL_ERROR(buffer);
   }
   if (size == NULL) {
-    return Api::NewError("%s expects argument 'size' to be non-null.",
-                         CURRENT_FUNC);
+    RETURN_NULL_ERROR(size);
   }
   const char* msg = CheckIsolateState(isolate);
   if (msg != NULL) {
     return Api::NewError(msg);
   }
   Library& library =
       Library::Handle(isolate, isolate->object_store()->root_library());
   if (library.IsNull()) {
     return
         Api::NewError("%s expects the isolate to have a script loaded in it.",
@@ skipping 623 matching lines @@
   }
   *len = str_obj.Length();
   return Api::Success(isolate);
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewString(const char* str) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   if (str == NULL) {
-    return Api::NewError("%s expects argument 'str' to be non-null.",
-                         CURRENT_FUNC);
+    RETURN_NULL_ERROR(str);
   }
   if (!Utf8::IsValid(str)) {
     return Api::NewError("%s expects argument 'str' to be valid UTF-8.",
                          CURRENT_FUNC);
   }
   return Api::NewHandle(isolate, String::New(str));
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewString8(const uint8_t* codepoints,
@@ skipping 32 matching lines @@
   const String& str = Api::UnwrapStringHandle(isolate, object);
   if (str.IsNull()) {
     RETURN_TYPE_ERROR(isolate, object, String);
   }
   if (!str.IsExternal()) {
     return
         Api::NewError("%s expects argument 'object' to be an external String.",
                       CURRENT_FUNC);
   }
   if (peer == NULL) {
-    return Api::NewError("%s expects argument 'peer' to be non-null.",
-                         CURRENT_FUNC);
+    RETURN_NULL_ERROR(peer);
   }
   *peer = str.GetPeer();
   return Api::Success(isolate);
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewExternalString8(const uint8_t* codepoints,
                                                 intptr_t length,
                                                 void* peer,
                                                 Dart_PeerFinalizer callback) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   if (codepoints == NULL && length != 0) {
-    return Api::NewError("%s expects argument 'codepoints' to be non-null.",
-                         CURRENT_FUNC);
+    RETURN_NULL_ERROR(codepoints);
   }
   if (length < 0) {
     return Api::NewError("%s expects argument 'length' to be greater than 0.",
                          CURRENT_FUNC);
   }
   return Api::NewHandle(
       isolate, String::NewExternal(codepoints, length, peer, callback));
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewExternalString16(const uint16_t* codepoints,
                                                  intptr_t length,
                                                  void* peer,
                                                  Dart_PeerFinalizer callback) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   if (codepoints == NULL && length != 0) {
-    return Api::NewError("%s expects argument 'codepoints' to be non-null.",
-                         CURRENT_FUNC);
+    RETURN_NULL_ERROR(codepoints);
   }
   if (length < 0) {
     return Api::NewError("%s expects argument 'length' to be greater than 0.",
                          CURRENT_FUNC);
   }
   return Api::NewHandle(
       isolate, String::NewExternal(codepoints, length, peer, callback));
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewExternalString32(const uint32_t* codepoints,
                                                  intptr_t length,
                                                  void* peer,
                                                  Dart_PeerFinalizer callback) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   if (codepoints == NULL && length != 0) {
-    return Api::NewError("%s expects argument 'codepoints' to be non-null.",
-                         CURRENT_FUNC);
+    RETURN_NULL_ERROR(codepoints);
   }
   if (length < 0) {
     return Api::NewError("%s expects argument 'length' to be greater than 0.",
                          CURRENT_FUNC);
   }
   return Api::NewHandle(
       isolate, String::NewExternal(codepoints, length, peer, callback));
 }
 
 
@@ skipping 82 matching lines @@
 DART_EXPORT Dart_Handle Dart_StringToBytes(Dart_Handle object,
                                            const uint8_t** bytes,
                                            intptr_t *length) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const String& str = Api::UnwrapStringHandle(isolate, object);
   if (str.IsNull()) {
     RETURN_TYPE_ERROR(isolate, object, String);
   }
   if (bytes == NULL) {
-    return Api::NewError("%s expects argument 'bytes' to be non-null.",
-                         CURRENT_FUNC);
+    RETURN_NULL_ERROR(bytes);
   }
   if (length == NULL) {
-    return Api::NewError("%s expects argument 'length' to be non-null.",
-                        CURRENT_FUNC);
+    RETURN_NULL_ERROR(length);
   }
   const char* cstring = str.ToCString();
   *length = Utf8::Length(str);
   uint8_t* result = reinterpret_cast<uint8_t*>(Api::Allocate(isolate, *length));
   if (result == NULL) {
     return Api::NewError("Unable to allocate memory");
   }
   memmove(result, cstring, *length);
   *bytes = result;
   return Api::Success(isolate);
@@ skipping 379 matching lines @@
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewExternalByteArray(uint8_t* data,
                                                   intptr_t length,
                                                   void* peer,
                                                   Dart_PeerFinalizer callback) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   if (data == NULL && length != 0) {
-    return Api::NewError("%s expects argument 'data' to be non-null.",
-                         CURRENT_FUNC);
+    RETURN_NULL_ERROR(data);
   }
   if (length < 0) {
     return Api::NewError("%s expects argument 'length' to be greater than 0.",
                          CURRENT_FUNC);
   }
   return Api::NewHandle(
       isolate, ExternalUint8Array::New(data, length, peer, callback));
 }
 
 
 DART_EXPORT Dart_Handle Dart_ExternalByteArrayGetPeer(Dart_Handle object,
                                                       void** peer) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const ExternalUint8Array& array =
       Api::UnwrapExternalUint8ArrayHandle(isolate, object);
   if (array.IsNull()) {
     RETURN_TYPE_ERROR(isolate, object, ExternalUint8Array);
   }
   if (peer == NULL) {
-    return Api::NewError("%s expects argument 'peer' to be non-null.",
-                         CURRENT_FUNC);
+    RETURN_NULL_ERROR(peer);
   }
   *peer = array.GetPeer();
   return Api::Success(isolate);
 }
 
 
 template<typename T>
 Dart_Handle ByteArrayGetAt(T* value, Dart_Handle array, intptr_t offset) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
@@ skipping 257 matching lines @@
 
 
 DART_EXPORT Dart_Handle Dart_ClassName(Dart_Handle clazz) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Class& cls = Class::Handle(
       isolate, Api::UnwrapClassHandle(isolate, clazz).raw());
   if (cls.IsNull()) {
     RETURN_TYPE_ERROR(isolate, clazz, Class);
   }
-  return Api::NewHandle(isolate, cls.Name());
+  const String& cls_name = String::Handle(isolate, cls.Name());
+  return Api::NewHandle(isolate, IdentifierPrettyName(isolate, cls_name));
 }
 
 
 DART_EXPORT Dart_Handle Dart_ClassGetLibrary(Dart_Handle clazz) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Class& cls = Class::Handle(
       isolate, Api::UnwrapClassHandle(isolate, clazz).raw());
   if (cls.IsNull()) {
     RETURN_TYPE_ERROR(isolate, clazz, Class);
   }
+
+#if defined(DEBUG)
+  const Library& lib = Library::Handle(cls.library());
+  if (lib.IsNull()) {
+    ASSERT(cls.IsDynamicClass() || cls.IsVoidClass());
+  }
+#endif
+
   return Api::NewHandle(isolate, cls.library());
 }
 
 
 DART_EXPORT Dart_Handle Dart_ClassGetDefault(Dart_Handle clazz) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Class& cls = Class::Handle(
       isolate, Api::UnwrapClassHandle(isolate, clazz).raw());
   if (cls.IsNull()) {
@@ skipping 58 matching lines @@
   if (interface_type.HasResolvedTypeClass()) {
     return Api::NewHandle(isolate, interface_type.type_class());
   }
   const String& type_name =
       String::Handle(isolate, interface_type.TypeClassName());
   return Api::NewError("%s: internal error: found unresolved type class '%s'.",
                        CURRENT_FUNC, type_name.ToCString());
 }
 
 
+// --- Function and Variable Reflection ---
+
+
+// Outside of the vm, we expose setter names with a trailing '='.
+static bool HasExternalSetterSuffix(const String& name) {
+  return name.CharAt(name.Length() - 1) == '=';
+}
+
+
+static RawString* AddExternalSetterSuffix(const String& name) {
+  const String& equals = String::Handle(String::NewSymbol("="));
+  return String::Concat(name, equals);
+}
+
+
+static RawString* RemoveExternalSetterSuffix(const String& name) {
+  ASSERT(HasExternalSetterSuffix(name));
+  return String::SubString(name, 0, name.Length() - 1);
+}
+
+
+DART_EXPORT Dart_Handle Dart_GetFunctionNames(Dart_Handle target) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(target));
+  if (obj.IsError()) {
+    return target;
+  }
+
+  const GrowableObjectArray& names =
+      GrowableObjectArray::Handle(isolate, GrowableObjectArray::New());
+  Function& func = Function::Handle();
+  String& name = String::Handle();
+
+  if (obj.IsClass()) {
+    const Class& cls = Class::Cast(obj);
+    const Array& func_array = Array::Handle(cls.functions());
+
+    // Some special types like 'Dynamic' have a null functions list.
+    if (!func_array.IsNull()) {
+      for (intptr_t i = 0; i < func_array.Length(); ++i) {
+        func ^= func_array.At(i);
+
+        // Skip implicit getters and setters.
+        if (func.kind() == RawFunction::kImplicitGetter ||
+            func.kind() == RawFunction::kImplicitSetter ||
+            func.kind() == RawFunction::kConstImplicitGetter) {
+          continue;
+        }
+
+        name = func.name();
+        bool is_setter = Field::IsSetterName(name);
+        name = IdentifierPrettyName(isolate, name);
+
+        if (is_setter) {
+          name = AddExternalSetterSuffix(name);
+        }
+        names.Add(name);
+      }
+    }
+  } else if (obj.IsLibrary()) {
+    const Library& lib = Library::Cast(obj);
+    DictionaryIterator it(lib);
+    Object& obj = Object::Handle();
+    while (it.HasNext()) {
+      obj = it.GetNext();
+      if (obj.IsFunction()) {
+        func ^= obj.raw();
+        name = func.name();
+        bool is_setter = Field::IsSetterName(name);
+        name = IdentifierPrettyName(isolate, name);
+        if (is_setter) {
+          name = AddExternalSetterSuffix(name);
+        }
+        names.Add(name);
+      }
+    }
+  } else {
+    return Api::NewError(
+        "%s expects argument 'target' to be a class or library.",
+        CURRENT_FUNC);
+  }
+  return Api::NewHandle(isolate, Array::MakeArray(names));
+}
+
+
+DART_EXPORT Dart_Handle Dart_LookupFunction(Dart_Handle target,
+                                            Dart_Handle function_name) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(target));
+  if (obj.IsError()) {
+    return target;
+  }
+  const String& func_name = Api::UnwrapStringHandle(isolate, function_name);
+  if (func_name.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, function_name, String);
+  }
+
+  Function& func = Function::Handle(isolate);
+  String& tmp_name = String::Handle(isolate);
+  if (obj.IsClass()) {
+    const Class& cls = Class::Cast(obj);
+
+    // Case 1.  Lookup the unmodified function name.
+    func = cls.LookupFunction(func_name);
+
+    // Case 2.  Lookup the function without the external setter suffix
+    // '='.  Make sure to do this check after the regular lookup, so
+    // that we don't interfere with operator lookups (like ==).
+    if (func.IsNull() && HasExternalSetterSuffix(func_name)) {
+      tmp_name = RemoveExternalSetterSuffix(func_name);
+      tmp_name = Field::SetterName(tmp_name);
+      func = cls.LookupFunction(tmp_name);
+    }
+
+    // Case 3.  Lookup the funciton with the getter prefix prepended.
+    if (func.IsNull()) {
+      tmp_name = Field::GetterName(func_name);
+      func = cls.LookupFunction(tmp_name);
+    }
+
+    // Case 4.  Lookup the function with a . appended to find the
+    // unnamed constructor.
+    if (func.IsNull()) {
+      const String& dot = String::Handle(String::NewSymbol("."));
+      tmp_name = String::Concat(func_name, dot);
+      func = cls.LookupFunction(tmp_name);
+    }
+  } else if (obj.IsLibrary()) {
+    const Library& lib = Library::Cast(obj);
+
+    // Case 1.  Lookup the unmodified function name.
+    func = lib.LookupFunctionAllowPrivate(func_name);
+
+    // Case 2.  Lookup the function without the external setter suffix
+    // '='.  Make sure to do this check after the regular lookup, so
+    // that we don't interfere with operator lookups (like ==).
+    if (func.IsNull() && HasExternalSetterSuffix(func_name)) {
+      tmp_name = RemoveExternalSetterSuffix(func_name);
+      tmp_name = Field::SetterName(tmp_name);
+      func = lib.LookupFunctionAllowPrivate(tmp_name);
+    }
+
+    // Case 3.  Lookup the funciton with the getter prefix prepended.
+    if (func.IsNull()) {
+      tmp_name = Field::GetterName(func_name);
+      func = lib.LookupFunctionAllowPrivate(tmp_name);
+    }
+  } else {
+    return Api::NewError(
+        "%s expects argument 'target' to be a class or library.",
+        CURRENT_FUNC);
+  }
+
+#if defined(DEBUG)
+  if (!func.IsNull()) {
+    // We only provide access to a subset of function kinds.
+    RawFunction::Kind func_kind = func.kind();
+    ASSERT(func_kind == RawFunction::kFunction ||
+           func_kind == RawFunction::kGetterFunction ||
+           func_kind == RawFunction::kSetterFunction ||
+           func_kind == RawFunction::kConstructor ||
+           func_kind == RawFunction::kAbstract);
+  }
+#endif
+  return Api::NewHandle(isolate, func.raw());
+}
+
+
+DART_EXPORT bool Dart_IsFunction(Dart_Handle handle) {
+  return Api::ClassId(handle) == kFunction;
+}
+
+
+DART_EXPORT Dart_Handle Dart_FunctionName(Dart_Handle function) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  const Function& func = Api::UnwrapFunctionHandle(isolate, function);
+  if (func.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, function, Function);
+  }
+  String& func_name = String::Handle(isolate);
+  func_name = func.name();
+  bool is_setter = Field::IsSetterName(func_name);
+  func_name = IdentifierPrettyName(isolate, func_name);
+  if (is_setter) {
+    func_name = AddExternalSetterSuffix(func_name);
+  }
+  return Api::NewHandle(isolate, func_name.raw());
+}
+
+
+DART_EXPORT Dart_Handle Dart_FunctionIsAbstract(Dart_Handle function,
+                                                bool* is_abstract) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  if (is_abstract == NULL) {
+    RETURN_NULL_ERROR(is_abstract);
+  }
+  const Function& func = Api::UnwrapFunctionHandle(isolate, function);
+  if (func.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, function, Function);
+  }
+  *is_abstract = (func.kind() == RawFunction::kAbstract);
+  return Api::Success(isolate);
+}
+
+
+DART_EXPORT Dart_Handle Dart_FunctionIsStatic(Dart_Handle function,
+                                              bool* is_static) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  if (is_static == NULL) {
+    RETURN_NULL_ERROR(is_static);
+  }
+  const Function& func = Api::UnwrapFunctionHandle(isolate, function);
+  if (func.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, function, Function);
+  }
+  *is_static = func.is_static();
+  return Api::Success(isolate);
+}
+
+
+DART_EXPORT Dart_Handle Dart_FunctionIsConstructor(Dart_Handle function,
+                                                   bool* is_constructor) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  if (is_constructor == NULL) {
+    RETURN_NULL_ERROR(is_constructor);
+  }
+  const Function& func = Api::UnwrapFunctionHandle(isolate, function);
+  if (func.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, function, Function);
+  }
+  *is_constructor = func.kind() == RawFunction::kConstructor;
+  return Api::Success(isolate);
+}
+
+
+DART_EXPORT Dart_Handle Dart_FunctionIsGetter(Dart_Handle function,
+                                              bool* is_getter) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  if (is_getter == NULL) {
+    RETURN_NULL_ERROR(is_getter);
+  }
+  const Function& func = Api::UnwrapFunctionHandle(isolate, function);
+  if (func.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, function, Function);
+  }
+  // TODO(turnidge): It would be nice if I could just use func.kind()
+  // to check for a getter function here, but unfortunately the only
+  // way to distinguish abstract getter functions is to use the name
+  // itself.  Consider adding a RawFunction::kAbstractGetter type.
+  const String& func_name = String::Handle(isolate, func.name());
+  *is_getter = Field::IsGetterName(func_name);
+
+  return Api::Success(isolate);
+}
+
+
+DART_EXPORT Dart_Handle Dart_FunctionIsSetter(Dart_Handle function,
+                                              bool* is_setter) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  if (is_setter == NULL) {
+    RETURN_NULL_ERROR(is_setter);
+  }
+  const Function& func = Api::UnwrapFunctionHandle(isolate, function);
+  if (func.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, function, Function);
+  }
+  // TODO(turnidge): It would be nice if I could just use func.kind()
+  // to check for a setter function here, but unfortunately the only
+  // way to distinguish abstract setter functions is to use the name
+  // itself.  Consider adding a RawFunction::kAbstractSetter type.
+  const String& func_name = String::Handle(isolate, func.name());
+  *is_setter = Field::IsSetterName(func_name);
+
+  return Api::Success(isolate);
+}
+
+
+DART_EXPORT Dart_Handle Dart_GetVariableNames(Dart_Handle target) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(target));
+  if (obj.IsError()) {
+    return target;
+  }
+
+  const GrowableObjectArray& names =
+      GrowableObjectArray::Handle(isolate, GrowableObjectArray::New());
+  Field& field = Field::Handle(isolate);
+  String& name = String::Handle(isolate);
+
+  if (obj.IsClass()) {
+    const Class& cls = Class::Cast(obj);
+    const Array& field_array = Array::Handle(cls.fields());
+
+    // Some special types like 'Dynamic' have a null fields list.
+    //
+    // TODO(turnidge): Fix 'Dynamic' so that it does not have a null
+    // fields list.  This will have to wait until the empty array is
+    // allocated in the vm isolate.
+    if (!field_array.IsNull()) {
+      for (intptr_t i = 0; i < field_array.Length(); ++i) {
+        field ^= field_array.At(i);
+        name = field.name();
+        name = IdentifierPrettyName(isolate, name);
+        names.Add(name);
+      }
+    }
+  } else if (obj.IsLibrary()) {
+    const Library& lib = Library::Cast(obj);
+    DictionaryIterator it(lib);
+    Object& obj = Object::Handle(isolate);
+    while (it.HasNext()) {
+      obj = it.GetNext();
+      if (obj.IsField()) {
+        field ^= obj.raw();
+        name = field.name();
+        name = IdentifierPrettyName(isolate, name);
+        names.Add(name);
+      }
+    }
+  } else {
+    return Api::NewError(
+        "%s expects argument 'target' to be a class or library.",
+        CURRENT_FUNC);
+  }
+  return Api::NewHandle(isolate, Array::MakeArray(names));
+}
+
+
+DART_EXPORT Dart_Handle Dart_LookupVariable(Dart_Handle target,
+                                            Dart_Handle variable_name) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(target));
+  if (obj.IsError()) {
+    return target;
+  }
+  const String& var_name = Api::UnwrapStringHandle(isolate, variable_name);
+  if (var_name.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, variable_name, String);
+  }
+  if (obj.IsClass()) {
+    const Class& cls = Class::Cast(obj);
+    return Api::NewHandle(isolate, cls.LookupField(var_name));
+  }
+  if (obj.IsLibrary()) {
+    const Library& lib = Library::Cast(obj);
+    return Api::NewHandle(isolate, lib.LookupFieldAllowPrivate(var_name));
+  }
+  return Api::NewError(
+      "%s expects argument 'target' to be a class or library.",
+      CURRENT_FUNC);
+}
+
+
+DART_EXPORT bool Dart_IsVariable(Dart_Handle handle) {
+  return Api::ClassId(handle) == kField;
+}
+
+
+DART_EXPORT Dart_Handle Dart_VariableName(Dart_Handle variable) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  const Field& var = Api::UnwrapFieldHandle(isolate, variable);
+  if (var.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, variable, Field);
+  }
+  const String& var_name = String::Handle(var.name());
+  return Api::NewHandle(isolate, IdentifierPrettyName(isolate, var_name));
+}
+
+
+DART_EXPORT Dart_Handle Dart_VariableIsStatic(Dart_Handle variable,
+                                              bool* is_static) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  if (is_static == NULL) {
+    RETURN_NULL_ERROR(is_static);
+  }
+  const Field& var = Api::UnwrapFieldHandle(isolate, variable);
+  if (var.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, variable, Field);
+  }
+  *is_static = var.is_static();
+  return Api::Success(isolate);
+}
+
+
+DART_EXPORT Dart_Handle Dart_VariableIsFinal(Dart_Handle variable,
+                                             bool* is_final) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  if (is_final == NULL) {
+    RETURN_NULL_ERROR(is_final);
+  }
+  const Field& var = Api::UnwrapFieldHandle(isolate, variable);
+  if (var.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, variable, Field);
+  }
+  *is_final = var.is_final();
+  return Api::Success(isolate);
+}
+
 // --- Constructors, Methods, and Fields ---
 
 
 static RawObject* ResolveConstructor(const char* current_func,
                                      const Class& cls,
                                      const String& class_name,
                                      const String& dotted_name,
                                      int num_args) {
   // The constructor must be present in the interface.
   String& constr_name = String::Handle(String::Concat(class_name, dotted_name));
@@ skipping 816 matching lines @@
                 &result);
   return result;
 }
 
 
 DART_EXPORT Dart_Handle Dart_LoadScriptFromSnapshot(const uint8_t* buffer) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   TIMERSCOPE(time_script_loading);
   if (buffer == NULL) {
-    return Api::NewError("%s expects argument 'buffer' to be non-null.",
-                         CURRENT_FUNC);
+    RETURN_NULL_ERROR(buffer);
   }
   const Snapshot* snapshot = Snapshot::SetupFromBuffer(buffer);
   if (!snapshot->IsScriptSnapshot()) {
     return Api::NewError("%s expects parameter 'buffer' to be a script type"
                          " snapshot", CURRENT_FUNC);
   }
   Library& library =
       Library::Handle(isolate, isolate->object_store()->root_library());
   if (!library.IsNull()) {
     const String& library_url = String::Handle(isolate, library.url());
@@ skipping 109 matching lines @@
     RETURN_TYPE_ERROR(isolate, library, Library);
   }
 
   const GrowableObjectArray& names =
       GrowableObjectArray::Handle(isolate, GrowableObjectArray::New());
   ClassDictionaryIterator it(lib);
   Class& cls = Class::Handle();
   String& name = String::Handle();
   while (it.HasNext()) {
     cls = it.GetNextClass();
-    name = cls.Name();
-    names.Add(name);
+    // For now we suppress the signature classes of closures.
+    //
+    // TODO(turnidge): Add this to the unit test.
+    const Function& signature_func = Function::Handle(cls.signature_function());
+    if (signature_func.IsNull()) {
+      name = cls.Name();
+      name = IdentifierPrettyName(isolate, name);
+      names.Add(name);
+    }
   }
   return Api::NewHandle(isolate, Array::MakeArray(names));
 }
 
 
 DART_EXPORT Dart_Handle Dart_LookupLibrary(Dart_Handle url) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const String& url_str = Api::UnwrapStringHandle(isolate, url);
   if (url_str.IsNull()) {
@@ skipping 142 matching lines @@
     *buffer_size = 0;
   }
 }
 
 
 DART_EXPORT void Dart_InitFlowGraphPrinting(FileWriterFunction function) {
   Dart::set_flow_graph_writer(function);
 }
 
 }  // namespace dart