Simplify various name flavors in VM.

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 198 matching lines @@
 // The trailing . on the default constructor name is dropped:
 //
 //   List. -> List
 //
 // And so forth:
 //
 //   get:foo@6328321 -> foo
 //   _MyClass@6328321. -> _MyClass
 //   _MyClass@6328321.named -> _MyClass.named
 //
-RawString* String::IdentifierPrettyName(const String& name) {
+RawString* String::ScrubName(const String& name) {
   Zone* zone = Thread::Current()->zone();
+
+#if !defined(PRODUCT)

[Cutch, 2016/02/25 00:10:07]

NOT_IN_PRODUCT(
....
);

[regis, 2016/02/25 17:47:27]

Done.

   if (name.Equals(Symbols::TopLevel())) {
     // Name of invisible top-level class.
     return Symbols::Empty().raw();
   }
+#endif  // !defined(PRODUCT)
 
   const char* cname = name.ToCString();
   ASSERT(strlen(cname) == static_cast<size_t>(name.Length()));
   const intptr_t name_len = name.Length();
   // First remove all private name mangling.
   intptr_t start_pos = 0;
   GrowableArray<const char*> unmangled_segments;
   intptr_t sum_segment_len = 0;
   for (intptr_t i = 0; i < name_len; i++) {
     if ((cname[i] == '@') && ((i + 1) < name_len) &&
@@ skipping 24 matching lines @@
     // Append the last segment.
     const intptr_t segment_len = name.Length() - start_pos;
     sum_segment_len += segment_len;
     AppendSubString(zone, &unmangled_segments, cname, start_pos, segment_len);
   }
   if (unmangled_name == NULL) {
     // Merge unmangled_segments.
     unmangled_name = MergeSubStrings(zone, unmangled_segments, sum_segment_len);
   }
 
+#if !defined(PRODUCT)

[Cutch, 2016/02/25 00:10:07]

NOT_IN_PRODUCT(
....
);

[regis, 2016/02/25 17:47:27]

Done.

   intptr_t len = sum_segment_len;
   intptr_t start = 0;
   intptr_t dot_pos = -1;  // Position of '.' in the name, if any.
   bool is_setter = false;
   for (intptr_t i = start; i < len; i++) {
     if (unmangled_name[i] == ':') {
       if (start != 0) {
         // Reset and break.
         start = 0;
         dot_pos = -1;
@@ skipping 28 matching lines @@
   intptr_t final_len = end - start;
   AppendSubString(zone, &unmangled_segments, unmangled_name, start, final_len);
   if (is_setter) {
     const char* equals = Symbols::Equals().ToCString();
     const intptr_t equals_len = strlen(equals);
     AppendSubString(zone, &unmangled_segments, equals, 0, equals_len);
     final_len += equals_len;
   }
 
   unmangled_name = MergeSubStrings(zone, unmangled_segments, final_len);
+#endif  // !defined(PRODUCT)
 
   return Symbols::New(unmangled_name);
 }
 
 
-RawString* String::IdentifierPrettyNameRetainPrivate(const String& name) {
+RawString* String::ScrubNameRetainPrivate(const String& name) {
+#if defined(PRODUCT)
+  return name.raw();
+#else  // defined(PRODUCT)
   intptr_t len = name.Length();
   intptr_t start = 0;
   intptr_t at_pos = -1;  // Position of '@' in the name, if any.
   bool is_setter = false;
 
   for (intptr_t i = start; i < len; i++) {
     if (name.CharAt(i) == ':') {
       ASSERT(start == 0);  // Only one : is possible in getters or setters.
       if (name.CharAt(0) == 's') {
         is_setter = true;
@@ skipping 22 matching lines @@
       const String& pre_at =
           String::Handle(String::SubString(result, 0, at_pos - 4));
       const String& post_at =
           String::Handle(String::SubString(name, at_pos, len - at_pos));
       result = String::Concat(pre_at, Symbols::Equals());
       result = String::Concat(result, post_at);
     }
   }
 
   return result.raw();
+#endif  // defined(PRODUCT)
 }
 
 
 template<typename type>
 static bool IsSpecialCharacter(type value) {
   return ((value == '"') ||
           (value == '\n') ||
           (value == '\f') ||
           (value == '\b') ||
           (value == '\t') ||
@@ skipping 1535 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 {
-  return GeneratePrettyName();
+RawString* Class::ScrubbedName() const {
+  return String::ScrubName(String::Handle(Name()));
 }
 
 
 RawString* Class::UserVisibleName() const {
 #if defined(PRODUCT)
-  return raw_ptr()->name_;
+  return GenerateUserVisibleName();
 #else  // defined(PRODUCT)
   ASSERT(raw_ptr()->user_name_ != String::null());
   return raw_ptr()->user_name_;
 #endif  // defined(PRODUCT)
 }
 
 
 bool Class::IsInFullSnapshot() const {
   NoSafepointScope no_safepoint;
   return raw_ptr()->library_->ptr()->is_in_fullsnapshot_;
@@ skipping 1216 matching lines @@
   intptr_t instance_size = ExternalTypedData::InstanceSize();
   Class& result = Class::Handle(New<ExternalTypedData>(class_id));
   result.set_instance_size(instance_size);
   result.set_next_field_offset(ExternalTypedData::NextFieldOffset());
   result.set_is_prefinalized();
   return result.raw();
 }
 
 
 void Class::set_name(const String& value) const {
+  ASSERT(raw_ptr()->name_ == String::null());
   ASSERT(value.IsSymbol());
   StorePointer(&raw_ptr()->name_, value.raw());
 NOT_IN_PRODUCT(
   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);
   }
 )
 }
 
 
 NOT_IN_PRODUCT(
 void Class::set_user_name(const String& value) const {
   StorePointer(&raw_ptr()->user_name_, value.raw());
 }
 )
 
 
-RawString* Class::GeneratePrettyName() const {
-  const String& name = String::Handle(Name());
-  return String::IdentifierPrettyName(name);
-}
-
-
 RawString* Class::GenerateUserVisibleName() const {
   if (FLAG_show_internal_names) {
     return Name();
   }
+#if !defined(PRODUCT)

[Cutch, 2016/02/25 00:10:07]

NOT_IN_PRODUCT(
....
);

[regis, 2016/02/25 17:47:27]

Done.

   switch (id()) {
     case kNullCid:
       return Symbols::Null().raw();
     case kDynamicCid:
       return Symbols::Dynamic().raw();
     case kVoidCid:
       return Symbols::Void().raw();
     case kClassCid:
       return Symbols::Class().raw();
     case kUnresolvedClassCid:
@@ skipping 111 matching lines @@
       return Symbols::Float32x4List().raw();
     case kTypedDataFloat64x2ArrayCid:
     case kExternalTypedDataFloat64x2ArrayCid:
       return Symbols::Float64x2List().raw();
     case kTypedDataFloat32ArrayCid:
     case kExternalTypedDataFloat32ArrayCid:
       return Symbols::Float32List().raw();
     case kTypedDataFloat64ArrayCid:
     case kExternalTypedDataFloat64ArrayCid:
       return Symbols::Float64List().raw();
+#endif  // !defined(PRODUCT)

[Ivan Posva, 2016/02/25 00:22:14]

I don't think this will compile in PRODUCT, because half of the switch statement
survives.

How about:
NOT_IN_PRODUCT(
  switch(id()) {
    ... list of class ids and corresponding remappings ...
    // default: left out.
  })
  const String& name = ...
  return String::ScrubName(name);

[regis, 2016/02/25 00:34:12]

Indeed, it does not compile. A debug build does not build product, as I just
noticed while trying a release build on the shuttle :-)

I will fix it and upload a new version tomorrow. Is there an easy way I can test
a product build?

     default:
       const String& name = String::Handle(Name());
-      return String::IdentifierPrettyName(name);
+      return String::ScrubName(name);
   }
   UNREACHABLE();
 }
 
 
 void Class::set_script(const Script& value) const {
   StorePointer(&raw_ptr()->script_, value.raw());
 }
 
 
@@ skipping 3309 matching lines @@
   ASSERT(obj.IsPatchClass());
   return PatchClass::Cast(obj).script();
 }
 
 
 bool Function::HasOptimizedCode() const {
   return HasCode() && Code::Handle(CurrentCode()).is_optimized();
 }
 
 
-RawString* Function::PrettyName() const {
-  const String& str = String::Handle(name());
-  return String::IdentifierPrettyName(str);
+RawString* Function::ScrubbedName() const {
+  if (FLAG_show_internal_names) {
+    return name();
+  }
+  return String::ScrubName(String::Handle(name()));
 }
 
 
-const char* Function::QualifiedUserVisibleNameCString() const {
-  const String& str = String::Handle(QualifiedUserVisibleName());
-  return str.ToCString();
+RawString* Function::QualifiedName(NameVisibility name_visibility) const {
+  ASSERT(name_visibility != kInternalName);  // We never request it.
+  // A function's scrubbed name and its user visible name are identical.
+  String& result = String::Handle(ScrubbedName());
+  if (IsClosureFunction()) {
+    Function& fun = Function::Handle(raw());
+    while (fun.IsLocalFunction() && !fun.IsImplicitClosureFunction()) {
+      fun = fun.parent_function();
+      result = String::Concat(Symbols::Dot(), result, Heap::kOld);
+      result = String::Concat(
+          String::Handle(fun.ScrubbedName()), result, Heap::kOld);
+    }
+  }
+  const Class& cls = Class::Handle(Owner());
+  if (!cls.IsTopLevel()) {
+    result = String::Concat(Symbols::Dot(), result, Heap::kOld);
+    const String& cls_name = String::Handle(
+        name_visibility == kScrubbedName ? cls.ScrubbedName()
+                                         : cls.UserVisibleName());
+    result = String::Concat(cls_name, result, Heap::kOld);
+  }
+  return result.raw();
 }
 
 
-RawString* Function::UserVisibleName() const {
-  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(), Heap::kOld);
-  const String& suffix = String::Handle(PrettyName());
-  return String::Concat(tmp, suffix, Heap::kOld);
-}
-
-
-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());
-      tmp = parent.QualifiedUserVisibleName();
-    } else {
-      return UserVisibleName();
-    }
-  } else {
-    if (cls.IsTopLevel()) {
-      return UserVisibleName();
-    } else {
-      tmp = cls.UserVisibleName();
-    }
-  }
-  tmp = String::Concat(tmp, Symbols::Dot());
-  const String& suffix = String::Handle(UserVisibleName());
-  return String::Concat(tmp, suffix);
-}
-
-
 RawString* Function::GetSource() const {
   if (IsImplicitConstructor() || IsSignatureFunction()) {
     // We may need to handle more cases when the restrictions on mixins are
     // relaxed. In particular we might start associating some source with the
     // forwarding constructors when it becomes possible to specify a particular
     // constructor from the mixin to use.
     return String::null();
   }
   const Script& func_script = Script::Handle(script());
   const TokenStream& stream = TokenStream::Handle(func_script.tokens());
@@ skipping 468 matching lines @@
   if (new_owner.NumTypeParameters() > 0) {
     // Adjust the field type to refer to type parameters of the new owner.
     AbstractType& type = AbstractType::Handle(clone.type());
     type ^= type.CloneUninstantiated(new_owner);
     clone.SetFieldType(type);
   }
   return clone.raw();
 }
 
 
-RawString* Field::PrettyName() const {
-  const String& str = String::Handle(name());
-  return String::IdentifierPrettyName(str);
+RawString* Field::ScrubbedName() const {
+  if (FLAG_show_internal_names) {
+    return name();
+  }
+  return String::ScrubName(String::Handle(name()));
 }
 
 
-RawString* Field::UserVisibleName() const {
-  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 {
   ASSERT(Thread::Current()->IsMutatorThread());
   StoreSmi(&raw_ptr()->guarded_list_length_, Smi::New(list_length));
 }
 
@@ skipping 1733 matching lines @@
   return Symbols::FromConcatAll(pieces);
 }
 
 
 static RawString* MakeFunctionMetaName(const Function& func) {
   const String& cname =
       String::Handle(MakeClassMetaName(Class::Handle(func.origin())));
   GrowableHandlePtrArray<const String> pieces(Thread::Current()->zone(), 3);
   pieces.Add(cname);
   pieces.Add(Symbols::At());
-  pieces.Add(String::Handle(func.QualifiedPrettyName()));
+  pieces.Add(String::Handle(func.QualifiedScrubbedName()));
   return Symbols::FromConcatAll(pieces);
 }
 
 
 static RawString* MakeTypeParameterMetaName(const TypeParameter& param) {
   const String& cname = String::Handle(
       MakeClassMetaName(Class::Handle(param.parameterized_class())));
   GrowableHandlePtrArray<const String> pieces(Thread::Current()->zone(), 3);
   pieces.Add(cname);
   pieces.Add(Symbols::At());
@@ skipping 4039 matching lines @@
   Zone* zone = Thread::Current()->zone();
   if (IsStubCode()) {
     const char* name = StubCode::NameOfStub(EntryPoint());
     return zone->PrintToString("[stub: %s]", name);
   } else {
     return zone->PrintToString("Code entry:%" Px, EntryPoint());
   }
 }
 
 
-// Called by disassembler.
 RawString* Code::Name() 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(Symbols::New(name));
     return Symbols::FromConcat(Symbols::StubPrefix(), stub_name);
   } else if (obj.IsClass()) {
     // Allocation stub.
     const Class& cls = Class::Cast(obj);
-    String& cls_name = String::Handle(cls.Name());
+    String& cls_name = String::Handle(cls.ScrubbedName());
     ASSERT(!cls_name.IsNull());
     return Symbols::FromConcat(Symbols::AllocationStubFor(), cls_name);
   } else {
     ASSERT(obj.IsFunction());
     // Dart function.
-    return Function::Cast(obj).name();
+    return Function::Cast(obj).ScrubbedName();
   }
 }
 
 
-RawString* Code::PrettyName() const {
+RawString* Code::QualifiedName() 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).QualifiedPrettyName();
+  if (obj.IsFunction()) {
+    return Function::Cast(obj).QualifiedScrubbedName();
   }
+  return Name();
 }
 
 
 bool Code::IsAllocationStubCode() const {
   const Object& obj = Object::Handle(owner());
   return obj.IsClass();
 }
 
 
 bool Code::IsStubCode() const {
@@ skipping 1691 matching lines @@
       }
     }
   }
   (*trail)->Add(*this);
   (*trail)->Add(buddy);
   return false;
 }
 
 
 RawString* AbstractType::BuildName(NameVisibility name_visibility) const {
+  ASSERT(name_visibility != kScrubbedName);
   Zone* zone = Thread::Current()->zone();
   if (IsBoundedType()) {
     const AbstractType& type = AbstractType::Handle(
         BoundedType::Cast(*this).type());
-    if (name_visibility == kPrettyName) {
-      return type.BuildName(kPrettyName);
-    } else if (name_visibility == kUserVisibleName) {
+    if (name_visibility == kUserVisibleName) {
       return type.BuildName(kUserVisibleName);
     }
     GrowableHandlePtrArray<const String> pieces(zone, 5);
     String& type_name = String::Handle(zone, type.BuildName(kInternalName));
     pieces.Add(type_name);
     pieces.Add(Symbols::SpaceExtendsSpace());
     // Build the bound name without causing divergence.
     const AbstractType& bound = AbstractType::Handle(
         zone, BoundedType::Cast(*this).bound());
     String& bound_name = String::Handle(zone);
@@ skipping 49 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 6595 matching lines @@
   return UserTag::null();
 }
 
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart