Implement VariableMirror creation with non-API code. To break circular initialization, have them fi…

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 582 matching lines @@
     Api::False(),
     Api::False(),
     Api::False(),
     Api::False()
   };
   Dart_Handle mirror =
       Dart_New(mirror_type, Dart_Null(), ARRAY_SIZE(args), args);
   return mirror;
 }
 
+static RawInstance* CreateVariableMirror(const Field& field,
+                                         const Instance& owner_mirror) {
+  const MirrorReference& field_ref =
+      MirrorReference::Handle(MirrorReference::New());
+  field_ref.set_referent(field);
 
-static Dart_Handle CreateVariableMirror(Dart_Handle var,
-                                        Dart_Handle var_name,
-                                        Dart_Handle owner_mirror) {
-  ASSERT(Dart_IsVariable(var));
-  Dart_Handle cls_name = NewString("_LocalVariableMirrorImpl");
-  Dart_Handle type = Dart_GetType(MirrorLib(), cls_name, 0, NULL);
-  if (Dart_IsError(type)) {
-    return type;
-  }
+  const String& name = String::Handle(field.UserVisibleName());
 
-  bool is_static = false;
-  bool is_final = false;
+  const Array& args = Array::Handle(Array::New(6));
+  args.SetAt(0, field_ref);
+  args.SetAt(1, name);
+  args.SetAt(2, owner_mirror);
+  args.SetAt(3, Instance::Handle());  // Null for type.

[rmacnak, 2013/07/20 00:46:52]

We still pass this argument because ParameterMirrors, a subclass, use it.

+  args.SetAt(4, field.is_static() ? Bool::True() : Bool::False());
+  args.SetAt(5, field.is_final()  ? Bool::True() : Bool::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 var_type = Dart_VariableType(var);
-  if (Dart_IsError(var_type)) {
-    return var_type;
-  }
-
-  Dart_Handle args[] = {
-    CreateMirrorReference(var),
-    var_name,
-    owner_mirror,
-    CreateLazyMirror(var_type),
-    Dart_NewBoolean(is_static),
-    Dart_NewBoolean(is_final),
-  };
-  Dart_Handle mirror = Dart_New(type, Dart_Null(), ARRAY_SIZE(args), args);
-  return mirror;
+  return CreateMirror(Symbols::_LocalVariableMirrorImpl(), args);
 }
 
 
+static Dart_Handle CreateVariableMirrorUsingApi(Dart_Handle var,
+                                                Dart_Handle var_name,
+                                                Dart_Handle owner_mirror) {
+  ASSERT(Dart_IsVariable(var));
+  Isolate* isolate = Isolate::Current();
+  const Field& field = Api::UnwrapFieldHandle(isolate, var);
+  const Instance& owner_mirror_inst =
+      Api::UnwrapInstanceHandle(isolate, owner_mirror);
+  const Instance& var_mirror =
+      Instance::Handle(CreateVariableMirror(field, owner_mirror_inst));
+  return Api::NewHandle(isolate, var_mirror.raw());
+}
+
+
 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;
@@ skipping 122 matching lines @@
   if (Dart_IsError(result)) {
     return result;
   }
   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);
+    Dart_Handle var_mirror = CreateVariableMirrorUsingApi(var,
+                                                          var_name,
+                                                          owner_mirror);

[siva, 2013/07/22 05:25:32]

Looks like this is the only caller for CreateVariableMirrorUsingApi.
Since this function is already using API stuff why not just inline all the
unwrap stuff here and just call CreateVariableMirror.

Do you anticipate more callers for CreateVariableMirrorUsingApi ?

[rmacnak, 2013/07/22 19:05:09]

I don't. Inlined.

     if (Dart_IsError(var_mirror)) {
       return var_mirror;
     }
     result = MapAdd(map, var_name, var_mirror);
     if (Dart_IsError(result)) {
       return result;
     }
   }
   return Dart_True();
 }
@@ skipping 1114 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(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