Allow externalization of canonical strings also. Only restrict canonical strings

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/bigint_operations.h"
@@ skipping 2247 matching lines @@
     if (name.CharAt(j) != accessor_name.CharAt(i)) {
       return false;
     }
   }
   return true;
 }
 
 
 RawFunction* Class::LookupFunction(const String& name) const {
   Isolate* isolate = Isolate::Current();
-  ASSERT(name.IsOneByteString());
   Array& funcs = Array::Handle(isolate, functions());
   if (funcs.IsNull()) {
     // This can occur, e.g., for Null classes.
     return Function::null();
   }
   Function& function = Function::Handle(isolate, Function::null());
   if (name.IsSymbol()) {
     // Quick Symbol compare.
     intptr_t len = funcs.Length();
     for (intptr_t i = 0; i < len; i++) {
@@ skipping 13 matching lines @@
       }
     }
   }
   // No function found.
   return Function::null();
 }
 
 
 RawFunction* Class::LookupFunctionAllowPrivate(const String& name) const {
   Isolate* isolate = Isolate::Current();
-  ASSERT(name.IsOneByteString());
   Array& funcs = Array::Handle(isolate, functions());
   if (funcs.IsNull()) {
     // This can occur, e.g., for Null classes.
     return Function::null();
   }
   Function& function = Function::Handle(isolate, Function::null());
   String& function_name = String::Handle(isolate, String::null());
   intptr_t len = funcs.Length();
   for (intptr_t i = 0; i < len; i++) {
     function ^= funcs.At(i);
     function_name ^= function.name();
-    if (OneByteString::EqualsIgnoringPrivateKey(function_name, name)) {
-      return function.raw();
+    if (String::EqualsIgnoringPrivateKey(function_name, name)) {
+        return function.raw();
     }
   }
   // No function found.
   return Function::null();
 }
 
 
 RawFunction* Class::LookupGetterFunction(const String& name) const {
   return LookupAccessorFunction(kGetterPrefix, kGetterPrefixLength, name);
 }
@@ skipping 72 matching lines @@
     }
     return field.raw();
   }
   // No field found.
   return Field::null();
 }
 
 
 RawField* Class::LookupField(const String& name) const {
   Isolate* isolate = Isolate::Current();
-  ASSERT(name.IsOneByteString());
   const Array& flds = Array::Handle(isolate, fields());
   Field& field = Field::Handle(isolate, Field::null());
   String& field_name = String::Handle(isolate, String::null());
   intptr_t len = flds.Length();
   for (intptr_t i = 0; i < len; i++) {
     field ^= flds.At(i);
     field_name ^= field.name();
-    if (OneByteString::EqualsIgnoringPrivateKey(field_name, name)) {
-      return field.raw();
+    if (String::EqualsIgnoringPrivateKey(field_name, name)) {
+        return field.raw();
     }
   }
   // No field found.
   return Field::null();
 }
 
 
 RawLibraryPrefix* Class::LookupLibraryPrefix(const String& name) const {
   Isolate* isolate = Isolate::Current();
   const Library& lib = Library::Handle(isolate, library());
@@ skipping 1532 matching lines @@
 
 
 RawFunction* Function::New(const String& name,
                            RawFunction::Kind kind,
                            bool is_static,
                            bool is_const,
                            bool is_abstract,
                            bool is_external,
                            const Object& owner,
                            intptr_t token_pos) {
-  ASSERT(name.IsOneByteString());
   ASSERT(!owner.IsNull());
   const Function& result = Function::Handle(Function::New());
   result.set_parameter_types(Object::empty_array());
   result.set_parameter_names(Object::empty_array());
   result.set_name(name);
   result.set_kind(kind);
   result.set_is_static(is_static);
   result.set_is_const(is_const);
   result.set_is_abstract(is_abstract);
   result.set_is_external(is_external);
@@ skipping 15 matching lines @@
     const ClosureData& data = ClosureData::Handle(ClosureData::New());
     result.set_data(data);
   }
   return result.raw();
 }
 
 
 RawFunction* Function::NewClosureFunction(const String& name,
                                           const Function& parent,
                                           intptr_t token_pos) {
-  ASSERT(name.IsOneByteString());
   ASSERT(!parent.IsNull());
   // Use the owner defining the parent function and not the class containing it.
   const Object& parent_owner = Object::Handle(parent.raw_ptr()->owner_);
   ASSERT(!parent_owner.IsNull());
   const Function& result = Function::Handle(
       Function::New(name,
                     RawFunction::kClosureFunction,
                     /* is_static = */ parent.is_static(),
                     /* is_const = */ false,
                     /* is_abstract = */ false,
@@ skipping 502 matching lines @@
   return reinterpret_cast<RawField*>(raw);
 }
 
 
 RawField* Field::New(const String& name,
                      bool is_static,
                      bool is_final,
                      bool is_const,
                      const Class& owner,
                      intptr_t token_pos) {
-  ASSERT(name.IsOneByteString());
   ASSERT(!owner.IsNull());
   const Field& result = Field::Handle(Field::New());
   result.set_name(name);
   result.set_is_static(is_static);
   if (is_static) {
     result.set_value(Instance::Handle());
   } else {
     result.SetOffset(0);
   }
   result.set_is_final(is_final);
@@ skipping 6313 matching lines @@
                                 Dart_PeerFinalizer cback) const {
   NoGCScope no_gc;
   ASSERT(array != NULL);
   intptr_t str_length = this->Length();
   ASSERT(length >= (str_length * this->CharSize()));
   intptr_t class_id = raw()->GetClassId();
   intptr_t used_size = 0;
   intptr_t original_size = 0;
   uword tags = raw_ptr()->tags_;
 
-  ASSERT(!IsCanonical());
+  ASSERT(!InVMHeap());
   if (class_id == kOneByteStringCid) {
     used_size = ExternalOneByteString::InstanceSize();
     original_size = OneByteString::InstanceSize(str_length);
     ASSERT(original_size >= used_size);
 
     // Copy the data into the external array.
     if (str_length > 0) {
       memmove(array, OneByteString::CharAddr(*this, 0), str_length);
     }
 
@@ skipping 76 matching lines @@
   return Transform(CaseMapping::ToUpper, str, space);
 }
 
 
 RawString* String::ToLowerCase(const String& str, Heap::Space space) {
   // TODO(cshapiro): create a fast-path for OneByteString instances.
   return Transform(CaseMapping::ToLower, str, space);
 }
 
 
+// Check to see if 'str1' matches 'str2' as is or
+// once the private key separator is stripped from str2.
+//
+// Things are made more complicated by the fact that constructors are
+// added *after* the private suffix, so "foo@123.named" should match
+// "foo.named".
+//
+// Also, the private suffix can occur more than once in the name, as in:
+//
+//    _ReceivePortImpl@6be832b._internal@6be832b
+//
+template<typename T1, typename T2>
+static bool EqualsIgnoringPrivateKey(const String& str1,
+                                     const String& str2) {
+  intptr_t len = str1.Length();
+  intptr_t str2_len = str2.Length();
+  if (len == str2_len) {
+    for (intptr_t i = 0; i < len; i++) {
+      if (T1::CharAt(str1, i) != T2::CharAt(str2, i)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  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) {
+      // 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;
+    }
+    str2_pos++;
+  }
+
+  // We have reached the end of mangled_name string.
+  ASSERT(pos == len);
+  return (str2_pos == str2_len);
+}
+
+
+#define EQUALS_IGNORING_PRIVATE_KEY(class_id, type, str1, str2)                \
+  switch (class_id) {                                                          \
+    case kOneByteStringCid :                                                   \
+      return dart::EqualsIgnoringPrivateKey<type, OneByteString>(str1, str2);  \
+    case kTwoByteStringCid :                                                   \
+      return dart::EqualsIgnoringPrivateKey<type, TwoByteString>(str1, str2);  \
+    case kExternalOneByteStringCid :                                           \
+      return dart::EqualsIgnoringPrivateKey<type, ExternalOneByteString>(str1, \
+                                                                         str2);\
+    case kExternalTwoByteStringCid :                                           \
+      return dart::EqualsIgnoringPrivateKey<type, ExternalTwoByteString>(str1, \
+                                                                         str2);\
+  }                                                                            \
+  UNREACHABLE();                                                               \
+
+
+bool String::EqualsIgnoringPrivateKey(const String& str1,
+                                      const String& str2) {
+  if (str1.raw() == str2.raw()) {
+    return true;  // Both handles point to the same raw instance.
+  }
+  NoGCScope no_gc;
+  intptr_t str1_class_id = str1.raw()->GetClassId();
+  intptr_t str2_class_id = str2.raw()->GetClassId();
+  switch (str1_class_id) {
+    case kOneByteStringCid :
+      EQUALS_IGNORING_PRIVATE_KEY(str2_class_id, OneByteString, str1, str2);
+      break;
+    case kTwoByteStringCid :
+      EQUALS_IGNORING_PRIVATE_KEY(str2_class_id, TwoByteString, str1, str2);
+      break;
+    case kExternalOneByteStringCid :
+      EQUALS_IGNORING_PRIVATE_KEY(str2_class_id,
+                                  ExternalOneByteString, str1, str2);
+      break;
+    case kExternalTwoByteStringCid :
+      EQUALS_IGNORING_PRIVATE_KEY(str2_class_id,
+                                  ExternalTwoByteString, str1, str2);
+      break;
+  }
+  UNREACHABLE();
+  return false;
+}
+
+
 bool String::CodePointIterator::Next() {
   ASSERT(index_ >= -1);
   intptr_t length = Utf16::Length(ch_);
   if (index_ < (end_ - length)) {
     index_ += length;
     ch_ = str_.CharAt(index_);
     if (Utf16::IsLeadSurrogate(ch_) && (index_ < (end_ - 1))) {
       int32_t ch2 = str_.CharAt(index_ + 1);
       if (Utf16::IsTrailSurrogate(ch2)) {
         ch_ = Utf16::Decode(ch_, ch2);
@@ skipping 33 matching lines @@
         *(CharAddr(dststr, index)) = *CharAddr(str, i);
         index += 1;
       }
     }
     return OneByteString::raw(dststr);
   }
   return OneByteString::null();
 }
 
 
-// Check to see if 'str1' matches 'str2' as is or
-// once the private key separator is stripped from str2.
-//
-// Things are made more complicated by the fact that constructors are
-// added *after* the private suffix, so "foo@123.named" should match
-// "foo.named".
-//
-// Also, the private suffix can occur more than once in the name, as in:
-//
-//    _ReceivePortImpl@6be832b._internal@6be832b
-//
-bool OneByteString::EqualsIgnoringPrivateKey(const String& str1,
-                                             const String& str2) {
-  ASSERT(str2.IsOneByteString());
-  if (str1.raw() == str2.raw()) {
-    return true;  // Both handles point to the same raw instance.
-  }
-  NoGCScope no_gc;
-  intptr_t len = str1.Length();
-  intptr_t str2_len = str2.Length();
-  if (len == str2_len) {
-    for (intptr_t i = 0; i < len; i++) {
-      if (*CharAddr(str1, i) != *CharAddr(str2, i)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  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 = *CharAddr(str1, pos);
-    pos++;
-
-    if (ch == Scanner::kPrivateKeySeparator) {
-      // Consume a private key separator.
-      while ((pos < len) && (*CharAddr(str1, pos) != '.')) {
-        pos++;
-      }
-      // Resume matching characters.
-      continue;
-    }
-    if ((str2_pos == str2_len) || (ch != *CharAddr(str2, str2_pos))) {
-      return false;
-    }
-    str2_pos++;
-  }
-
-  // We have reached the end of mangled_name string.
-  ASSERT(pos == len);
-  return (str2_pos == str2_len);
-}
-
-
 RawOneByteString* OneByteString::New(intptr_t len,
                                      Heap::Space space) {
   ASSERT(Isolate::Current() == Dart::vm_isolate() ||
          Isolate::Current()->object_store()->one_byte_string_class() !=
          Class::null());
   if (len < 0 || len > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in OneByteString::New: invalid len %"Pd"\n", len);
   }
   String& result = String::Handle();
@@ skipping 1515 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart