Implement more of the mirrors library, primarily stuff to do with types.

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 "platform/json.h"
 #include "vm/bootstrap_natives.h"
 #include "vm/dart_entry.h"
 #include "vm/exceptions.h"
@@ skipping 22 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 = Dart_NewString("dart:core");
   return Dart_LookupLibrary(core_lib_name);
 }
 
 
 static Dart_Handle MapNew() {
+  // TODO(turnidge): Switch to an order-preserving map type.
   Dart_Handle cls = Dart_GetClass(CoreLib(), Dart_NewString("Map"));
   if (Dart_IsError(cls)) {
     return cls;
   }
   return Dart_New(cls, Dart_Null(), 0, NULL);
 }
 
 
 static Dart_Handle MapAdd(Dart_Handle map, Dart_Handle key, Dart_Handle value) {
   Dart_Handle args[] = { key, value };
@@ skipping 121 matching lines @@
     }
 }
 
 static Dart_Handle UnwrapArgList(Dart_Handle arg_list,
                                  GrowableArray<Dart_Handle>* arg_array) {
   intptr_t len = 0;
   Dart_Handle result = Dart_ListLength(arg_list, &len);
   if (Dart_IsError(result)) {
     return result;
   }
-  for (int i = 0; i < len; i++) {
+  for (intptr_t i = 0; i < len; i++) {
     Dart_Handle arg = Dart_ListGetAt(arg_list, i);
     Dart_Handle unwrapped_arg = UnwrapArg(arg);
     if (Dart_IsError(unwrapped_arg)) {
       return unwrapped_arg;
     }
     arg_array->Add(unwrapped_arg);
   }
   return Dart_True();
 }
 
 
+static Dart_Handle CreateLazyMirror(Dart_Handle target);
+
+
+static Dart_Handle CreateParameterMirrorList(Dart_Handle func) {
+  int64_t fixed_param_count;
+  int64_t opt_param_count;
+  Dart_Handle result = Dart_FunctionParameterCounts(func,
+                                                    &fixed_param_count,
+                                                    &opt_param_count);
+  if (Dart_IsError(result)) {
+    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 = Dart_NewString("_LocalParameterMirrorImpl");
+  Dart_Handle param_cls = Dart_GetClass(MirrorLib(), param_cls_name);
+  if (Dart_IsError(param_cls)) {
+    return param_cls;
+  }
+
+  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 args[] = {
+      CreateLazyMirror(param_type),
+      Dart_NewBoolean(i >= fixed_param_count),  // optional param?
+    };
+    Dart_Handle param =
+        Dart_New(param_cls, 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)) {
+  if (Dart_IsNull(target) || Dart_IsError(target)) {
     return target;
   }
+
   if (Dart_IsLibrary(target)) {
     Dart_Handle cls_name = Dart_NewString("_LazyLibraryMirror");
     Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
     Dart_Handle args[] = { Dart_LibraryName(target) };
     return Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
-  } else {
-    ASSERT(Dart_IsClass(target) || Dart_IsInterface(target));
-    Dart_Handle cls_name = Dart_NewString("_LazyClassMirror");
+  }
+
+  if (Dart_IsClass(target) || Dart_IsInterface(target)) {
+    if (Dart_ClassIsFunctionType(target)) {
+      Dart_Handle cls_name = Dart_NewString("_LazyFunctionTypeMirror");
+      Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
+
+      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);
+    } else {
+      Dart_Handle cls_name = Dart_NewString("_LazyTypeMirror");
+      Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
+      Dart_Handle lib = Dart_ClassGetLibrary(target);
+      Dart_Handle lib_name;
+      if (Dart_IsNull(lib)) {
+        lib_name = Dart_Null();
+      } else {
+        lib_name = Dart_LibraryName(lib);
+      }
+      Dart_Handle args[] = { lib_name, Dart_ClassName(target) };
+      return Dart_New(cls, 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 = Dart_NewString("_LazyTypeVariableMirror");
     Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
 
-    Dart_Handle lib = Dart_ClassGetLibrary(target);
-    Dart_Handle lib_name;
-    if (Dart_IsNull(lib)) {
-      lib_name = Dart_Null();
-    } else {
-      lib_name = Dart_LibraryName(lib);
-    }
-
-    Dart_Handle args[] = { lib_name, Dart_ClassName(target) };
+    Dart_Handle args[] = { var_name, owner_mirror };
     return Dart_New(cls, 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);
   if (Dart_IsError(result)) {
     return result;
   }
 
   Dart_Handle mirror_list = Dart_NewList(len);
   if (Dart_IsError(mirror_list)) {
     return mirror_list;
   }
 
-  for (int i = 0; i < len; i++) {
+  for (intptr_t i = 0; i < len; i++) {
     Dart_Handle interface = Dart_ClassGetInterfaceAt(intf, i);
     if (Dart_IsError(interface)) {
       return interface;
     }
     Dart_Handle mirror = CreateLazyMirror(interface);
     if (Dart_IsError(mirror)) {
       return mirror;
     }
     Dart_Handle result = Dart_ListSetAt(mirror_list, i, mirror);
     if (Dart_IsError(result)) {
       return result;
     }
   }
   return mirror_list;
 }
 
 
-static Dart_Handle CreateMemberMap(Dart_Handle owner);
+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 = Dart_NewString("_LocalTypeVariableMirrorImpl");
+  Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
+  if (Dart_IsError(cls)) {
+    return cls;
+  }
+
+  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);
+  return mirror;
+}
+
+
+static Dart_Handle CreateTypeVariableMap(Dart_Handle owner,
+                                         Dart_Handle owner_mirror) {
+  ASSERT(Dart_IsClass(owner) || Dart_IsInterface(owner));
+  // TODO(turnidge): This should be an immutable map.
+  Dart_Handle map = MapNew();
+  if (Dart_IsError(map)) {
+    return map;
+  }
+
+  Dart_Handle names = Dart_GetTypeVariableNames(owner);
+  if (Dart_IsError(names)) {
+    return names;
+  }
+  intptr_t len;
+  Dart_Handle result = Dart_ListLength(names, &len);
+  if (Dart_IsError(result)) {
+    return result;
+  }
+  for (intptr_t i = 0; i < len; i++) {
+    Dart_Handle type_var_name = Dart_ListGetAt(names, i);
+    Dart_Handle type_var = Dart_LookupTypeVariable(owner, type_var_name);
+    if (Dart_IsError(type_var)) {
+      return type_var;
+    }
+    ASSERT(!Dart_IsNull(type_var));
+    Dart_Handle type_var_mirror =
+        CreateTypeVariableMirror(type_var, type_var_name, owner_mirror);
+    if (Dart_IsError(type_var_mirror)) {
+      return type_var_mirror;
+    }
+    result = MapAdd(map, type_var_name, type_var_mirror);
+    if (Dart_IsError(result)) {
+      return result;
+    }
+  }
+  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 = Dart_NewString("_LocalTypedefMirrorImpl");
+  Dart_Handle mirror_cls = Dart_GetClass(MirrorLib(), mirror_cls_name);
+  if (Dart_IsError(mirror_cls)) {
+    return mirror_cls;
+  }
+
+  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);
+  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) || Dart_IsInterface(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 = Dart_NewString("_LocalClassMirrorImpl");
   Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
   if (Dart_IsError(cls)) {
     return cls;
   }
 
   // TODO(turnidge): Why am I getting Null when I expect Object?
   Dart_Handle super_class = Dart_GetSuperclass(intf);
   if (Dart_IsNull(super_class)) {
     super_class = Dart_GetClass(CoreLib(), Dart_NewString("Object"));
   }
   Dart_Handle default_class = Dart_ClassGetDefault(intf);
-  Dart_Handle member_map = CreateMemberMap(intf);
+
+  Dart_Handle intf_mirror = CreateLazyMirror(intf);
+  if (Dart_IsError(intf_mirror)) {
+    return intf_mirror;
+  }
+  Dart_Handle member_map = CreateMemberMap(intf, intf_mirror);
   if (Dart_IsError(member_map)) {
     return member_map;
   }
+  Dart_Handle constructor_map = CreateConstructorMap(intf, intf_mirror);
+  if (Dart_IsError(constructor_map)) {
+    return constructor_map;
+  }
+  Dart_Handle type_var_map = CreateTypeVariableMap(intf, intf_mirror);
+  if (Dart_IsError(type_var_map)) {
+    return type_var_map;
+  }
 
   Dart_Handle args[] = {
     CreateVMReference(intf),
     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);
   return mirror;
 }
 
 
 static Dart_Handle CreateMethodMirror(Dart_Handle func,
                                       Dart_Handle func_name,
                                       Dart_Handle owner_mirror) {
   ASSERT(Dart_IsFunction(func));
-  Dart_Handle cls_name = Dart_NewString("_LocalMethodMirrorImpl");
-  Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
-  if (Dart_IsError(cls)) {
-    return cls;
+  Dart_Handle mirror_cls_name = Dart_NewString("_LocalMethodMirrorImpl");
+  Dart_Handle mirror_cls = Dart_GetClass(MirrorLib(), mirror_cls_name);
+  if (Dart_IsError(mirror_cls)) {
+    return mirror_cls;
   }
 
   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)) {
     return result;
   }
   result = Dart_FunctionIsAbstract(func, &is_abstract);
   if (Dart_IsError(result)) {
     return result;
   }
   result = Dart_FunctionIsGetter(func, &is_getter);
   if (Dart_IsError(result)) {
     return result;
   }
   result = Dart_FunctionIsSetter(func, &is_setter);
   if (Dart_IsError(result)) {
     return result;
   }
   result = Dart_FunctionIsConstructor(func, &is_constructor);
   if (Dart_IsError(result)) {
     return result;
   }
 
+  Dart_Handle return_type = Dart_FunctionReturnType(func);
+  if (Dart_IsError(return_type)) {
+    return return_type;
+  }
+
   int64_t fixed_param_count;
   int64_t opt_param_count;
   result = Dart_FunctionParameterCounts(func,
                                         &fixed_param_count,
                                         &opt_param_count);
   if (Dart_IsError(result)) {
     return result;
   }
 
-  Dart_Handle parameter_mirrors =
-    Dart_NewList(fixed_param_count + opt_param_count);
-  if (Dart_IsError(parameter_mirrors)) {
-    return result;
-  }
-
-  Dart_Handle param_cls_name = Dart_NewString("_LocalParameterMirrorImpl");
-  Dart_Handle param_cls = Dart_GetClass(MirrorLib(), param_cls_name);
-  if (Dart_IsError(param_cls)) {
-    return param_cls;
-  }
-
-  // TODO(rmacnak): Fill the parameter mirrors with more than whether they are
-  // are optional.
-  for (int i = 0; i < fixed_param_count; i++) {
-    Dart_Handle args[] = { Dart_False() };
-    Dart_Handle fixed_param =
-      Dart_New(param_cls, Dart_Null(), ARRAY_SIZE(args), args);
-    if (Dart_IsError(fixed_param)) {
-     return fixed_param;
-    }
-    result = Dart_ListSetAt(parameter_mirrors, i, fixed_param);
-    if (Dart_IsError(result)) {
-     return result;
-    }
-  }
-
-  for (int i = 0; i < opt_param_count; i++) {
-    Dart_Handle args[] = { Dart_True() };
-    Dart_Handle opt_param =
-      Dart_New(param_cls, Dart_Null(), ARRAY_SIZE(args), args);
-    if (Dart_IsError(opt_param)) {
-     return opt_param;
-    }
-    result = Dart_ListSetAt(parameter_mirrors, i+fixed_param_count, opt_param);
-    if (Dart_IsError(result)) {
-     return result;
-    }
-  }
-
   // TODO(turnidge): Implement constructor kinds (arguments 7 - 10).
   Dart_Handle args[] = {
     func_name,
     owner_mirror,
-    parameter_mirrors,
+    CreateParameterMirrorList(func),
+    CreateLazyMirror(return_type),
     Dart_NewBoolean(is_static),
     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(cls, Dart_Null(), ARRAY_SIZE(args), args);
+  Dart_Handle mirror =
+      Dart_New(mirror_cls, 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 = Dart_NewString("_LocalVariableMirrorImpl");
   Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
   if (Dart_IsError(cls)) {
     return cls;
   }
 
   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 args[] = {
     var_name,
     lib_mirror,
+    CreateLazyMirror(type),
     Dart_NewBoolean(is_static),
     Dart_NewBoolean(is_final),
   };
   Dart_Handle mirror = Dart_New(cls, 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);
   if (Dart_IsError(names)) {
     return names;
   }
   intptr_t len;
   result = Dart_ListLength(names, &len);
   if (Dart_IsError(result)) {
     return result;
   }
-  for (int i = 0; i < len; i++) {
+  for (intptr_t i = 0; i < len; i++) {
     Dart_Handle intf_name = Dart_ListGetAt(names, i);
     Dart_Handle intf = Dart_GetClass(owner, intf_name);
     if (Dart_IsError(intf)) {
       return intf;
     }
     Dart_Handle intf_mirror =
         CreateClassMirror(intf, intf_name, owner, owner_mirror);
     if (Dart_IsError(intf_mirror)) {
       return intf_mirror;
     }
@@ skipping 12 matching lines @@
   Dart_Handle result;
   Dart_Handle names = Dart_GetFunctionNames(owner);
   if (Dart_IsError(names)) {
     return names;
   }
   intptr_t len;
   result = Dart_ListLength(names, &len);
   if (Dart_IsError(result)) {
     return result;
   }
-  for (int i = 0; i < len; i++) {
+  for (intptr_t i = 0; i < len; i++) {
     Dart_Handle func_name = Dart_ListGetAt(names, i);
     Dart_Handle func = Dart_LookupFunction(owner, func_name);
     if (Dart_IsError(func)) {
       return func;
     }
     ASSERT(!Dart_IsNull(func));
+
+    bool is_constructor = false;
+    result = Dart_FunctionIsConstructor(func, &is_constructor);
+    if (Dart_IsError(result)) {
+      return result;
+    }
+    if (is_constructor) {
+      // Skip constructors.
+      continue;
+    }
+
     Dart_Handle func_mirror = CreateMethodMirror(func, func_name, owner_mirror);
     if (Dart_IsError(func_mirror)) {
       return func_mirror;
     }
     result = MapAdd(map, func_name, func_mirror);
     if (Dart_IsError(result)) {
       return result;
     }
   }
   return Dart_True();
 }
 
 
+static Dart_Handle AddConstructors(Dart_Handle map,
+                                   Dart_Handle owner,
+                                   Dart_Handle owner_mirror) {
+  Dart_Handle result;
+  Dart_Handle names = Dart_GetFunctionNames(owner);
+  if (Dart_IsError(names)) {
+    return names;
+  }
+  intptr_t len;
+  result = Dart_ListLength(names, &len);
+  if (Dart_IsError(result)) {
+    return result;
+  }
+  for (intptr_t i = 0; i < len; i++) {
+    Dart_Handle func_name = Dart_ListGetAt(names, i);
+    Dart_Handle func = Dart_LookupFunction(owner, func_name);
+    if (Dart_IsError(func)) {
+      return func;
+    }
+    ASSERT(!Dart_IsNull(func));
+
+    bool is_constructor = false;
+    result = Dart_FunctionIsConstructor(func, &is_constructor);
+    if (Dart_IsError(result)) {
+      return result;
+    }
+    if (!is_constructor) {
+      // Skip non-constructors.
+      continue;
+    }
+
+    Dart_Handle func_mirror = CreateMethodMirror(func, func_name, owner_mirror);
+    if (Dart_IsError(func_mirror)) {
+      return func_mirror;
+    }
+    result = MapAdd(map, func_name, func_mirror);
+    if (Dart_IsError(result)) {
+      return result;
+    }
+  }
+  return Dart_True();
+}
+
+
 static Dart_Handle AddMemberVariables(Dart_Handle map,
                                       Dart_Handle owner,
                                       Dart_Handle owner_mirror) {
   Dart_Handle result;
   Dart_Handle names = Dart_GetVariableNames(owner);
   if (Dart_IsError(names)) {
     return names;
   }
   intptr_t len;
   result = Dart_ListLength(names, &len);
   if (Dart_IsError(result)) {
     return result;
   }
-  for (int i = 0; i < len; i++) {
+  for (intptr_t i = 0; i < len; i++) {
     Dart_Handle var_name = Dart_ListGetAt(names, i);
     Dart_Handle var = Dart_LookupVariable(owner, var_name);
     if (Dart_IsError(var)) {
       return var;
     }
     ASSERT(!Dart_IsNull(var));
     Dart_Handle var_mirror = CreateVariableMirror(var, var_name, owner_mirror);
     if (Dart_IsError(var_mirror)) {
       return var_mirror;
     }
     result = MapAdd(map, var_name, var_mirror);
     if (Dart_IsError(result)) {
       return result;
     }
   }
   return Dart_True();
 }
 
 
-static Dart_Handle CreateMemberMap(Dart_Handle owner) {
+static Dart_Handle CreateMemberMap(Dart_Handle owner,
+                                   Dart_Handle owner_mirror) {
   // TODO(turnidge): This should be an immutable map.
-  Dart_Handle owner_mirror = CreateLazyMirror(owner);
   if (Dart_IsError(owner_mirror)) {
     return owner_mirror;
   }
   Dart_Handle result;
   Dart_Handle map = MapNew();
   if (Dart_IsLibrary(owner)) {
     result = AddMemberClasses(map, owner, owner_mirror);
     if (Dart_IsError(result)) {
       return result;
     }
   }
   result = AddMemberFunctions(map, owner, owner_mirror);
   if (Dart_IsError(result)) {
     return result;
   }
   result = AddMemberVariables(map, owner, owner_mirror);
   if (Dart_IsError(result)) {
     return result;
   }
   return map;
 }
 
 
+static Dart_Handle CreateConstructorMap(Dart_Handle owner,
+                                        Dart_Handle owner_mirror) {
+  // TODO(turnidge): This should be an immutable map.
+  if (Dart_IsError(owner_mirror)) {
+    return owner_mirror;
+  }
+  Dart_Handle result;
+  Dart_Handle map = MapNew();
+  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 = Dart_NewString("_LocalLibraryMirrorImpl");
   Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
   if (Dart_IsError(cls)) {
     return cls;
   }
-  Dart_Handle member_map = CreateMemberMap(lib);
+  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);
@@ skipping 11 matching lines @@
 
   Dart_Handle lib_urls = Dart_GetLibraryURLs();
   if (Dart_IsError(lib_urls)) {
     return lib_urls;
   }
   intptr_t len;
   Dart_Handle result = Dart_ListLength(lib_urls, &len);
   if (Dart_IsError(result)) {
     return result;
   }
-  for (int i = 0; i < len; i++) {
+  for (intptr_t i = 0; i < len; i++) {
     Dart_Handle lib_url = Dart_ListGetAt(lib_urls, i);
     Dart_Handle lib = Dart_LookupLibrary(lib_url);
     if (Dart_IsError(lib)) {
       return lib;
     }
     Dart_Handle lib_key = Dart_LibraryName(lib);
     Dart_Handle lib_mirror = CreateLibraryMirror(lib);
     if (Dart_IsError(lib_mirror)) {
       return lib_mirror;
     }
@@ skipping 62 matching lines @@
   return mirror;
 }
 
 
 static Dart_Handle CreateInstanceMirror(Dart_Handle instance) {
   if (Dart_IsNull(instance)) {
     return CreateNullMirror();
   }
   ASSERT(Dart_IsInstance(instance));
 
-  bool is_closure = Dart_IsClosure(instance);
-  Dart_Handle cls_name = Dart_NewString(
-    is_closure ? "_LocalClosureMirrorImpl" : "_LocalInstanceMirrorImpl");
-  Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
-  if (Dart_IsError(cls)) {
-    return cls;
-  }
   Dart_Handle instance_cls = Dart_InstanceGetClass(instance);
   if (Dart_IsError(instance_cls)) {
     return instance_cls;
   }
 
-  Dart_Handle args[] = {
-    CreateVMReference(instance),
-    CreateLazyMirror(instance_cls),
-    instance
-  };
-  Dart_Handle mirror = Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
-
-  if (is_closure) {
+  if (Dart_IsClosure(instance)) {
+    Dart_Handle cls_name = Dart_NewString("_LocalClosureMirrorImpl");
+    Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
+    if (Dart_IsError(cls)) {
+      return cls;
+    }
     // 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 = Dart_NewString("call");
-    // TODO(turnidge): Passing in 'mirror' here as the method owner
-    // seems wrong to me.  Investigate.
-    Dart_Handle func_mirror = CreateMethodMirror(func, func_name, mirror);
+    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);
 
-    Dart_Handle func_field_name = Dart_NewString("_function");
-    Dart_Handle result = Dart_SetField(mirror, func_field_name, func_mirror);
-    if (Dart_IsError(result)) {
-      return result;
+  } else {
+    Dart_Handle cls_name = Dart_NewString("_LocalInstanceMirrorImpl");
+    Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
+    if (Dart_IsError(cls)) {
+      return cls;
     }
+    Dart_Handle args[] = {
+      CreateVMReference(instance),
+      CreateLazyMirror(instance_cls),
+      instance,
+    };
+    return Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
   }
-  return mirror;
 }
 
 
 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;
     }
@@ skipping 192 matching lines @@
 }
 
 
 void HandleMirrorsMessage(Isolate* isolate,
                           Dart_Port reply_port,
                           const Instance& message) {
   UNIMPLEMENTED();
 }
 
 }  // namespace dart