Add proper API for creating private symbols wrt a library.

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 @@
 
 static void MarkInvisibleFunctions() {
 #define MARK_FUNCTION(lib, class_name, function_name)                          \
   MarkFunctionAsInvisible(Library::Handle(Library::lib()),                     \
       #class_name, #function_name);                                            \
 
 INVISIBLE_LIST(MARK_FUNCTION)
 #undef MARK_FUNCTION
 }
 
+
 // Takes a vm internal name and makes it suitable for external user.
 //
 // Examples:
 //
 // Internal getter and setter prefixes are changed:
 //
 //   get:foo -> foo
 //   set:foo -> foo=
 //
 // Private name mangling is removed, possibly multiple times:
 //
 //   _ReceivePortImpl@6be832b -> _ReceivePortImpl
 //   _ReceivePortImpl@6be832b._internal@6be832b -> _ReceivePortImpl._internal
 //   _C@0x2b4ab9cc&_E@0x2b4ab9cc&_F@0x2b4ab9cc -> _C&_E&_F
 //
 // The trailing . on the default constructor name is dropped:
 //
 //   List. -> List
 //
 // And so forth:
 //
 //   get:foo@6be832b -> foo
 //   _MyClass@6b3832b. -> _MyClass
 //   _MyClass@6b3832b.named -> _MyClass.named
 //
-static RawString* IdentifierPrettyName(const String& name) {
+RawString* String::IdentifierPrettyName(const String& name) {
   if (name.Equals(Symbols::TopLevel())) {
     // Name of invisible top-level class.
     return Symbols::Empty().raw();
   }
 
   // First remove all private name mangling.
   String& unmangled_name = String::Handle(Symbols::Empty().raw());
   String& segment = String::Handle();
   intptr_t start_pos = 0;
   for (intptr_t i = 0; i < name.Length(); i++) {
@@ skipping 53 matching lines @@
 
   if (is_setter) {
     // Setters need to end with '='.
     return String::Concat(result, Symbols::Equals());
   }
 
   return result.raw();
 }
 
 
+RawString* String::IdentifierPrettyNameRetainPrivate(const String& name) {
+  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;
+      }
+      start = i + 1;
+    } else if (name.CharAt(i) == '@') {
+      ASSERT(at_pos == -1);  // Only one @ is supported.
+      at_pos = i;
+    }
+  }
+
+  if (start == 0) {
+    // This unmangled_name is fine as it is.
+    return name.raw();
+  }
+
+  String& result =
+      String::Handle(String::SubString(name, start, (len - start)));
+
+  if (is_setter) {
+    // Setters need to end with '='.
+    if (at_pos == -1) {
+      return String::Concat(result, Symbols::Equals());
+    } else {
+      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();
+}
+
+
 template<typename type>
 static bool IsSpecialCharacter(type value) {
   return ((value == '"') ||
           (value == '\n') ||
           (value == '\f') ||
           (value == '\b') ||
           (value == '\t') ||
           (value == '\v') ||
           (value == '\r') ||
           (value == '\\') ||
@@ skipping 1156 matching lines @@
       return Symbols::Float32x4List().raw();
     case kTypedDataFloat32ArrayCid:
     case kExternalTypedDataFloat32ArrayCid:
       return Symbols::Float32List().raw();
     case kTypedDataFloat64ArrayCid:
     case kExternalTypedDataFloat64ArrayCid:
       return Symbols::Float64List().raw();
     default:
       if (!IsSignatureClass()) {
         const String& name = String::Handle(Name());
-        return IdentifierPrettyName(name);
+        return String::IdentifierPrettyName(name);
       } else {
         return Name();
       }
   }
   UNREACHABLE();
 }
 
 
 RawType* Class::SignatureType() const {
   ASSERT(IsSignatureClass());
@@ skipping 3685 matching lines @@
 }
 
 
 bool Function::HasOptimizedCode() const {
   return HasCode() && Code::Handle(raw_ptr()->code_).is_optimized();
 }
 
 
 RawString* Function::UserVisibleName() const {
   const String& str = String::Handle(name());
-  return IdentifierPrettyName(str);
+  return String::IdentifierPrettyName(str);
 }
 
 
 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 396 matching lines @@
   clone.set_dependent_code(Object::null_array());
   if (!clone.is_static()) {
     clone.SetOffset(0);
   }
   return clone.raw();
 }
 
 
 RawString* Field::UserVisibleName() const {
   const String& str = String::Handle(name());
-  return IdentifierPrettyName(str);
+  return String::IdentifierPrettyName(str);
 }
 
 
 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 9794 matching lines @@
   return "_MirrorReference";
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
 }
 
 
 }  // namespace dart