Minor changes based on the profile while running dart2js compile all.

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 "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 1911 matching lines @@
   }
   for (intptr_t i = 0, j = prefix_length; i < accessor_name_len; i++, j++) {
     if (name.CharAt(j) != accessor_name.CharAt(i)) {
       return false;
     }
   }
   return true;
 }
 
 
-// Check to see if mangled_name is equal to bare_name once the private
-// key separator is stripped from mangled_name.
-//
-// 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 EqualsIgnoringPrivate(const String& mangled_name,
-                           const String& bare_name) {
-  intptr_t mangled_len = mangled_name.Length();
-  intptr_t bare_len = bare_name.Length();
-  if (mangled_len < bare_len) {
-    // No way they can match.
-    return false;
-  }
-
-  intptr_t mangled_pos = 0;
-  intptr_t bare_pos = 0;
-  while (mangled_pos < mangled_len) {
-    int32_t mangled_char = mangled_name.CharAt(mangled_pos);
-    mangled_pos++;
-
-    if (mangled_char == Scanner::kPrivateKeySeparator) {
-      // Consume a private key separator.
-      while (mangled_pos < mangled_len &&
-             mangled_name.CharAt(mangled_pos) != '.') {
-        mangled_pos++;
-      }
-
-      // Resume matching characters.
-      continue;
-    }
-    if (bare_pos == bare_len || mangled_char != bare_name.CharAt(bare_pos)) {
-      return false;
-    }
-    bare_pos++;
-  }
-
-  // The strings match if we have reached the end of both strings.
-  return (mangled_pos == mangled_len &&
-          bare_pos == bare_len);
-}
-
-
 RawFunction* Class::LookupFunction(const String& name) const {
   Isolate* isolate = Isolate::Current();
+  ASSERT(name.IsOneByteString());
+  const OneByteString& lookup_name = OneByteString::Cast(name);
   Array& funcs = Array::Handle(isolate, functions());
   Function& function = Function::Handle(isolate, Function::null());
-  String& function_name = String::Handle(isolate, String::null());
+  OneByteString& function_name =
+      OneByteString::Handle(isolate, OneByteString::null());
   intptr_t len = funcs.Length();
   for (intptr_t i = 0; i < len; i++) {
     function ^= funcs.At(i);
     function_name ^= function.name();
-    if (function_name.Equals(name) ||
-        EqualsIgnoringPrivate(function_name, name)) {
+    if (function_name.EqualsIgnoringPrivate(lookup_name)) {
       return function.raw();
     }
   }
 
   // No function found.
   return Function::null();
 }
 
 
 RawFunction* Class::LookupGetterFunction(const String& name) const {
@@ skipping 74 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 OneByteString& lookup_name = OneByteString::Cast(name);
   const Array& flds = Array::Handle(isolate, fields());
   Field& field = Field::Handle(isolate, Field::null());
-  String& field_name = String::Handle(isolate, String::null());
+  OneByteString& field_name =
+      OneByteString::Handle(isolate, OneByteString::null());
   intptr_t len = flds.Length();
   for (intptr_t i = 0; i < len; i++) {
     field ^= flds.At(i);
     field_name ^= field.name();
-    if (field_name.Equals(name) || EqualsIgnoringPrivate(field_name, name)) {
+    if (field_name.EqualsIgnoringPrivate(lookup_name)) {
       return field.raw();
     }
   }
   // No field found.
   return Field::null();
 }
 
 
 RawLibraryPrefix* Class::LookupLibraryPrefix(const String& name) const {
   Isolate* isolate = Isolate::Current();
@@ skipping 1900 matching lines @@
                                     Heap::kOld);
   return reinterpret_cast<RawFunction*>(raw);
 }
 
 
 RawFunction* Function::New(const String& name,
                            RawFunction::Kind kind,
                            bool is_static,
                            bool is_const,
                            intptr_t token_pos) {
+  ASSERT(name.IsOneByteString());
   const Function& result = Function::Handle(Function::New());
   result.set_parameter_types(Array::Handle(Array::Empty()));
   result.set_parameter_names(Array::Handle(Array::Empty()));
   result.set_name(name);
   result.set_kind(kind);
   result.set_is_static(is_static);
   result.set_is_const(is_const);
   result.set_token_pos(token_pos);
   result.set_end_token_pos(token_pos);
   result.set_num_fixed_parameters(0);
   result.set_num_optional_parameters(0);
   result.set_usage_counter(0);
   result.set_deoptimization_counter(0);
   result.set_is_optimizable(true);
   result.set_is_native(false);
   return result.raw();
 }
 
 
 RawFunction* Function::NewClosureFunction(const String& name,
                                           const Function& parent,
                                           intptr_t token_pos) {
+  ASSERT(name.IsOneByteString());
   ASSERT(!parent.IsNull());
   const Class& parent_class = Class::Handle(parent.owner());
   ASSERT(!parent_class.IsNull());
   const Function& result = Function::Handle(
       Function::New(name,
                     RawFunction::kClosureFunction,
                     /* is_static = */ parent.is_static(),
                     /* is_const = */ false,
                     token_pos));
   result.set_parent_function(parent);
@@ skipping 315 matching lines @@
                                     Field::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawField*>(raw);
 }
 
 
 RawField* Field::New(const String& name,
                      bool is_static,
                      bool is_final,
                      intptr_t token_pos) {
+  ASSERT(name.IsOneByteString());
   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);
   result.set_token_pos(token_pos);
@@ skipping 3916 matching lines @@
     return true;
   }
 
   if (!other.IsString() || other.IsNull()) {
     return false;
   }
 
   const String& other_string = String::Cast(other);
   if (this->HasHash() && other_string.HasHash() &&
       (this->Hash() != other_string.Hash())) {
-    // Both sides have a hash code and it does not match.
-    return false;
+    return false;  // Both sides have a hash code and it does not match.
   }
-
-  intptr_t len = this->Length();
-  if (len != other_string.Length()) {
-    // Lengths don't match.
-    return false;
-  }
-
-  for (intptr_t i = 0; i < len; i++) {
-    if (this->CharAt(i) != other_string.CharAt(i)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-
-bool String::Equals(const String& str,
-                    intptr_t begin_index,
-                    intptr_t len) const {
-  ASSERT(begin_index >= 0);
-  ASSERT(begin_index == 0 || begin_index < str.Length());
-  ASSERT(len >= 0);
-  ASSERT(len <= str.Length());
-  if (len != this->Length()) {
-    // Lengths don't match.
-    return false;
-  }
-
-  for (intptr_t i = 0; i < len; i++) {
-    if (this->CharAt(i) != str.CharAt(begin_index + i)) {
-      return false;
-    }
-  }
-  return true;
+  return Equals(other_string, 0, other_string.Length());
 }
 
 
 bool String::Equals(const char* str) const {
   for (intptr_t i = 0; i < this->Length(); ++i) {
     if (*str == '\0') {
       // Lengths don't match.
       return false;
     }
     int32_t ch;
@@ skipping 709 matching lines @@
         *(dststr.CharAddr(index)) = *CharAddr(i);
         index += 1;
       }
     }
     return dststr.raw();
   }
   return OneByteString::null();
 }
 
 
+// Check to see if 'name' matches 'this' as is or
+// once the private key separator is stripped from name.
+//
+// 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::EqualsIgnoringPrivate(const OneByteString& name) const {
+  if (raw() == name.raw()) {
+    return true;  // Both handles point to the same raw instance.
+  }
+  intptr_t len = Length();
+  intptr_t name_len = name.Length();
+  if (len == name_len) {
+    for (intptr_t i = 0; i < len; i++) {
+      if (*(CharAddr(i)) != *(name.CharAddr(i))) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (len < name_len) {
+    return false;  // No way they can match.
+  }
+  intptr_t pos = 0;
+  intptr_t name_pos = 0;
+  while (pos < len) {
+    int32_t ch = *(CharAddr(pos));
+    pos++;
+
+    if (ch == Scanner::kPrivateKeySeparator) {
+      // Consume a private key separator.
+      while (pos < len && *(CharAddr(pos)) != '.') {
+        pos++;
+      }
+      // Resume matching characters.
+      continue;
+    }
+    if (name_pos == name_len || ch != *(name.CharAddr(name_pos))) {
+      return false;
+    }
+    name_pos++;
+  }
+
+  // We have reached the end of mangled_name string.
+  ASSERT(pos == len);
+  return (name_pos == name_len);
+}
+
+
 RawOneByteString* OneByteString::New(intptr_t len,
                                      Heap::Space space) {
   Isolate* isolate = Isolate::Current();
 
   const Class& cls =
       Class::Handle(isolate->object_store()->one_byte_string_class());
   OneByteString& result = OneByteString::Handle();
   {
     RawObject* raw = Object::Allocate(cls,
                                       OneByteString::InstanceSize(len),
@@ skipping 1661 matching lines @@
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart