Continue improving the documentation for the vm service protocol.

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 5284 matching lines @@
   ASSERT(IsRedirectingFactory());
   const Object& obj = Object::Handle(raw_ptr()->data_);
   ASSERT(!obj.IsNull());
   return RedirectionData::Cast(obj).type();
 }
 
 
 const char* Function::KindToCString(RawFunction::Kind kind) {
   switch (kind) {
     case RawFunction::kRegularFunction:
-      return "kRegularFunction";
+      return "RegularFunction";
       break;
     case RawFunction::kClosureFunction:
-      return "kClosureFunction";
+      return "ClosureFunction";
       break;
     case RawFunction::kSignatureFunction:
-      return "kSignatureFunction";
+      return "SignatureFunction";
       break;
     case RawFunction::kGetterFunction:
-      return "kGetterFunction";
+      return "GetterFunction";
       break;
     case RawFunction::kSetterFunction:
-      return "kSetterFunction";
+      return "SetterFunction";
       break;
     case RawFunction::kConstructor:
-      return "kConstructor";
+      return "Constructor";
       break;
     case RawFunction::kImplicitGetter:
-      return "kImplicitGetter";
+      return "ImplicitGetter";
       break;
     case RawFunction::kImplicitSetter:
-      return "kImplicitSetter";
+      return "ImplicitSetter";
       break;
     case RawFunction::kImplicitStaticFinalGetter:
-      return "kImplicitStaticFinalGetter";
+      return "ImplicitStaticFinalGetter";
       break;
     case RawFunction::kMethodExtractor:
-      return "kMethodExtractor";
+      return "MethodExtractor";
       break;
     case RawFunction::kNoSuchMethodDispatcher:
-      return "kNoSuchMethodDispatcher";
+      return "NoSuchMethodDispatcher";
       break;
     case RawFunction::kInvokeFieldDispatcher:
-      return "kInvokeFieldDispatcher";
+      return "InvokeFieldDispatcher";
       break;
     case RawFunction::kIrregexpFunction:
-      return "kIrregexpFunction";
+      return "IrregexpFunction";
       break;
     default:
       UNREACHABLE();
       return NULL;
   }
 }
 
 
 void Function::SetRedirectionType(const Type& type) const {
   ASSERT(IsFactory());
@@ skipping 886 matching lines @@
   return result.raw();
 }
 
 RawFunction* Function::ImplicitClosureFunction() const {
   // Return the existing implicit closure function if any.
   if (implicit_closure_function() != Function::null()) {
     return implicit_closure_function();
   }
   ASSERT(!IsSignatureFunction() && !IsClosureFunction());
   // Create closure function.
-  const String& closure_name = String::Handle(name());
+  const String& closure_name = Symbols::ImplicitClosure();
   const Function& closure_function = Function::Handle(
       NewClosureFunction(closure_name, *this, token_pos()));
 
   // Set closure function's context scope.
   ContextScope& context_scope = ContextScope::Handle();
   if (is_static()) {
     context_scope = ContextScope::New(0);
   } else {
     context_scope = LocalScope::CreateImplicitClosureScope(*this);
   }
@@ skipping 313 matching lines @@
   const String& suffix = String::Handle(PrettyName());
   return String::Concat(tmp, suffix);
 }
 
 
 RawString* Function::QualifiedUserVisibleName() const {
   String& tmp = String::Handle();
   const Class& cls = Class::Handle(Owner());
 
   if (IsClosureFunction()) {
-    if (IsLocalFunction() && !IsImplicitClosureFunction()) {
+    if (IsLocalFunction()) {
       const Function& parent = Function::Handle(parent_function());
       tmp = parent.QualifiedUserVisibleName();
     } else {
       return UserVisibleName();
     }
   } else {
     if (cls.IsTopLevel()) {
       return UserVisibleName();
     } else {
       tmp = cls.UserVisibleName();
@@ skipping 218 matching lines @@
   ASSERT(!cls.IsNull());
   Error& err = Error::Handle();
   err ^= cls.EnsureIsFinalized(Isolate::Current());
   ASSERT(err.IsNull());
   JSONObject jsobj(stream);
   AddTypeProperties(&jsobj, "Function", JSONType(), ref);
   jsobj.AddProperty("id", GetFunctionServiceId(*this, cls));
   const String& user_name = String::Handle(PrettyName());
   const String& vm_name = String::Handle(name());
   AddNameProperties(&jsobj, user_name, vm_name);
-  if (cls.IsTopLevel()) {
-    const Library& library = Library::Handle(cls.library());
-    jsobj.AddProperty("owningLibrary", library);
-  } else {
-    jsobj.AddProperty("owningClass", cls);
-  }
   const Function& parent = Function::Handle(parent_function());
   if (!parent.IsNull()) {
-    jsobj.AddProperty("parent", parent);
+    jsobj.AddProperty("owner", parent);
+  } else if (cls.IsTopLevel()) {
+    const Library& library = Library::Handle(cls.library());
+    jsobj.AddProperty("owner", library);
+  } else {
+    jsobj.AddProperty("owner", cls);
   }
+
   const char* kind_string = Function::KindToCString(kind());
   jsobj.AddProperty("kind", kind_string);
   if (ref) {
     return;
   }
   jsobj.AddProperty("static", is_static());
   jsobj.AddProperty("const", is_const());
-  jsobj.AddProperty("optimizable", is_optimizable());
-  jsobj.AddProperty("inlinable", CanBeInlined());
-  jsobj.AddProperty("unoptimizedCode", Object::Handle(unoptimized_code()));
-  jsobj.AddProperty("usageCounter", usage_counter());
-  jsobj.AddProperty("optimizedCallSiteCount", optimized_call_site_count());
-  jsobj.AddProperty("code", Object::Handle(CurrentCode()));
-  jsobj.AddProperty("deoptimizations",
+  Code& code = Code::Handle(CurrentCode());
+  if (!code.IsNull()) {
+    jsobj.AddProperty("code", code);
+  }
+  jsobj.AddProperty("_optimizable", is_optimizable());
+  jsobj.AddProperty("_inlinable", CanBeInlined());
+  code = unoptimized_code();
+  if (!code.IsNull()) {
+    jsobj.AddProperty("_unoptimizedCode", code);
+  }
+  jsobj.AddProperty("_usageCounter", usage_counter());
+  jsobj.AddProperty("_optimizedCallSiteCount", optimized_call_site_count());
+  jsobj.AddProperty("_deoptimizations",
                     static_cast<intptr_t>(deoptimization_counter()));
 
   const Script& script = Script::Handle(this->script());
   if (!script.IsNull()) {
     jsobj.AddProperty("script", script);
     jsobj.AddProperty("tokenPos", token_pos());
     jsobj.AddProperty("endTokenPos", end_token_pos());
   }
 }
 
@@ skipping 328 matching lines @@
   }
 
   AbstractType& declared_type = AbstractType::Handle(type());
   jsobj.AddProperty("declaredType", declared_type);
   jsobj.AddProperty("static", is_static());
   jsobj.AddProperty("final", is_final());
   jsobj.AddProperty("const", is_const());
   if (ref) {
     return;
   }
-  jsobj.AddProperty("guardNullable", is_nullable());
+  jsobj.AddProperty("_guardNullable", is_nullable());
   if (guarded_cid() == kIllegalCid) {
-    jsobj.AddProperty("guardClass", "unknown");
+    jsobj.AddProperty("_guardClass", "unknown");
   } else if (guarded_cid() == kDynamicCid) {
-    jsobj.AddProperty("guardClass", "dynamic");
+    jsobj.AddProperty("_guardClass", "dynamic");
   } else {
     ClassTable* table = Isolate::Current()->class_table();
     ASSERT(table->IsValidIndex(guarded_cid()));
     cls ^= table->At(guarded_cid());
-    jsobj.AddProperty("guardClass", cls);
+    jsobj.AddProperty("_guardClass", cls);
   }
   if (guarded_list_length() == kUnknownFixedLength) {
-    jsobj.AddProperty("guardLength", "unknown");
+    jsobj.AddProperty("_guardLength", "unknown");
   } else if (guarded_list_length() == kNoFixedLength) {
-    jsobj.AddProperty("guardLength", "variable");
+    jsobj.AddProperty("_guardLength", "variable");
   } else {
-    jsobj.AddProperty("guardLength", guarded_list_length());
+    jsobj.AddProperty("_guardLength", guarded_list_length());
   }
   const Class& origin_cls = Class::Handle(origin());
   const Script& script = Script::Handle(origin_cls.script());
   if (!script.IsNull()) {
     jsobj.AddProperty("script", script);
     jsobj.AddProperty("tokenPos", token_pos());
   }
 }
 
 
@@ skipping 1289 matching lines @@
   ASSERT(!encoded_url.IsNull());
   const Library& lib = Library::Handle(FindLibrary());
   intptr_t lib_index = (lib.IsNull()) ? -1 : lib.index();
   jsobj.AddPropertyF("id", "libraries/%" Pd "/scripts/%s",
       lib_index, encoded_url.ToCString());
   jsobj.AddPropertyStr("name", name);
   jsobj.AddProperty("kind", GetKindAsCString());
   if (ref) {
     return;
   }
-  jsobj.AddProperty("owningLibrary", lib);
+  jsobj.AddProperty("library", lib);
   const String& source = String::Handle(Source());
   jsobj.AddPropertyStr("source", source);
 
   // Print the line number table
   {
     JSONArray tokenPosTable(&jsobj, "tokenPosTable");
 
     const GrowableObjectArray& lineNumberArray =
         GrowableObjectArray::Handle(GenerateLineNumberArray());
     Object& value = Object::Handle();
@@ skipping 3999 matching lines @@
   const Object& obj = Object::Handle(owner());
   return obj.IsFunction();
 }
 
 
 void Code::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   AddTypeProperties(&jsobj, "Code", JSONType(), ref);
   jsobj.AddPropertyF("id", "code/%" Px64"-%" Px "", compile_timestamp(),
                      EntryPoint());
-  jsobj.AddPropertyF("start", "%" Px "", EntryPoint());
-  jsobj.AddPropertyF("end", "%" Px "", EntryPoint() + Size());
-  jsobj.AddProperty("optimized", is_optimized());
-  jsobj.AddProperty("alive", is_alive());
-  const Object& obj = Object::Handle(owner());
+  const String& user_name = String::Handle(PrettyName());
+  const String& vm_name = String::Handle(Name());
+  AddNameProperties(&jsobj, user_name, vm_name);
   const bool is_stub = IsStubCode() || IsAllocationStubCode();
   if (is_stub) {
     jsobj.AddProperty("kind", "Stub");
   } else {
     jsobj.AddProperty("kind", "Dart");
   }
-  const String& user_name = String::Handle(PrettyName());
-  const String& vm_name = String::Handle(Name());
-  AddNameProperties(&jsobj, user_name, vm_name);
+  jsobj.AddProperty("_optimized", is_optimized());
+  if (ref) {
+    return;
+  }
+  const Object& obj = Object::Handle(owner());
   if (obj.IsFunction()) {
     jsobj.AddProperty("function", obj);
   } else {
     // Generate a fake function reference.
     JSONObject func(&jsobj, "function");
     func.AddProperty("type", "@Function");
     func.AddProperty("kind", "Stub");
     func.AddProperty("name", user_name.ToCString());
     AddNameProperties(&func, user_name, vm_name);
   }
-  if (ref) {
-    return;
-  }
+  jsobj.AddPropertyF("_startAddress", "%" Px "", EntryPoint());
+  jsobj.AddPropertyF("_endAddress", "%" Px "", EntryPoint() + Size());
+  jsobj.AddProperty("_alive", is_alive());
   const Array& array = Array::Handle(ObjectPool());
-  jsobj.AddProperty("objectPool", array);
+  jsobj.AddProperty("_objectPool", array);
   {
-    JSONArray jsarr(&jsobj, "disassembly");
+    JSONArray jsarr(&jsobj, "_disassembly");
     if (is_alive()) {
       // Only disassemble alive code objects.
       DisassembleToJSONStream formatter(jsarr);
       Disassemble(&formatter);
     }
   }
   const PcDescriptors& descriptors = PcDescriptors::Handle(pc_descriptors());
   if (!descriptors.IsNull()) {
-    JSONObject desc(&jsobj, "descriptors");
+    JSONObject desc(&jsobj, "_descriptors");
     descriptors.PrintToJSONObject(&desc, false);
   }
   const Array& inlined_function_table = Array::Handle(inlined_id_to_function());
   if (!inlined_function_table.IsNull()) {
-    JSONArray inlined_functions(&jsobj, "inlinedFunctions");
+    JSONArray inlined_functions(&jsobj, "_inlinedFunctions");
     Function& function = Function::Handle();
     for (intptr_t i = 0; i < inlined_function_table.Length(); i++) {
       function ^= inlined_function_table.At(i);
       ASSERT(!function.IsNull());
       inlined_functions.AddValue(function);
     }
   }
   const Array& intervals = Array::Handle(inlined_intervals());
   if (!intervals.IsNull()) {
     Smi& start = Smi::Handle();
     Smi& end = Smi::Handle();
     Smi& temp_smi = Smi::Handle();
-    JSONArray inline_intervals(&jsobj, "inlinedIntervals");
+    JSONArray inline_intervals(&jsobj, "_inlinedIntervals");
     for (intptr_t i = 0; i < intervals.Length() - Code::kInlIntNumEntries;
          i += Code::kInlIntNumEntries) {
       start ^= intervals.At(i + Code::kInlIntStart);
       if (start.IsNull()) {
         continue;
       }
       end ^= intervals.At(i + Code::kInlIntNumEntries + Code::kInlIntStart);
 
       // Format: [start, end, inline functions...]
       JSONArray inline_interval(&inline_intervals);
@@ skipping 8112 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart