Don't remap class/type names in the vm service.

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 1616 matching lines @@
 
 
 RawString* Class::Name() const {
   // TODO(turnidge): This assert fails for the fake kFreeListElement class.
   // Fix this.
   ASSERT(raw_ptr()->name_ != String::null());
   return raw_ptr()->name_;
 }
 
 
+RawString* Class::PrettyName() const {
+  ASSERT(raw_ptr()->pretty_name_ != String::null());
+  return raw_ptr()->pretty_name_;
+}
+
+
 RawString* Class::UserVisibleName() const {
   ASSERT(raw_ptr()->user_name_ != String::null());
   return raw_ptr()->user_name_;
 }
 
 
 RawType* Class::SignatureType() const {
   ASSERT(IsSignatureClass());
   const Function& function = Function::Handle(signature_function());
   ASSERT(!function.IsNull());
@@ skipping 1369 matching lines @@
 void Class::set_name(const String& value) const {
   ASSERT(value.IsSymbol());
   StorePointer(&raw_ptr()->name_, value.raw());
   if (raw_ptr()->user_name_ == String::null()) {
     // TODO(johnmccutchan): Eagerly set user name for VM isolate classes,
     // lazily set user name for the other classes.
     // Generate and set user_name.
     const String& user_name = String::Handle(GenerateUserVisibleName());
     set_user_name(user_name);
   }
+  if (raw_ptr()->pretty_name_ == String::null()) {
+    const String& pretty_name = String::Handle(GeneratePrettyName());
+    set_pretty_name(pretty_name);
+  }
 }
 
 
 void Class::set_user_name(const String& value) const {
   StorePointer(&raw_ptr()->user_name_, value.raw());
 }
 
 
+void Class::set_pretty_name(const String& value) const {
+  StorePointer(&raw_ptr()->pretty_name_, value.raw());
+}
+
+
+RawString* Class::GeneratePrettyName() const {
+  if (!IsCanonicalSignatureClass()) {
+    const String& name = String::Handle(Name());
+    return String::IdentifierPrettyName(name);
+  } else {
+    return Name();
+  }
+}
+
+
 RawString* Class::GenerateUserVisibleName() const {
   if (FLAG_show_internal_names) {
     return Name();
   }
   switch (id()) {
     case kNullCid:
       return Symbols::Null().raw();
     case kDynamicCid:
       return Symbols::Dynamic().raw();
     case kVoidCid:
@@ skipping 858 matching lines @@
 }
 
 
 void Class::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   if ((raw() == Class::null()) || (id() == kFreeListElement)) {
     jsobj.AddProperty("type", "Null");
     return;
   }
   const char* internal_class_name = String::Handle(Name()).ToCString();
-  const char* user_visible_class_name =
-      String::Handle(UserVisibleName()).ToCString();
+  const char* pretty_class_name =
+      String::Handle(PrettyName()).ToCString();
   jsobj.AddProperty("type", JSONType(ref));
   jsobj.AddPropertyF("id", "classes/%" Pd "", id());
   jsobj.AddProperty("name", internal_class_name);
-  jsobj.AddProperty("user_name", user_visible_class_name);
+  jsobj.AddProperty("user_name", pretty_class_name);
   if (ref) {
     return;
   }
 
   const Error& err = Error::Handle(EnsureIsFinalized(Isolate::Current()));
   if (!err.IsNull()) {
     jsobj.AddProperty("error", err);
   }
   jsobj.AddProperty("implemented", is_implemented());
   jsobj.AddProperty("abstract", is_abstract());
@@ skipping 63 matching lines @@
           subclasses_array.AddValue(subclass);
         }
       }
     }
   }
   {
     JSONObject typesRef(&jsobj, "canonicalTypes");
     typesRef.AddProperty("type", "@TypeList");
     typesRef.AddPropertyF("id", "classes/%" Pd "/types", id());
     jsobj.AddPropertyF("name", "canonical types of %s", internal_class_name);
-    jsobj.AddPropertyF("user_name", "canonical types of %s",
-                       user_visible_class_name);
+    jsobj.AddPropertyF("user_name", "canonical types of %s", pretty_class_name);
   }
 }
 
 
 void Class::InsertCanonicalConstant(intptr_t index,
                                     const Instance& constant) const {
   // The constant needs to be added to the list. Grow the list if it is full.
   Array& canonical_list = Array::Handle(constants());
   const intptr_t list_len = canonical_list.Length();
   if (index >= list_len) {
@@ skipping 232 matching lines @@
   // preserved when the table grows and the entries get rehashed. Use the ring.
   Isolate* isolate = Isolate::Current();
   ObjectStore* object_store = isolate->object_store();
   const Array& table = Array::Handle(object_store->canonical_type_arguments());
   ASSERT(table.Length() > 0);
   ObjectIdRing* ring = Isolate::Current()->object_id_ring();
   const intptr_t id = ring->GetIdForObject(raw());
   jsobj.AddProperty("type", JSONType(ref));
   jsobj.AddPropertyF("id", "objects/%" Pd "", id);
   const char* name = String::Handle(Name()).ToCString();
-  const char* user_name = String::Handle(UserVisibleName()).ToCString();
+  const char* pretty_name = String::Handle(PrettyName()).ToCString();
   jsobj.AddProperty("name", name);
-  jsobj.AddProperty("user_name", user_name);
+  jsobj.AddProperty("user_name", pretty_name);
   jsobj.AddProperty("length", Length());
   jsobj.AddProperty("num_instantiations", NumInstantiations());
   if (ref) {
     return;
   }
   {
     JSONArray jsarr(&jsobj, "types");
     AbstractType& type_arg = AbstractType::Handle();
     for (intptr_t i = 0; i < Length(); i++) {
       type_arg = TypeAt(i);
@@ skipping 1990 matching lines @@
   ASSERT(obj.IsPatchClass());
   return PatchClass::Cast(obj).Script();
 }
 
 
 bool Function::HasOptimizedCode() const {
   return HasCode() && Code::Handle(raw_ptr()->code_).is_optimized();
 }
 
 
+RawString* Function::PrettyName() const {
+  const String& str = String::Handle(name());
+  return String::IdentifierPrettyName(str);
+}
+
+
 RawString* Function::UserVisibleName() const {
-  const String& str = String::Handle(name());
-  return String::IdentifierPrettyName(str);
+  return PrettyName();
+}
+
+
+RawString* Function::QualifiedPrettyName() const {
+  String& tmp = String::Handle();
+  const Class& cls = Class::Handle(Owner());
+
+  if (IsClosureFunction()) {
+    if (IsLocalFunction() && !IsImplicitClosureFunction()) {
+      const Function& parent = Function::Handle(parent_function());
+      tmp = parent.QualifiedPrettyName();
+    } else {
+      return PrettyName();
+    }
+  } else {
+    if (cls.IsTopLevel()) {
+      return PrettyName();
+    } else {
+      tmp = cls.PrettyName();
+    }
+  }
+  tmp = String::Concat(tmp, Symbols::Dot());
+  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()) {
       const Function& parent = Function::Handle(parent_function());
@@ skipping 148 matching lines @@
                              static_str, abstract_str, kind_str, const_str) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, function_name,
               static_str, abstract_str, kind_str, const_str);
   return chars;
 }
 
 
 void Function::PrintJSONImpl(JSONStream* stream, bool ref) const {
   const char* internal_name = String::Handle(name()).ToCString();
-  const char* user_name =
-      String::Handle(UserVisibleName()).ToCString();
+  const char* pretty_name =
+      String::Handle(PrettyName()).ToCString();
   Class& cls = Class::Handle(Owner());
   ASSERT(!cls.IsNull());
   Error& err = Error::Handle();
   err ^= cls.EnsureIsFinalized(Isolate::Current());
   ASSERT(err.IsNull());
   intptr_t id = -1;
   const char* selector = NULL;
   if (IsNonImplicitClosureFunction()) {
     id = cls.FindClosureIndex(*this);
     selector = "closures";
@@ skipping 14 matching lines @@
   // id ring. Current known examples are signature functions of closures
   // and stubs like 'megamorphic_miss'.
   if (id < 0) {
     ObjectIdRing* ring = Isolate::Current()->object_id_ring();
     id = ring->GetIdForObject(raw());
     jsobj.AddPropertyF("id", "objects/%" Pd "", id);
   } else {
     jsobj.AddPropertyF("id", "classes/%" Pd "/%s/%" Pd "", cid, selector, id);
   }
   jsobj.AddProperty("name", internal_name);
-  jsobj.AddProperty("user_name", user_name);
+  jsobj.AddProperty("user_name", pretty_name);
   if (cls.IsTopLevel()) {
     const Library& library = Library::Handle(cls.library());
     jsobj.AddProperty("owner", library);
   } else {
     jsobj.AddProperty("owner", cls);
   }
   const Function& parent = Function::Handle(parent_function());
   if (!parent.IsNull()) {
     jsobj.AddProperty("parent", parent);
   }
@@ skipping 240 matching lines @@
       PatchClass::Handle(PatchClass::New(new_owner, owner));
   clone.set_owner(clone_owner);
   clone.set_dependent_code(Object::null_array());
   if (!clone.is_static()) {
     clone.SetOffset(0);
   }
   return clone.raw();
 }
 
 
+RawString* Field::PrettyName() const {
+  const String& str = String::Handle(name());
+  return String::IdentifierPrettyName(str);
+}
+
+
 RawString* Field::UserVisibleName() const {
-  const String& str = String::Handle(name());
-  return String::IdentifierPrettyName(str);
+  return PrettyName();
 }
 
 
 intptr_t Field::guarded_list_length() const {
   return Smi::Value(raw_ptr()->guarded_list_length_);
 }
 
 
 void Field::set_guarded_list_length(intptr_t list_length) const {
   raw_ptr()->guarded_list_length_ = Smi::New(list_length);
@@ skipping 31 matching lines @@
   intptr_t len =
       OS::SNPrint(NULL, 0, kFormat, cls_name, field_name, kF0, kF1, kF2) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, cls_name, field_name, kF0, kF1, kF2);
   return chars;
 }
 
 void Field::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   const char* internal_field_name = String::Handle(name()).ToCString();
-  const char* field_name = String::Handle(UserVisibleName()).ToCString();
+  const char* field_name = String::Handle(PrettyName()).ToCString();
   Class& cls = Class::Handle(owner());
   intptr_t id = cls.FindFieldIndex(*this);
   ASSERT(id >= 0);
   intptr_t cid = cls.id();
   jsobj.AddProperty("type", JSONType(ref));
   jsobj.AddPropertyF("id", "classes/%" Pd "/fields/%" Pd "", cid, id);
   jsobj.AddProperty("name", internal_field_name);
   jsobj.AddProperty("user_name", field_name);
   if (is_static()) {
     const Instance& valueObj = Instance::Handle(value());
@@ skipping 4852 matching lines @@
     ASSERT(!cls_name.IsNull());
     return String::Concat(Symbols::AllocationStubFor(), cls_name);
   } else {
     ASSERT(obj.IsFunction());
     // Dart function.
     return Function::Cast(obj).name();
   }
 }
 
 
