Inline CreateTypedefMirror and get rid of LazyXXXMirror

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/dart_api_state.h"  // TODO(11742): Remove with CreateMirrorRef.
 #include "vm/bootstrap_natives.h"
@@ skipping 56 matching lines @@
 static Dart_Handle CreateMirrorReference(Dart_Handle handle) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& referent = Object::Handle(isolate, Api::UnwrapHandle(handle));
   const MirrorReference& reference =
        MirrorReference::Handle(MirrorReference::New(referent));
   return Api::NewHandle(isolate, reference.raw());
 }
 
 
-static Dart_Handle CreateLazyMirror(Dart_Handle target);
-
-
 static RawInstance* CreateParameterMirrorList(const Function& func) {
   HANDLESCOPE(Isolate::Current());
   const intptr_t param_cnt = func.num_fixed_parameters() -
                              func.NumImplicitParameters() +
                              func.NumOptionalParameters();
   const Array& results = Array::Handle(Array::New(param_cnt));
   const Array& args = Array::Handle(Array::New(3));
   args.SetAt(0, MirrorReference::Handle(MirrorReference::New(func)));
   Smi& pos = Smi::Handle();
   Instance& param = Instance::Handle();
   for (intptr_t i = 0; i < param_cnt; i++) {
     pos ^= Smi::New(i);
     args.SetAt(1, pos);
     args.SetAt(2, (i >= func.num_fixed_parameters()) ?
         Bool::True() : Bool::False());
     param ^= CreateMirror(Symbols::_LocalParameterMirrorImpl(), args);
     results.SetAt(i, param);
   }
   results.MakeImmutable();
   return results.raw();
 }
 
 
-static Dart_Handle CreateParameterMirrorListUsingApi(Dart_Handle func) {
-  ASSERT(Dart_IsFunction(func));
-  Isolate* isolate = Isolate::Current();
-  return Api::NewHandle(
-      isolate, CreateParameterMirrorList(Api::UnwrapFunctionHandle(
-          isolate, func)));
-}
-
-
-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 type = Dart_GetType(MirrorLib(), cls_name, 0, NULL);
-    Dart_Handle args[] = { Dart_LibraryUrl(target) };
-    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 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[] = {
-        CreateMirrorReference(target),
-        CreateLazyMirror(return_type),
-        CreateParameterMirrorListUsingApi(sig),
-      };
-      return Dart_New(type, Dart_Null(), ARRAY_SIZE(args), args);
-    } else {
-      Dart_Handle cls_name = NewString("_LazyTypeMirror");
-      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(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 type = Dart_GetType(MirrorLib(), cls_name, 0, NULL);
-
-    Dart_Handle args[] = { var_name, owner_mirror };
-    return Dart_New(type, Dart_Null(), ARRAY_SIZE(args), args);
-  }
-
-  UNREACHABLE();
-  return Dart_Null();
-}
-
-
 static RawInstance* CreateTypeVariableMirror(const TypeParameter& param,
                                              const Instance& owner_mirror) {
   const Array& args = Array::Handle(Array::New(3));
   args.SetAt(0, param);
   args.SetAt(1, String::Handle(param.name()));
   args.SetAt(2, owner_mirror);
   return CreateMirror(Symbols::_LocalTypeVariableMirrorImpl(), args);
 }
 
 
@@ skipping 11 matching lines @@
     type ^= args.TypeAt(i);
     ASSERT(type.IsTypeParameter());
     name ^= type.name();
     result.SetAt(2 * i, name);
     result.SetAt(2 * i + 1, type);
   }
   return result.raw();
 }
 
 
-static Dart_Handle CreateTypedefMirror(Dart_Handle cls,
-                                       Dart_Handle cls_name,
-                                       Dart_Handle owner_mirror) {
-  Dart_Handle mirror_cls_name = NewString("_LocalTypedefMirrorImpl");
-  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[] = {
-    CreateMirrorReference(cls),
-    cls_name,
-    owner_mirror,
-    CreateLazyMirror(referent),
-  };
-  Dart_Handle mirror =
-      Dart_New(mirror_type, Dart_Null(), ARRAY_SIZE(args), args);
-  return mirror;
+static RawInstance* CreateTypedefMirror(const Class& cls,
+                                        const Instance& owner_mirror) {
+  const Array& args = Array::Handle(Array::New(3));
+  args.SetAt(0, MirrorReference::Handle(MirrorReference::New(cls)));
+  args.SetAt(1, String::Handle(cls.UserVisibleName()));
+  args.SetAt(2, owner_mirror);
+  return CreateMirror(Symbols::_LocalTypedefMirrorImpl(), args);
 }
 
 
+static Dart_Handle CreateTypedefMirrorUsingApi(Dart_Handle cls,
+                                               Dart_Handle cls_name,
+                                               Dart_Handle owner_mirror) {
+  Isolate* isolate = Isolate::Current();
+  return Api::NewHandle(
+      isolate, CreateTypedefMirror(
+          Api::UnwrapClassHandle(isolate, cls),
+          Api::UnwrapInstanceHandle(isolate, owner_mirror)));
+}
+
+
 static Dart_Handle CreateClassMirrorUsingApi(Dart_Handle intf,
                                              Dart_Handle intf_name,
                                              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_mirror);
+    return CreateTypedefMirrorUsingApi(intf, intf_name, lib_mirror);
   }
 
   Dart_Handle cls_name = NewString("_LocalClassMirrorImpl");
   Dart_Handle type = Dart_GetType(MirrorLib(), cls_name, 0, NULL);
   if (Dart_IsError(type)) {
     return type;
   }
 
   Dart_Handle args[] = {
     CreateMirrorReference(intf),
@@ skipping 224 matching lines @@
 
   const Library& library = Library::Handle(klass.library());
   const Object& metadata = Object::Handle(library.GetMetadata(decl));
   if (metadata.IsError()) {
     ThrowInvokeError(Error::Cast(metadata));
   }
   return metadata.raw();
 }
 
 
+DEFINE_NATIVE_ENTRY(FunctionTypeMirror_parameters, 1) {
+  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
+  const Class& cls = Class::Handle(ref.GetClassReferent());
+  const Function& func = Function::Handle(cls.signature_function());
+  return CreateParameterMirrorList(func);
+}
+
+
+DEFINE_NATIVE_ENTRY(FunctionTypeMirror_return_type, 1) {
+  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
+  const Class& cls = Class::Handle(ref.GetClassReferent());
+  const Function& func = Function::Handle(cls.signature_function());
+  const AbstractType& return_type = AbstractType::Handle(func.result_type());
+  return CreateTypeMirror(return_type);
+}
+
+
 void HandleMirrorsMessage(Isolate* isolate,
                           Dart_Port reply_port,
                           const Instance& message) {
   UNIMPLEMENTED();
 }
 
 
 static bool FieldIsUninitialized(const Field& field) {
   ASSERT(!field.IsNull());
 
@@ skipping 803 matching lines @@
 DEFINE_NATIVE_ENTRY(MethodMirror_return_type, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
   const Function& func = Function::Handle(ref.GetFunctionReferent());
   // We handle constructors in Dart code.
   ASSERT(!func.IsConstructor());
   const AbstractType& return_type = AbstractType::Handle(func.result_type());
   return CreateTypeMirror(return_type);
 }
 
 
+DEFINE_NATIVE_ENTRY(TypedefMirror_referent, 1) {
+  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
+  const Class& cls = Class::Handle(ref.GetClassReferent());
+  const Function& sig_func = Function::Handle(cls.signature_function());
+  const Class& sig_cls = Class::Handle(sig_func.signature_class());
+  return MirrorReference::New(sig_cls);
+}
+
+
 DEFINE_NATIVE_ENTRY(ParameterMirror_type, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(Smi, pos, arguments->NativeArgAt(1));
   const Function& func = Function::Handle(ref.GetFunctionReferent());
   const AbstractType& param_type = AbstractType::Handle(func.ParameterTypeAt(
       func.NumImplicitParameters() + pos.Value()));
   return CreateTypeMirror(param_type);
 }
 
 
 DEFINE_NATIVE_ENTRY(VariableMirror_type, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
   const Field& field = Field::Handle(ref.GetFieldReferent());
 
   const AbstractType& type = AbstractType::Handle(field.type());
   return CreateTypeMirror(type);
 }
 
 }  // namespace dart