Convert implementation in mirrors.cc to use Dart_GetType instead of Dart_GetClass.

runtime/vm/mirrors_api_impl.cc

 // Copyright (c) 2013, 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_mirrors_api.h"
 
 #include "platform/assert.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart.h"
 #include "vm/dart_api_impl.h"
@@ skipping 30 matching lines @@
     return Api::NewHandle(isolate, type.raw());
   } else {
     return Api::NewError("%s: unexpected type '%s' encountered.",
                          function_name, type.ToCString());
   }
 }
 
 
 // --- Classes and Interfaces Reflection ---
 
-DART_EXPORT Dart_Handle Dart_ClassName(Dart_Handle clazz) {
+DART_EXPORT Dart_Handle Dart_ClassName(Dart_Handle object) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
-  const Class& cls = Api::UnwrapClassHandle(isolate, clazz);
-  if (cls.IsNull()) {
-    RETURN_TYPE_ERROR(isolate, clazz, Class);
+  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
+  if (obj.IsType() || obj.IsClass()) {
+    const Class& cls = (obj.IsType()) ?
+        Class::Handle(Type::Cast(obj).type_class()) : Class::Cast(obj);
+    return Api::NewHandle(isolate, cls.UserVisibleName());
+  } else {
+    RETURN_TYPE_ERROR(isolate, object, Class/Type);
   }
-  return Api::NewHandle(isolate, cls.UserVisibleName());
 }
 
 
-DART_EXPORT Dart_Handle Dart_ClassGetLibrary(Dart_Handle clazz) {
+DART_EXPORT Dart_Handle Dart_ClassGetLibrary(Dart_Handle object) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
-  const Class& cls = Api::UnwrapClassHandle(isolate, clazz);
-  if (cls.IsNull()) {
-    RETURN_TYPE_ERROR(isolate, clazz, Class);
+  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
+  if (!obj.IsType() && !obj.IsClass()) {
+    RETURN_TYPE_ERROR(isolate, object, Class/Type);
   }
+  const Class& cls = (obj.IsType()) ?
+      Class::Handle(Type::Cast(obj).type_class()) : Class::Cast(obj);
 
 #if defined(DEBUG)
   const Library& lib = Library::Handle(cls.library());
   if (lib.IsNull()) {
     // ASSERT(cls.IsDynamicClass() || cls.IsVoidClass());
     if (!cls.IsDynamicClass() && !cls.IsVoidClass()) {
       fprintf(stderr, "NO LIBRARY: %s\n", cls.ToCString());
     }
   }
 #endif
 
   return Api::NewHandle(isolate, cls.library());
 }
 
 
-DART_EXPORT Dart_Handle Dart_ClassGetInterfaceCount(Dart_Handle clazz,
+DART_EXPORT Dart_Handle Dart_ClassGetInterfaceCount(Dart_Handle object,
                                                     intptr_t* count) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
-  const Class& cls = Api::UnwrapClassHandle(isolate, clazz);
-  if (cls.IsNull()) {
-    RETURN_TYPE_ERROR(isolate, clazz, Class);
+  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
+  if (!obj.IsType() && !obj.IsClass()) {
+    RETURN_TYPE_ERROR(isolate, object, Class/Type);
   }
-
+  const Class& cls = (obj.IsType()) ?
+      Class::Handle(Type::Cast(obj).type_class()) : Class::Cast(obj);
   const Array& interface_types = Array::Handle(isolate, cls.interfaces());
   if (interface_types.IsNull()) {
     *count = 0;
   } else {
     *count = interface_types.Length();
   }
   return Api::Success();
 }
 
 
-DART_EXPORT Dart_Handle Dart_ClassGetInterfaceAt(Dart_Handle clazz,
+DART_EXPORT Dart_Handle Dart_ClassGetInterfaceAt(Dart_Handle object,
                                                  intptr_t index) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
-  const Class& cls = Api::UnwrapClassHandle(isolate, clazz);
-  if (cls.IsNull()) {
-    RETURN_TYPE_ERROR(isolate, clazz, Class);
+  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
+  if (!obj.IsType() && !obj.IsClass()) {
+    RETURN_TYPE_ERROR(isolate, object, Class/Type);
   }
+  const Class& cls = (obj.IsType()) ?
+      Class::Handle(Type::Cast(obj).type_class()) : Class::Cast(obj);
 
   // Finalize all classes.
   Dart_Handle state = Api::CheckIsolateState(isolate);
   if (::Dart_IsError(state)) {
     return state;
   }
 
   const Array& interface_types = Array::Handle(isolate, cls.interfaces());
   if (index < 0 || index >= interface_types.Length()) {
     return Api::NewError("%s: argument 'index' out of bounds.", CURRENT_FUNC);
   }
   Type& interface_type = Type::Handle(isolate);
   interface_type ^= interface_types.At(index);
   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());
 }
 
 
-DART_EXPORT bool Dart_ClassIsTypedef(Dart_Handle clazz) {
+DART_EXPORT bool Dart_ClassIsTypedef(Dart_Handle object) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
-  const Class& cls = Api::UnwrapClassHandle(isolate, clazz);
-  if (cls.IsNull()) {
-    RETURN_TYPE_ERROR(isolate, clazz, Class);
+  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
+  if (!obj.IsType() && !obj.IsClass()) {
+    RETURN_TYPE_ERROR(isolate, object, Class/Type);
   }
+  const Class& cls = (obj.IsType()) ?
+      Class::Handle(Type::Cast(obj).type_class()) : Class::Cast(obj);
   // For now we represent typedefs as non-canonical signature classes.
   // I anticipate this may change if we make typedefs more general.
   return cls.IsSignatureClass() && !cls.IsCanonicalSignatureClass();
 }
 
 
-DART_EXPORT Dart_Handle Dart_ClassGetTypedefReferent(Dart_Handle clazz) {
+DART_EXPORT Dart_Handle Dart_ClassGetTypedefReferent(Dart_Handle object) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
-  const Class& cls = Api::UnwrapClassHandle(isolate, clazz);
-  if (cls.IsNull()) {
-    RETURN_TYPE_ERROR(isolate, clazz, Class);
+  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
+  if (!obj.IsType() && !obj.IsClass()) {
+    RETURN_TYPE_ERROR(isolate, object, Class/Type);
   }
-
+  const Class& cls = (obj.IsType()) ?
+      Class::Handle(Type::Cast(obj).type_class()) : Class::Cast(obj);
   if (!cls.IsSignatureClass() && !cls.IsCanonicalSignatureClass()) {
     const String& cls_name = String::Handle(cls.UserVisibleName());
     return Api::NewError("%s: class '%s' is not a typedef class. "
                          "See Dart_ClassIsTypedef.",
                          CURRENT_FUNC, cls_name.ToCString());
   }
 
   const Function& func = Function::Handle(isolate, cls.signature_function());
   return Api::NewHandle(isolate, func.signature_class());
 }
 
 
-DART_EXPORT bool Dart_ClassIsFunctionType(Dart_Handle clazz) {
+DART_EXPORT bool Dart_ClassIsFunctionType(Dart_Handle object) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
-  const Class& cls = Api::UnwrapClassHandle(isolate, clazz);
-  if (cls.IsNull()) {
-    RETURN_TYPE_ERROR(isolate, clazz, Class);
+  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
+  if (!obj.IsType() && !obj.IsClass()) {
+    RETURN_TYPE_ERROR(isolate, object, Class/Type);
   }
+  const Class& cls = (obj.IsType()) ?
+      Class::Handle(Type::Cast(obj).type_class()) : Class::Cast(obj);
   // A class represents a function type when it is a canonical
   // signature class.
   return cls.IsCanonicalSignatureClass();
 }
 
 
-DART_EXPORT Dart_Handle Dart_ClassGetFunctionTypeSignature(Dart_Handle clazz) {
+DART_EXPORT Dart_Handle Dart_ClassGetFunctionTypeSignature(Dart_Handle object) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
-  const Class& cls = Api::UnwrapClassHandle(isolate, clazz);
-  if (cls.IsNull()) {
-    RETURN_TYPE_ERROR(isolate, clazz, Class);
+  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
+  if (!obj.IsType() && !obj.IsClass()) {
+    RETURN_TYPE_ERROR(isolate, object, Class/Type);
   }
+  const Class& cls = (obj.IsType()) ?
+      Class::Handle(Type::Cast(obj).type_class()) : Class::Cast(obj);
   if (!cls.IsCanonicalSignatureClass()) {
     const String& cls_name = String::Handle(cls.UserVisibleName());
     return Api::NewError("%s: class '%s' is not a function-type class. "
                          "See Dart_ClassIsFunctionType.",
                          CURRENT_FUNC, cls_name.ToCString());
   }
   return Api::NewHandle(isolate, cls.signature_function());
 }
 
 
@@ skipping 17 matching lines @@
   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);
+  if (obj.IsType() || obj.IsClass()) {
+    // For backwards compatibility we allow class objects to be passed in
+    // for now. This needs to be removed once all code that uses class
+    // objects to invoke Dart_Invoke is removed.
+    const Class& cls = (obj.IsType()) ?
+        Class::Handle(Type::Cast(obj).type_class()) : Class::Cast(obj);
     const Error& error = Error::Handle(isolate, cls.EnsureIsFinalized(isolate));
     if (!error.IsNull()) {
       return Api::NewHandle(isolate, error.raw());
     }
     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);
@@ skipping 40 matching lines @@
   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);
+  if (obj.IsType() || obj.IsClass()) {
+    // For backwards compatibility we allow class objects to be passed in
+    // for now. This needs to be removed once all code that uses class
+    // objects to invoke Dart_Invoke is removed.
+    const Class& cls = (obj.IsType()) ?
+        Class::Handle(Type::Cast(obj).type_class()) : Class::Cast(obj);
 
     // Case 1.  Lookup the unmodified function name.
     func = cls.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);
@@ skipping 256 matching lines @@
   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);
+  if (obj.IsType() || obj.IsClass()) {
+    // For backwards compatibility we allow class objects to be passed in
+    // for now. This needs to be removed once all code that uses class
+    // objects to invoke Dart_Invoke is removed.
+    const Class& cls = (obj.IsType()) ?
+        Class::Handle(Type::Cast(obj).type_class()) : Class::Cast(obj);
     const Error& error = Error::Handle(isolate, cls.EnsureIsFinalized(isolate));
     if (!error.IsNull()) {
       return Api::NewHandle(isolate, error.raw());
     }
     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
@@ skipping 31 matching lines @@
   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);
+  if (obj.IsType() || obj.IsClass()) {
+    // For backwards compatibility we allow class objects to be passed in
+    // for now. This needs to be removed once all code that uses class
+    // objects to invoke Dart_Invoke is removed.
+    const Class& cls = (obj.IsType()) ?
+        Class::Handle(Type::Cast(obj).type_class()) : 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);
 }
@@ skipping 48 matching lines @@
   const Field& var = Api::UnwrapFieldHandle(isolate, variable);
   if (var.IsNull()) {
     RETURN_TYPE_ERROR(isolate, variable, Field);
   }
 
   const AbstractType& type = AbstractType::Handle(isolate, var.type());
   return TypeToHandle(isolate, "Dart_VariableType", type);
 }
 
 
-DART_EXPORT Dart_Handle Dart_GetTypeVariableNames(Dart_Handle clazz) {
+DART_EXPORT Dart_Handle Dart_GetTypeVariableNames(Dart_Handle object) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
-  const Class& cls = Api::UnwrapClassHandle(isolate, clazz);
-  if (cls.IsNull()) {
-    RETURN_TYPE_ERROR(isolate, clazz, Class);
+  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
+  if (!obj.IsType() && !obj.IsClass()) {
+    RETURN_TYPE_ERROR(isolate, object, Class/Type);
   }
-
+  const Class& cls = (obj.IsType()) ?
+      Class::Handle(Type::Cast(obj).type_class()) : Class::Cast(obj);
   const intptr_t num_type_params = cls.NumTypeParameters();
   const TypeArguments& type_params =
       TypeArguments::Handle(cls.type_parameters());
 
   const GrowableObjectArray& names =
       GrowableObjectArray::Handle(isolate, GrowableObjectArray::New());
   TypeParameter& type_param = TypeParameter::Handle(isolate);
   String& name = String::Handle(isolate);
   for (intptr_t i = 0; i < num_type_params; i++) {
     type_param ^= type_params.TypeAt(i);
     name = type_param.name();
     names.Add(name);
   }
   return Api::NewHandle(isolate, Array::MakeArray(names));
 }
 
 
 DART_EXPORT Dart_Handle Dart_LookupTypeVariable(
-    Dart_Handle clazz,
+    Dart_Handle object,
     Dart_Handle type_variable_name) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
-  const Class& cls = Api::UnwrapClassHandle(isolate, clazz);
-  if (cls.IsNull()) {
-    RETURN_TYPE_ERROR(isolate, clazz, Class);
+  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
+  if (!obj.IsType() && !obj.IsClass()) {
+    RETURN_TYPE_ERROR(isolate, object, Class/Type);
   }
+  const Class& cls = (obj.IsType()) ?
+      Class::Handle(Type::Cast(obj).type_class()) : Class::Cast(obj);
   const String& var_name = Api::UnwrapStringHandle(isolate, type_variable_name);
   if (var_name.IsNull()) {
     RETURN_TYPE_ERROR(isolate, type_variable_name, String);
   }
 
   const intptr_t num_type_params = cls.NumTypeParameters();
   const TypeArguments& type_params =
       TypeArguments::Handle(cls.type_parameters());
 
   TypeParameter& type_param = TypeParameter::Handle(isolate);
@@ skipping 130 matching lines @@
   } else if (obj.IsField()) {
     cls = Field::Cast(obj).origin();
   } else {
     return Api::NewHandle(isolate, Object::empty_array().raw());
   }
   const Library& lib = Library::Handle(cls.library());
   return Api::NewHandle(isolate, lib.GetMetadata(obj));
 }
 
 }  // namespace dart