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

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/bootstrap_natives.h"
 #include "vm/dart_entry.h"
@@ skipping 27 matching lines @@
 
 
 // TODO(turnidge): Add Map support to the dart embedding api instead
 // of implementing it here.
 static Dart_Handle CoreLib() {
   Dart_Handle core_lib_name = NewString("dart:core");
   return Dart_LookupLibrary(core_lib_name);
 }
 
 
 static Dart_Handle MapNew() {

[regis, 2013/06/26 00:16:05]

Probably not for this cl, but we could consider passing the key and value types.

[siva, 2013/06/26 21:27:14]

Some or all of this is going to change as we redo this implementation.
We could address this at that time.

On 2013/06/26 00:16:05, regis wrote:

   // TODO(turnidge): Switch to an order-preserving map type.
-  Dart_Handle cls = Dart_GetClass(CoreLib(), NewString("Map"));
-  if (Dart_IsError(cls)) {
-    return cls;
+  Dart_Handle type = Dart_GetType(CoreLib(), NewString("Map"), 0, NULL);
+  if (Dart_IsError(type)) {
+    return type;
   }
-  return Dart_New(cls, Dart_Null(), 0, NULL);
+  return Dart_New(type, Dart_Null(), 0, NULL);
 }
 
 
 static Dart_Handle MapAdd(Dart_Handle map, Dart_Handle key, Dart_Handle value) {
   Dart_Handle args[] = { key, value };
   return Dart_Invoke(map, NewString("[]="), ARRAY_SIZE(args), args);
 }
 
 
 static Dart_Handle MirrorLib() {
   Dart_Handle mirror_lib_name = NewString("dart:mirrors");
   return Dart_LookupLibrary(mirror_lib_name);
 }
 
 
 static Dart_Handle IsMirror(Dart_Handle object, bool* is_mirror) {
   Dart_Handle cls_name = NewString("Mirror");
-  Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
-  if (Dart_IsError(cls)) {
-    return cls;
+  Dart_Handle type = Dart_GetType(MirrorLib(), cls_name, 0, NULL);
+  if (Dart_IsError(type)) {
+    return type;
   }
-  Dart_Handle result = Dart_ObjectIsType(object, cls, is_mirror);
+  Dart_Handle result = Dart_ObjectIsType(object, type, is_mirror);
   if (Dart_IsError(result)) {
     return result;
   }
   return Dart_True();  // Indicates success.  Result is in is_mirror.
 }
 
 static Dart_Handle IsMethodMirror(Dart_Handle object, bool* is_mirror) {
   Dart_Handle cls_name = NewString("MethodMirror");
-  Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
-  if (Dart_IsError(cls)) {
-    return cls;
+  Dart_Handle type = Dart_GetType(MirrorLib(), cls_name, 0, NULL);
+  if (Dart_IsError(type)) {
+    return type;
   }
-  Dart_Handle result = Dart_ObjectIsType(object, cls, is_mirror);
+  Dart_Handle result = Dart_ObjectIsType(object, type, is_mirror);
   if (Dart_IsError(result)) {
     return result;
   }
   return Dart_True();  // Indicates success.  Result is in is_mirror.
 }
 
 static Dart_Handle IsVariableMirror(Dart_Handle object, bool* is_mirror) {
   Dart_Handle cls_name = NewString("VariableMirror");
-  Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
-  if (Dart_IsError(cls)) {
-    return cls;
+  Dart_Handle type = Dart_GetType(MirrorLib(), cls_name, 0, NULL);
+  if (Dart_IsError(type)) {
+    return type;
   }
-  Dart_Handle result = Dart_ObjectIsType(object, cls, is_mirror);
+  Dart_Handle result = Dart_ObjectIsType(object, type, is_mirror);
   if (Dart_IsError(result)) {
     return result;
   }
   return Dart_True();  // Indicates success.  Result is in is_mirror.
 }
 
 
 static bool IsSimpleValue(Dart_Handle object) {
   return (Dart_IsNull(object) ||
           Dart_IsNumber(object) ||
           Dart_IsString(object) ||
           Dart_IsBoolean(object));
 }
 
 
 static void FreeVMReference(Dart_WeakPersistentHandle weak_ref, void* data) {
   Dart_PersistentHandle perm_handle =
       reinterpret_cast<Dart_PersistentHandle>(data);
   Dart_DeletePersistentHandle(perm_handle);
   Dart_DeleteWeakPersistentHandle(weak_ref);
 }
 
 
 static Dart_Handle CreateVMReference(Dart_Handle handle) {
   // Create the VMReference object.
   Dart_Handle cls_name = NewString("VMReference");
-  Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
-  if (Dart_IsError(cls)) {
-    return cls;
+  Dart_Handle type = Dart_GetType(MirrorLib(), cls_name, 0, NULL);
+  if (Dart_IsError(type)) {
+    return type;
   }
-  Dart_Handle vm_ref =  Dart_New(cls, Dart_Null(), 0, NULL);
+  Dart_Handle vm_ref =  Dart_New(type, Dart_Null(), 0, NULL);
   if (Dart_IsError(vm_ref)) {
     return vm_ref;
   }
 
   // Allocate a persistent handle.
   Dart_PersistentHandle perm_handle = Dart_NewPersistentHandle(handle);
   ASSERT(perm_handle != NULL);
 
   // Store the persistent handle in the VMReference.
   intptr_t perm_handle_value = reinterpret_cast<intptr_t>(perm_handle);
@@ skipping 189 matching lines @@
     return result;
   }
 
   int64_t param_count = fixed_param_count + opt_param_count;
   Dart_Handle parameter_list = Dart_NewList(param_count);
   if (Dart_IsError(parameter_list)) {
     return result;
   }
 
   Dart_Handle param_cls_name = NewString("_LocalParameterMirrorImpl");
-  Dart_Handle param_cls = Dart_GetClass(MirrorLib(), param_cls_name);
-  if (Dart_IsError(param_cls)) {
-    return param_cls;
+  Dart_Handle param_type = Dart_GetType(MirrorLib(), param_cls_name, 0, NULL);
+  if (Dart_IsError(param_type)) {
+    return param_type;
   }
 
   for (int64_t i = 0; i < param_count; i++) {
-    Dart_Handle param_type = Dart_FunctionParameterType(func, i);
-    if (Dart_IsError(param_type)) {
-      return param_type;
+    Dart_Handle arg_type = Dart_FunctionParameterType(func, i);
+    if (Dart_IsError(arg_type)) {
+      return arg_type;
     }
     Dart_Handle args[] = {
-      CreateLazyMirror(param_type),
+      CreateLazyMirror(arg_type),
       Dart_NewBoolean(i >= fixed_param_count),  // optional param?
     };
     Dart_Handle param =
-        Dart_New(param_cls, Dart_Null(), ARRAY_SIZE(args), args);
+        Dart_New(param_type, Dart_Null(), ARRAY_SIZE(args), args);
     if (Dart_IsError(param)) {
       return param;
     }
     result = Dart_ListSetAt(parameter_list, i, param);
     if (Dart_IsError(result)) {
       return result;
     }
   }
   return parameter_list;
 }
 
 
 static Dart_Handle CreateLazyMirror(Dart_Handle target) {
   if (Dart_IsNull(target) || Dart_IsError(target)) {
     return target;
   }
 
   if (Dart_IsLibrary(target)) {
     Dart_Handle cls_name = NewString("_LazyLibraryMirror");
-    Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
+    Dart_Handle type = Dart_GetType(MirrorLib(), cls_name, 0, NULL);
     Dart_Handle args[] = { Dart_LibraryUrl(target) };
-    return Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
+    return Dart_New(type, Dart_Null(), ARRAY_SIZE(args), args);
   }
 
   if (Dart_IsClass(target)) {
     if (Dart_ClassIsFunctionType(target)) {
       Dart_Handle cls_name = NewString("_LazyFunctionTypeMirror");
-      Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
+      Dart_Handle type = Dart_GetType(MirrorLib(), cls_name, 0, NULL);
 
       Dart_Handle sig = Dart_ClassGetFunctionTypeSignature(target);
       Dart_Handle return_type = Dart_FunctionReturnType(sig);
       if (Dart_IsError(return_type)) {
         return return_type;
       }
 
       Dart_Handle args[] = {
         CreateLazyMirror(return_type),
         CreateParameterMirrorList(sig),
       };
-      return Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
+      return Dart_New(type, Dart_Null(), ARRAY_SIZE(args), args);
     } else {
       Dart_Handle cls_name = NewString("_LazyTypeMirror");
-      Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
+      Dart_Handle type = Dart_GetType(MirrorLib(), cls_name, 0, NULL);
       Dart_Handle lib = Dart_ClassGetLibrary(target);
       Dart_Handle lib_url;
       if (Dart_IsNull(lib)) {
         lib_url = Dart_Null();
       } else {
         lib_url = Dart_LibraryUrl(lib);
       }
       Dart_Handle args[] = { lib_url, Dart_ClassName(target) };
-      return Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
+      return Dart_New(type, Dart_Null(), ARRAY_SIZE(args), args);
     }
   }
 
   if (Dart_IsTypeVariable(target)) {
     Dart_Handle var_name = Dart_TypeVariableName(target);
     Dart_Handle owner = Dart_TypeVariableOwner(target);
     Dart_Handle owner_mirror = CreateLazyMirror(owner);
 
     Dart_Handle cls_name = NewString("_LazyTypeVariableMirror");
-    Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
+    Dart_Handle type = Dart_GetType(MirrorLib(), cls_name, 0, NULL);
 
     Dart_Handle args[] = { var_name, owner_mirror };
-    return Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
+    return Dart_New(type, Dart_Null(), ARRAY_SIZE(args), args);
   }
 
   UNREACHABLE();
   return Dart_Null();
 }
 
 
 static Dart_Handle CreateImplementsList(Dart_Handle intf) {
   intptr_t len = 0;
   Dart_Handle result = Dart_ClassGetInterfaceCount(intf, &len);
@@ skipping 22 matching lines @@
   }
   return mirror_list;
 }
 
 
 static Dart_Handle CreateTypeVariableMirror(Dart_Handle type_var,
                                             Dart_Handle type_var_name,
                                             Dart_Handle owner_mirror) {
   ASSERT(Dart_IsTypeVariable(type_var));
   Dart_Handle cls_name = NewString("_LocalTypeVariableMirrorImpl");
-  Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
-  if (Dart_IsError(cls)) {
-    return cls;
+  Dart_Handle type = Dart_GetType(MirrorLib(), cls_name, 0, NULL);
+  if (Dart_IsError(type)) {
+    return type;
   }
 
   Dart_Handle upper_bound = Dart_TypeVariableUpperBound(type_var);
   if (Dart_IsError(upper_bound)) {
     return upper_bound;
   }
 
   Dart_Handle args[] = {
     type_var_name,
     owner_mirror,
     CreateLazyMirror(upper_bound),
   };
-  Dart_Handle mirror = Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
+  Dart_Handle mirror = Dart_New(type, Dart_Null(), ARRAY_SIZE(args), args);
   return mirror;
 }
 
 
 static Dart_Handle CreateTypeVariableMap(Dart_Handle owner,
                                          Dart_Handle owner_mirror) {
   ASSERT(Dart_IsClass(owner));
   // TODO(turnidge): This should be an immutable map.
   Dart_Handle map = MapNew();
   if (Dart_IsError(map)) {
@@ skipping 28 matching lines @@
   }
   return map;
 }
 
 
 static Dart_Handle CreateTypedefMirror(Dart_Handle cls,
                                        Dart_Handle cls_name,
                                        Dart_Handle owner,
                                        Dart_Handle owner_mirror) {
   Dart_Handle mirror_cls_name = NewString("_LocalTypedefMirrorImpl");
-  Dart_Handle mirror_cls = Dart_GetClass(MirrorLib(), mirror_cls_name);
-  if (Dart_IsError(mirror_cls)) {
-    return mirror_cls;
+  Dart_Handle mirror_type = Dart_GetType(MirrorLib(), mirror_cls_name, 0, NULL);
+  if (Dart_IsError(mirror_type)) {
+    return mirror_type;
   }
 
   Dart_Handle referent = Dart_ClassGetTypedefReferent(cls);
   if (Dart_IsError(referent)) {
     return referent;
   }
 
   Dart_Handle args[] = {
     cls_name,
     owner_mirror,
     CreateLazyMirror(referent),
   };
   Dart_Handle mirror =
-      Dart_New(mirror_cls, Dart_Null(), ARRAY_SIZE(args), args);
+      Dart_New(mirror_type, Dart_Null(), ARRAY_SIZE(args), args);
   return mirror;
 }
 
 
 static Dart_Handle CreateMemberMap(Dart_Handle owner, Dart_Handle owner_mirror);
 static Dart_Handle CreateConstructorMap(Dart_Handle owner,
                                         Dart_Handle owner_mirror);
 
 
 static Dart_Handle CreateClassMirror(Dart_Handle intf,
                                      Dart_Handle intf_name,
                                      Dart_Handle lib,
                                      Dart_Handle lib_mirror) {
   ASSERT(Dart_IsClass(intf));
   if (Dart_ClassIsTypedef(intf)) {
     // This class is actually a typedef.  Represent it specially in
     // reflection.
     return CreateTypedefMirror(intf, intf_name, lib, lib_mirror);
   }
 
   Dart_Handle cls_name = NewString("_LocalClassMirrorImpl");
-  Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
-  if (Dart_IsError(cls)) {
-    return cls;
+  Dart_Handle type = Dart_GetType(MirrorLib(), cls_name, 0, NULL);
+  if (Dart_IsError(type)) {
+    return type;
   }
 
   // TODO(turnidge): Why am I getting Null when I expect Object?
   // TODO(gbracha): this is probably the root of bug 7868
   Dart_Handle super_class = Dart_GetSuperclass(intf);
   if (Dart_IsNull(super_class)) {
     super_class = Dart_GetClass(CoreLib(), NewString("Object"));
   }
   // TODO(turnidge): Simplify code, now that default classes have been removed.
   Dart_Handle default_class = Dart_Null();
@@ skipping 20 matching lines @@
     intf_name,
     Dart_NewBoolean(Dart_IsClass(intf)),
     lib_mirror,
     CreateLazyMirror(super_class),
     CreateImplementsList(intf),
     CreateLazyMirror(default_class),
     member_map,
     constructor_map,
     type_var_map,
   };
-  Dart_Handle mirror = Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
+  Dart_Handle mirror = Dart_New(type, Dart_Null(), ARRAY_SIZE(args), args);
   return mirror;
 }
 
 
 static Dart_Handle CreateMethodMirror(Dart_Handle func,
                                       Dart_Handle func_name,
                                       Dart_Handle owner_mirror) {
   ASSERT(Dart_IsFunction(func));
   Dart_Handle mirror_cls_name = NewString("_LocalMethodMirrorImpl");
-  Dart_Handle mirror_cls = Dart_GetClass(MirrorLib(), mirror_cls_name);
-  if (Dart_IsError(mirror_cls)) {
-    return mirror_cls;
+  Dart_Handle mirror_type = Dart_GetType(MirrorLib(), mirror_cls_name, 0, NULL);
+  if (Dart_IsError(mirror_type)) {
+    return mirror_type;
   }
 
   bool is_static = false;
   bool is_abstract = false;
   bool is_getter = false;
   bool is_setter = false;
   bool is_constructor = false;
 
   Dart_Handle result = Dart_FunctionIsStatic(func, &is_static);
   if (Dart_IsError(result)) {
@@ skipping 40 matching lines @@
     Dart_NewBoolean(is_abstract),
     Dart_NewBoolean(is_getter),
     Dart_NewBoolean(is_setter),
     Dart_NewBoolean(is_constructor),
     Dart_False(),
     Dart_False(),
     Dart_False(),
     Dart_False(),
   };
   Dart_Handle mirror =
-      Dart_New(mirror_cls, Dart_Null(), ARRAY_SIZE(args), args);
+      Dart_New(mirror_type, Dart_Null(), ARRAY_SIZE(args), args);
   return mirror;
 }
 
 
 static Dart_Handle CreateVariableMirror(Dart_Handle var,
                                         Dart_Handle var_name,
                                         Dart_Handle lib_mirror) {
   ASSERT(Dart_IsVariable(var));
   Dart_Handle cls_name = NewString("_LocalVariableMirrorImpl");
-  Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
-  if (Dart_IsError(cls)) {
-    return cls;
+  Dart_Handle type = Dart_GetType(MirrorLib(), cls_name, 0, NULL);
+  if (Dart_IsError(type)) {
+    return type;
   }
 
   bool is_static = false;
   bool is_final = false;
 
   Dart_Handle result = Dart_VariableIsStatic(var, &is_static);
   if (Dart_IsError(result)) {
     return result;
   }
   result = Dart_VariableIsFinal(var, &is_final);
   if (Dart_IsError(result)) {
     return result;
   }
 
-  Dart_Handle type = Dart_VariableType(var);
-  if (Dart_IsError(type)) {
-    return type;
+  Dart_Handle var_type = Dart_VariableType(var);
+  if (Dart_IsError(var_type)) {
+    return var_type;
   }
 
   Dart_Handle args[] = {
     var_name,
     lib_mirror,
-    CreateLazyMirror(type),
+    CreateLazyMirror(var_type),
     Dart_NewBoolean(is_static),
     Dart_NewBoolean(is_final),
   };
-  Dart_Handle mirror = Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
+  Dart_Handle mirror = Dart_New(type, Dart_Null(), ARRAY_SIZE(args), args);
   return mirror;
 }
 
 
 static Dart_Handle AddMemberClasses(Dart_Handle map,
                                     Dart_Handle owner,
                                     Dart_Handle owner_mirror) {
   ASSERT(Dart_IsLibrary(owner));
   Dart_Handle result;
   Dart_Handle names = Dart_LibraryGetClassNames(owner);
@@ skipping 183 matching lines @@
   result = AddConstructors(map, owner, owner_mirror);
   if (Dart_IsError(result)) {
     return result;
   }
   return map;
 }
 
 
 static Dart_Handle CreateLibraryMirror(Dart_Handle lib) {
   Dart_Handle cls_name = NewString("_LocalLibraryMirrorImpl");
-  Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
-  if (Dart_IsError(cls)) {
-    return cls;
+  Dart_Handle type = Dart_GetType(MirrorLib(), cls_name, 0, NULL);
+  if (Dart_IsError(type)) {
+    return type;
   }
   Dart_Handle lazy_lib_mirror = CreateLazyMirror(lib);
   if (Dart_IsError(lazy_lib_mirror)) {
     return lazy_lib_mirror;
   }
   Dart_Handle member_map = CreateMemberMap(lib, lazy_lib_mirror);
   if (Dart_IsError(member_map)) {
     return member_map;
   }
   Dart_Handle args[] = {
     CreateVMReference(lib),
     Dart_LibraryName(lib),
     Dart_LibraryUrl(lib),
     member_map,
   };
-  Dart_Handle lib_mirror = Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
+  Dart_Handle lib_mirror = Dart_New(type, Dart_Null(), ARRAY_SIZE(args), args);
   if (Dart_IsError(lib_mirror)) {
     return lib_mirror;
   }
 
   return lib_mirror;
 }
 
 
 static Dart_Handle CreateLibrariesMap() {
   // TODO(turnidge): This should be an immutable map.
@@ skipping 25 matching lines @@
       return lib_mirror;
     }
     result = MapAdd(map, lib_url, lib_mirror);
   }
   return map;
 }
 
 
 static Dart_Handle CreateIsolateMirror() {
   Dart_Handle cls_name = NewString("_LocalIsolateMirrorImpl");
-  Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
-  if (Dart_IsError(cls)) {
-    return cls;
+  Dart_Handle type = Dart_GetType(MirrorLib(), cls_name, 0, NULL);
+  if (Dart_IsError(type)) {
+    return type;
   }
   Dart_Handle args[] = {
     Dart_DebugName(),
     CreateLazyMirror(Dart_RootLibrary()),
   };
-  return Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
+  return Dart_New(type, Dart_Null(), ARRAY_SIZE(args), args);
 }
 
 
 static Dart_Handle CreateMirrorSystem() {
   Dart_Handle cls_name = NewString("_LocalMirrorSystemImpl");
-  Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
-  if (Dart_IsError(cls)) {
-    return cls;
+  Dart_Handle type = Dart_GetType(MirrorLib(), cls_name, 0, NULL);
+  if (Dart_IsError(type)) {
+    return type;
   }
 
   Dart_Handle libraries = CreateLibrariesMap();
   if (Dart_IsError(libraries)) {
     return libraries;
   }
 
   Dart_Handle args[] = {
     libraries,
     CreateIsolateMirror(),
   };
-  Dart_Handle mirror = Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
+  Dart_Handle mirror = Dart_New(type, Dart_Null(), ARRAY_SIZE(args), args);
   if (Dart_IsError(mirror)) {
     return mirror;
   }
 
   return mirror;
 }
 
 
 static Dart_Handle CreateNullMirror() {
   Dart_Handle cls_name = NewString("_LocalInstanceMirrorImpl");
-  Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
-  if (Dart_IsError(cls)) {
-    return cls;
+  Dart_Handle type = Dart_GetType(MirrorLib(), cls_name, 0, NULL);
+  if (Dart_IsError(type)) {
+    return type;
   }
 
   // TODO(turnidge): This is wrong.  The Null class is distinct from object.
   Dart_Handle object_class = Dart_GetClass(CoreLib(), NewString("Object"));
 
   Dart_Handle args[] = {
     CreateVMReference(Dart_Null()),
     CreateLazyMirror(object_class),
     Dart_Null(),
   };
-  Dart_Handle mirror = Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
+  Dart_Handle mirror = Dart_New(type, Dart_Null(), ARRAY_SIZE(args), args);
   return mirror;
 }
 
 
 static Dart_Handle CreateInstanceMirror(Dart_Handle instance) {
   if (Dart_IsNull(instance)) {
     return CreateNullMirror();
   }
   ASSERT(Dart_IsInstance(instance));
 
   Dart_Handle instance_cls = Dart_InstanceGetClass(instance);
   if (Dart_IsError(instance_cls)) {
     return instance_cls;
   }
 
   if (Dart_IsClosure(instance)) {
     Dart_Handle cls_name = NewString("_LocalClosureMirrorImpl");
-    Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
-    if (Dart_IsError(cls)) {
-      return cls;
+    Dart_Handle type = Dart_GetType(MirrorLib(), cls_name, 0, NULL);
+    if (Dart_IsError(type)) {
+      return type;
     }
     // We set the function field of ClosureMirrors outside of the constructor
     // to break the mutual recursion.
     Dart_Handle func = Dart_ClosureFunction(instance);
     if (Dart_IsError(func)) {
       return func;
     }
 
     // TODO(turnidge): Why not use the real function name here?
     Dart_Handle func_name = NewString("call");
     Dart_Handle func_owner = Dart_FunctionOwner(func);
     if (Dart_IsError(func_owner)) {
       return func_owner;
     }
 
     // TODO(turnidge): Pass the function owner here.  This will require
     // us to support functions in CreateLazyMirror.
     Dart_Handle func_mirror =
         CreateMethodMirror(func, func_name, Dart_Null());
     if (Dart_IsError(func_mirror)) {
       return func_mirror;
     }
     Dart_Handle args[] = {
       CreateVMReference(instance),
       CreateLazyMirror(instance_cls),
       instance,
       func_mirror,
     };
-    return Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
+    return Dart_New(type, Dart_Null(), ARRAY_SIZE(args), args);
 
   } else {
     Dart_Handle cls_name = NewString("_LocalInstanceMirrorImpl");
-    Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
-    if (Dart_IsError(cls)) {
-      return cls;
+    Dart_Handle type = Dart_GetType(MirrorLib(), cls_name, 0, NULL);
+    if (Dart_IsError(type)) {
+      return type;
     }
     Dart_Handle args[] = {
       CreateVMReference(instance),
       CreateLazyMirror(instance_cls),
       instance,
     };
-    return Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
+    return Dart_New(type, Dart_Null(), ARRAY_SIZE(args), args);
   }
 }
 
 
 static Dart_Handle CreateMirroredError(Dart_Handle error) {
   ASSERT(Dart_IsError(error));
   if (Dart_IsUnhandledExceptionError(error)) {
     Dart_Handle exc = Dart_ErrorGetException(error);
     if (Dart_IsError(exc)) {
       return exc;
     }
     Dart_Handle exc_string = Dart_ToString(exc);
     if (Dart_IsError(exc_string)) {
       // Only propagate fatal errors from exc.toString().  Ignore the rest.
       if (Dart_IsFatalError(exc_string)) {
         return exc_string;
       }
       exc_string = Dart_Null();
     }
 
     Dart_Handle stack = Dart_ErrorGetStacktrace(error);
     if (Dart_IsError(stack)) {
       return stack;
     }
     Dart_Handle cls_name = NewString("MirroredUncaughtExceptionError");
-    Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
+    Dart_Handle type = Dart_GetType(MirrorLib(), cls_name, 0, NULL);
     Dart_Handle args[] = {
       CreateInstanceMirror(exc),
       exc_string,
       stack,
     };
     Dart_Handle mirrored_exc =
-        Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
+        Dart_New(type, Dart_Null(), ARRAY_SIZE(args), args);
     return Dart_NewUnhandledExceptionError(mirrored_exc);
   } else if (Dart_IsApiError(error) ||
              Dart_IsCompilationError(error)) {
     Dart_Handle cls_name = NewString("MirroredCompilationError");
-    Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
+    Dart_Handle type = Dart_GetType(MirrorLib(), cls_name, 0, NULL);
     Dart_Handle args[] = { NewString(Dart_GetError(error)) };
     Dart_Handle mirrored_exc =
-        Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
+        Dart_New(type, Dart_Null(), ARRAY_SIZE(args), args);
     return Dart_NewUnhandledExceptionError(mirrored_exc);
   } else {
     ASSERT(Dart_IsFatalError(error));
     return error;
   }
 }
 
 
 void NATIVE_ENTRY_FUNCTION(Mirrors_makeLocalMirrorSystem)(
     Dart_NativeArguments args) {
@@ skipping 241 matching lines @@
   Dart_ExitScope();
 }
 
 void HandleMirrorsMessage(Isolate* isolate,
                           Dart_Port reply_port,
                           const Instance& message) {
   UNIMPLEMENTED();
 }
 
 }  // namespace dart