- Ensure that classes are finalized before their description is

runtime/vm/object.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 "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 3213 matching lines @@
     return;
   }
   const char* internal_class_name = String::Handle(Name()).ToCString();
   const char* user_visible_class_name =
       String::Handle(UserVisibleName()).ToCString();
   jsobj.AddProperty("type", JSONType(ref));
   jsobj.AddProperty("id", id());
   jsobj.AddProperty("name", internal_class_name);
   jsobj.AddProperty("user_name", user_visible_class_name);
   if (!ref) {
+    const Error& err = Error::Handle(EnsureIsFinalized(Isolate::Current()));
+    if (!err.IsNull()) {
+      jsobj.AddProperty("error", err);
+    }

[siva, 2013/11/21 19:11:19]

This now means classes which have not been compiled yet will start getting
compiled just because they are being browsed, i.e browsing has a side effect
here.

Do we want to instead just state that the class is not finalized and provide an
option to explode the class only if the user decides to do so?

     jsobj.AddProperty("implemented", is_implemented());
     jsobj.AddProperty("abstract", is_abstract());
     jsobj.AddProperty("patch", is_patch());
     jsobj.AddProperty("finalized", is_finalized());
     jsobj.AddProperty("const", is_const());
     jsobj.AddProperty("super", Class::Handle(SuperClass()));
     jsobj.AddProperty("library", Object::Handle(library()));
     {
       JSONArray fields_array(&jsobj, "fields");
       const Array& field_array = Array::Handle(fields());
@@ skipping 7375 matching lines @@
 
 const char* Error::ToCString() const {
   // Error is an abstract class.  We should never reach here.
   UNREACHABLE();
   return "Error";
 }
 
 
 void Error::PrintToJSONStream(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
+  jsobj.AddProperty("type", JSONType(false));
+  jsobj.AddProperty("error_msg", ToErrorCString());
 }
 
 
 RawApiError* ApiError::New() {
   ASSERT(Object::api_error_class() != Class::null());
   RawObject* raw = Object::Allocate(ApiError::kClassId,
                                     ApiError::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawApiError*>(raw);
 }
@@ skipping 25 matching lines @@
 }
 
 
 const char* ApiError::ToCString() const {
   return "ApiError";
 }
 
 
 void ApiError::PrintToJSONStream(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
+  jsobj.AddProperty("type", JSONType(false));
+  jsobj.AddProperty("error_msg", ToErrorCString());
 }
 
 
 RawLanguageError* LanguageError::New() {
   ASSERT(Object::language_error_class() != Class::null());
   RawObject* raw = Object::Allocate(LanguageError::kClassId,
                                     LanguageError::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawLanguageError*>(raw);
 }
@@ skipping 164 matching lines @@
 }
 
 
 const char* LanguageError::ToCString() const {
   return "LanguageError";
 }
 
 
 void LanguageError::PrintToJSONStream(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
+  jsobj.AddProperty("type", JSONType(false));
+  jsobj.AddProperty("error_msg", ToErrorCString());
 }
 
 
 RawUnhandledException* UnhandledException::New(const Instance& exception,
                                                const Instance& stacktrace,
                                                Heap::Space space) {
   ASSERT(Object::unhandled_exception_class() != Class::null());
   UnhandledException& result = UnhandledException::Handle();
   {
     RawObject* raw = Object::Allocate(UnhandledException::kClassId,
@@ skipping 54 matching lines @@
 
 
 const char* UnhandledException::ToCString() const {
   return "UnhandledException";
 }
 
 
 void UnhandledException::PrintToJSONStream(JSONStream* stream,
                                            bool ref) const {
   JSONObject jsobj(stream);
+  jsobj.AddProperty("type", JSONType(false));
+  jsobj.AddProperty("error_msg", ToErrorCString());
 }
 
 
 RawUnwindError* UnwindError::New(const String& message, Heap::Space space) {
   ASSERT(Object::unwind_error_class() != Class::null());
   UnwindError& result = UnwindError::Handle();
   {
     RawObject* raw = Object::Allocate(UnwindError::kClassId,
                                       UnwindError::InstanceSize(),
                                       space);
@@ skipping 16 matching lines @@
 }
 
 
 const char* UnwindError::ToCString() const {
   return "UnwindError";
 }
 
 
 void UnwindError::PrintToJSONStream(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
+  jsobj.AddProperty("type", JSONType(false));
+  jsobj.AddProperty("error_msg", ToErrorCString());
 }
 
 
 RawObject* Instance::Evaluate(const String& expr) const {
   const Class& cls = Class::Handle(clazz());
   const PatchClass& temp_class =
       PatchClass::Handle(MakeTempPatchClass(cls, expr));
   const String& eval_func_name = String::Handle(Symbols::New(":eval"));
   const Function& eval_func =
       Function::Handle(Function::New(eval_func_name,
@@ skipping 4941 matching lines @@
   return "_MirrorReference";
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
 }
 
 
 }  // namespace dart