Small cleanup: move all library private key code to Library class

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 6702 matching lines @@
         literal = String::EscapeSpecialCharacters(literal);
         literals.Add(literal);
       } else {
         literals.Add(literal);
       }
       if ((next != Token::kINTERPOL_VAR) && (next != Token::kINTERPOL_START)) {
         literals.Add(Symbols::DoubleQuotes());
       }
     } else if (curr == Token::kINTERPOL_VAR) {
       literals.Add(Symbols::Dollar());
-      if (literal.CharAt(0) == Scanner::kPrivateIdentifierStart) {
+      if (literal.CharAt(0) == Library::kPrivateIdentifierStart) {
         literal = String::SubString(literal, 0, literal.Length() - private_len);
       }
       literals.Add(literal);
     } else if (curr == Token::kIDENT) {
-      if (literal.CharAt(0) == Scanner::kPrivateIdentifierStart) {
+      if (literal.CharAt(0) == Library::kPrivateIdentifierStart) {
         literal = String::SubString(literal, 0, literal.Length() - private_len);
       }
       literals.Add(literal);
     } else {
       literals.Add(literal);
     }
     // Determine the separation text based on this current token.
     const String* separator = NULL;
     switch (curr) {
       case Token::kLBRACE:
@@ skipping 1102 matching lines @@
 
 
 // Add a name to the resolved name cache. This name resolves to the
 // given object in this library scope. obj may be null, which means
 // the name does not resolve to anything in this library scope.
 void Library::AddToResolvedNamesCache(const String& name,
                                       const Object& obj) const {
   if (!FLAG_use_lib_cache) {
     return;
   }
+  ASSERT(!Field::IsGetterName(name) && !Field::IsSetterName(name));

[hausner, 2014/02/10 21:07:35]

Unrelated but on purpose.

   const Array& cache = Array::Handle(resolved_names());
   // let N = cache.Length();
   // The entry cache[N-1] is used as a counter
   // The array entries [0..N-2] are used as cache entries.
   //   cache[i] contains the name of the entry
   //   cache[i+(N-1)/2] contains the resolved entity, or NULL if that name
   //   is not present in the library.
   const intptr_t counter_index = cache.Length() - 1;
   intptr_t cache_size = ResolvedNameCacheSize(cache);
   intptr_t index = name.Hash() % cache_size;
@@ skipping 567 matching lines @@
                                     Heap::kOld);
   return reinterpret_cast<RawLibrary*>(raw);
 }
 
 
 RawLibrary* Library::NewLibraryHelper(const String& url,
                                       bool import_core_lib) {
   const Library& result = Library::Handle(Library::New());
   result.StorePointer(&result.raw_ptr()->name_, Symbols::Empty().raw());
   result.StorePointer(&result.raw_ptr()->url_, url.raw());
-  result.raw_ptr()->private_key_ = Scanner::AllocatePrivateKey(result);
   result.raw_ptr()->resolved_names_ = Object::empty_array().raw();
   result.raw_ptr()->dictionary_ = Object::empty_array().raw();
   result.StorePointer(&result.raw_ptr()->metadata_,
                       GrowableObjectArray::New(4, Heap::kOld));
   result.raw_ptr()->anonymous_classes_ = Object::empty_array().raw();
   result.raw_ptr()->num_anonymous_ = 0;
   result.raw_ptr()->imports_ = Object::empty_array().raw();
   result.raw_ptr()->exports_ = Object::empty_array().raw();
   result.raw_ptr()->loaded_scripts_ = Array::null();
   result.set_native_entry_resolver(NULL);
   result.raw_ptr()->corelib_imported_ = true;
   result.set_debuggable(false);
   result.raw_ptr()->load_state_ = RawLibrary::kAllocated;
   result.raw_ptr()->index_ = -1;
   const intptr_t kInitialNameCacheSize = 64;
   result.InitResolvedNamesCache(kInitialNameCacheSize);
   result.InitClassDictionary();
   result.InitImportList();
+  result.AllocatePrivateKey();
   if (import_core_lib) {
     const Library& core_lib = Library::Handle(Library::CoreLibrary());
     ASSERT(!core_lib.IsNull());
     const Namespace& ns = Namespace::Handle(
         Namespace::New(core_lib, Object::null_array(), Object::null_array()));
     result.AddImport(ns);
   }
   return result.raw();
 }
 
@@ skipping 76 matching lines @@
   return Library::null();
 }
 
 
 RawError* Library::Patch(const Script& script) const {
   ASSERT(script.kind() == RawScript::kPatchTag);
   return Compiler::Compile(*this, script);
 }
 
 
+bool Library::IsPrivate(const String& name) {
+  if (ShouldBePrivate(name)) return true;
+  // Factory names: List._fromLiteral.
+  for (intptr_t i = 1; i < name.Length() - 1; i++) {
+    if (name.CharAt(i) == '.') {
+      if (name.CharAt(i + 1) == '_') {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+
 bool Library::IsKeyUsed(intptr_t key) {
   intptr_t lib_key;
   const GrowableObjectArray& libs = GrowableObjectArray::Handle(
       Isolate::Current()->object_store()->libraries());
   Library& lib = Library::Handle();
   String& lib_url = String::Handle();
   for (int i = 0; i < libs.Length(); i++) {
     lib ^= libs.At(i);
     lib_url ^= lib.url();
     lib_key = lib_url.Hash();
     if (lib_key == key) {
       return true;
     }
   }
   return false;
 }
 
 
-bool Library::IsPrivate(const String& name) {
-  if (ShouldBePrivate(name)) return true;
-  // Factory names: List._fromLiteral.
-  for (intptr_t i = 1; i < name.Length() - 1; i++) {
-    if (name.CharAt(i) == '.') {
-      if (name.CharAt(i + 1) == '_') {
-        return true;
-      }
-    }
+void Library::AllocatePrivateKey() const {
+  const String& url = String::Handle(this->url());
+  intptr_t key_value = url.Hash();
+  while (Library::IsKeyUsed(key_value)) {
+    key_value++;
   }
-  return false;
+  char private_key[32];
+  OS::SNPrint(private_key, sizeof(private_key),
+              "%c%#" Px "", kPrivateKeySeparator, key_value);
+  StorePointer(&raw_ptr()->private_key_, String::New(private_key, Heap::kOld));
 }
 
 
 const String& Library::PrivateCoreLibName(const String& member) {
   const Library& core_lib = Library::Handle(Library::CoreLibrary());
   const String& private_name = String::ZoneHandle(core_lib.PrivateName(member));
   return private_name;
 }
 
 
 RawClass* Library::LookupCoreClass(const String& class_name) {
   const Library& core_lib = Library::Handle(Library::CoreLibrary());
   String& name = String::Handle(class_name.raw());
-  if (class_name.CharAt(0) == Scanner::kPrivateIdentifierStart) {
+  if (class_name.CharAt(0) == kPrivateIdentifierStart) {
     // Private identifiers are mangled on a per library basis.
     name = String::Concat(name, String::Handle(core_lib.private_key()));
     name = Symbols::New(name);
   }
   return core_lib.LookupClass(name);
 }
 
 
 // Cannot handle qualified names properly as it only appends private key to
 // the end (e.g. _Alfa.foo -> _Alfa.foo@...).
@@ skipping 6880 matching lines @@
   }
   if (len < str2_len) {
     return false;  // No way they can match.
   }
   intptr_t pos = 0;
   intptr_t str2_pos = 0;
   while (pos < len) {
     int32_t ch = T1::CharAt(str1, pos);
     pos++;
 
-    if (ch == Scanner::kPrivateKeySeparator) {
+    if (ch == Library::kPrivateKeySeparator) {
       // Consume a private key separator.
       while ((pos < len) && (T1::CharAt(str1, pos) != '.')) {
         pos++;
       }
       // Resume matching characters.
       continue;
     }
     if ((str2_pos == str2_len) || (ch != T2::CharAt(str2, str2_pos))) {
       return false;
     }
@@ skipping 1829 matching lines @@
   return "_MirrorReference";
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   Instance::PrintToJSONStream(stream, ref);
 }
 
 
 }  // namespace dart