-RawString* Code::UserName() const {
+RawString* Code::PrettyName() const {
   const Object& obj = Object::Handle(owner());
   if (obj.IsNull()) {
     // Regular stub.
     const char* name = StubCode::NameOfStub(EntryPoint());
     ASSERT(name != NULL);
     const String& stub_name = String::Handle(String::New(name));
     return String::Concat(Symbols::StubPrefix(), stub_name);
   } else if (obj.IsClass()) {
     // Allocation stub.
     const Class& cls = Class::Cast(obj);
     String& cls_name = String::Handle(cls.Name());
     ASSERT(!cls_name.IsNull());
     return String::Concat(Symbols::AllocationStubFor(), cls_name);
   } else {
     ASSERT(obj.IsFunction());
     // Dart function.
-    return Function::Cast(obj).QualifiedUserVisibleName();
+    return Function::Cast(obj).QualifiedPrettyName();
   }
 }
 
 
 void Code::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   jsobj.AddProperty("type", JSONType(ref));
   jsobj.AddPropertyF("id", "code/%" Px64"-%" Px "", compile_timestamp(),
                      EntryPoint());
   jsobj.AddPropertyF("start", "%" Px "", EntryPoint());
   jsobj.AddPropertyF("end", "%" Px "", EntryPoint() + Size());
   jsobj.AddProperty("is_optimized", is_optimized());
   jsobj.AddProperty("is_alive", is_alive());
   jsobj.AddProperty("kind", "Dart");
   const String& name = String::Handle(Name());
-  const String& user_name = String::Handle(UserName());
+  const String& pretty_name = String::Handle(PrettyName());
   const char* name_prefix = is_optimized() ? "*" : "";
   jsobj.AddPropertyF("name", "%s%s", name_prefix, name.ToCString());
-  jsobj.AddPropertyF("user_name", "%s%s", name_prefix, user_name.ToCString());
+  jsobj.AddPropertyF("user_name", "%s%s", name_prefix, pretty_name.ToCString());
   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.AddPropertyF("id", "functions/stub-%" Pd "", EntryPoint());
-    func.AddProperty("user_name", user_name.ToCString());
+    func.AddProperty("user_name", pretty_name.ToCString());
     func.AddProperty("name", name.ToCString());
   }
   if (ref) {
     return;
   }
   const Array& array = Array::Handle(ObjectPool());
   jsobj.AddProperty("object_pool", array);
   {
     JSONArray jsarr(&jsobj, "disassembly");
     if (is_alive()) {
@@ skipping 1504 matching lines @@
   }
   (*trail)->Add(*this);
   (*trail)->Add(buddy);
 }
 
 
 RawString* AbstractType::BuildName(NameVisibility name_visibility) const {
   if (IsBoundedType()) {
     const AbstractType& type = AbstractType::Handle(
         BoundedType::Cast(*this).type());
-    if (name_visibility == kUserVisibleName) {
+    if (name_visibility == kPrettyName) {
+      return type.BuildName(kPrettyName);
+    } else if (name_visibility == kUserVisibleName) {
       return type.BuildName(kUserVisibleName);
     }
     String& type_name = String::Handle(type.BuildName(kInternalName));
     type_name = String::Concat(type_name, Symbols::SpaceExtendsSpace());
     // Build the bound name without causing divergence.
     const AbstractType& bound = AbstractType::Handle(
         BoundedType::Cast(*this).bound());
     String& bound_name = String::Handle();
     if (bound.IsTypeParameter()) {
       bound_name = TypeParameter::Cast(bound).name();
@@ skipping 24 matching lines @@
     if (IsResolved() || !cls.IsMixinApplication()) {
       // Do not print the full vector, but only the declared type parameters.
       num_type_params = cls.NumTypeParameters();
     } else {
       // Do not print the type parameters of an unresolved mixin application,
       // since it would prematurely trigger the application of the mixin type.
       num_type_params = 0;
     }
     if (name_visibility == kInternalName) {
       class_name = cls.Name();
+    } else if (name_visibility == kPrettyName) {
+      class_name = cls.PrettyName();
     } else {
       ASSERT(name_visibility == kUserVisibleName);
       // Map internal types to their corresponding public interfaces.
       class_name = cls.UserVisibleName();
     }
     if (num_type_params > num_args) {
       first_type_param_index = 0;
       if (!IsFinalized() || IsBeingFinalized() || IsMalformed()) {
         // Most probably a malformed type. Do not fill up with "dynamic",
         // but use actual vector.
@@ skipping 826 matching lines @@
     ASSERT(id >= 0);
     intptr_t cid = type_cls.id();
     jsobj.AddPropertyF("id", "classes/%" Pd "/types/%" Pd "", cid, id);
     jsobj.AddProperty("type_class", type_cls);
   } else {
     ObjectIdRing* ring = Isolate::Current()->object_id_ring();
     const intptr_t id = ring->GetIdForObject(raw());
     jsobj.AddPropertyF("id", "objects/%" Pd "", id);
   }
   const char* name = String::Handle(Name()).ToCString();
-  const char* user_name = String::Handle(UserVisibleName()).ToCString();
+  const char* pretty_name = String::Handle(PrettyName()).ToCString();
   jsobj.AddProperty("name", name);
-  jsobj.AddProperty("user_name", user_name);
+  jsobj.AddProperty("user_name", pretty_name);
   if (ref) {
     return;
   }
   jsobj.AddProperty("type_arguments", TypeArguments::Handle(arguments()));
 }
 
 
 bool TypeRef::IsInstantiated(GrowableObjectArray* trail) const {
   if (TestAndAddToTrail(&trail)) {
     return true;
@@ skipping 141 matching lines @@
 }
 
 
 void TypeRef::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   PrintSharedInstanceJSON(&jsobj, ref);
   ObjectIdRing* ring = Isolate::Current()->object_id_ring();
   const intptr_t id = ring->GetIdForObject(raw());
   jsobj.AddPropertyF("id", "objects/%" Pd "", id);
   const char* name = String::Handle(Name()).ToCString();
-  const char* user_name = String::Handle(UserVisibleName()).ToCString();
+  const char* pretty_name = String::Handle(PrettyName()).ToCString();
   jsobj.AddProperty("name", name);
-  jsobj.AddProperty("user_name", user_name);
+  jsobj.AddProperty("user_name", pretty_name);
   if (ref) {
     return;
   }
   jsobj.AddProperty("ref_type", AbstractType::Handle(type()));
 }
 
 
 void TypeParameter::set_is_finalized() const {
   ASSERT(!IsFinalized());
   set_type_state(RawTypeParameter::kFinalizedUninstantiated);
@@ skipping 194 matching lines @@
 }
 
 
 void TypeParameter::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   PrintSharedInstanceJSON(&jsobj, ref);
   ObjectIdRing* ring = Isolate::Current()->object_id_ring();
   const intptr_t id = ring->GetIdForObject(raw());
   jsobj.AddPropertyF("id", "objects/%" Pd "", id);
   const char* name = String::Handle(Name()).ToCString();
-  const char* user_name = String::Handle(UserVisibleName()).ToCString();
+  const char* pretty_name = String::Handle(PrettyName()).ToCString();
   jsobj.AddProperty("name", name);
-  jsobj.AddProperty("user_name", user_name);
+  jsobj.AddProperty("user_name", pretty_name);
   const Class& param_cls = Class::Handle(parameterized_class());
   jsobj.AddProperty("parameterized_class", param_cls);
   if (ref) {
     return;
   }
   jsobj.AddProperty("index", index());
   const AbstractType& upper_bound = AbstractType::Handle(bound());
   jsobj.AddProperty("upper_bound", upper_bound);
 }
 
@@ skipping 181 matching lines @@
 }
 
 
 void BoundedType::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   PrintSharedInstanceJSON(&jsobj, ref);
   ObjectIdRing* ring = Isolate::Current()->object_id_ring();
   const intptr_t id = ring->GetIdForObject(raw());
   jsobj.AddPropertyF("id", "objects/%" Pd "", id);
   const char* name = String::Handle(Name()).ToCString();
-  const char* user_name = String::Handle(UserVisibleName()).ToCString();
+  const char* pretty_name = String::Handle(PrettyName()).ToCString();
   jsobj.AddProperty("name", name);
-  jsobj.AddProperty("user_name", user_name);
+  jsobj.AddProperty("user_name", pretty_name);
   if (ref) {
     return;
   }
   jsobj.AddProperty("bounded_type", AbstractType::Handle(type()));
   jsobj.AddProperty("upper_bound", AbstractType::Handle(bound()));
 }
 
 
 intptr_t MixinAppType::token_pos() const {
   return AbstractType::Handle(MixinTypeAt(0)).token_pos();
@@ skipping 4001 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart