Remove all uses of StringShape variables, since that has proven...

src/objects.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 557 matching lines @@
   return Construct(RETRY_AFTER_GC, value);
 }
 
 
 // Should a word be prefixed by 'a' or 'an' in order to read naturally in
 // English?  Returns false for non-ASCII or words that don't start with
 // a capital letter.  The a/an rule follows pronunciation in English.
 // We don't use the BBC's overcorrect "an historic occasion" though if
 // you speak a dialect you may well say "an 'istoric occasion".
 static bool AnWord(String* str) {
-  StringShape shape(str);
-  if (str->length(shape) == 0) return false;  // A nothing.
-  int c0 = str->Get(shape, 0);
-  int c1 = str->length(shape) > 1 ? str->Get(shape, 1) : 0;
+  if (str->length() == 0) return false;  // A nothing.
+  int c0 = str->Get(0);
+  int c1 = str->length() > 1 ? str->Get(1) : 0;
   if (c0 == 'U') {
     if (c1 > 'Z') {
       return true;  // An Umpire, but a UTF8String, a U.
     }
   } else if (c0 == 'A' || c0 == 'E' || c0 == 'I' || c0 == 'O') {
     return true;    // An Ape, an ABCBook.
   } else if ((c1 == 0 || (c1 >= 'A' && c1 <= 'Z')) &&
            (c0 == 'F' || c0 == 'H' || c0 == 'M' || c0 == 'N' || c0 == 'R' ||
             c0 == 'S' || c0 == 'X')) {
     return true;    // An MP3File, an M.
   }
   return false;
 }
 
 
-Object* String::TryFlatten(StringShape shape) {
+Object* String::TryFlatten() {
 #ifdef DEBUG
   // Do not attempt to flatten in debug mode when allocation is not
   // allowed.  This is to avoid an assertion failure when allocating.
   // Flattening strings is the only case where we always allow
   // allocation because no GC is performed if the allocation fails.
   if (!Heap::IsAllocationAllowed()) return this;
 #endif
 
-  switch (shape.representation_tag()) {
+  switch (StringShape(this).representation_tag()) {
     case kSlicedStringTag: {
       SlicedString* ss = SlicedString::cast(this);
       // The SlicedString constructor should ensure that there are no
       // SlicedStrings that are constructed directly on top of other
       // SlicedStrings.
       String* buf = ss->buffer();
       ASSERT(!buf->IsSlicedString());
-      Object* ok = buf->TryFlatten(StringShape(buf));
+      Object* ok = buf->TryFlatten();
       if (ok->IsFailure()) return ok;
       // Under certain circumstances (TryFlattenIfNotFlat fails in
       // String::Slice) we can have a cons string under a slice.
       // In this case we need to get the flat string out of the cons!
       if (StringShape(String::cast(ok)).IsCons()) {
         ss->set_buffer(ConsString::cast(ok)->first());
       }
       return this;
     }
     case kConsStringTag: {
       ConsString* cs = ConsString::cast(this);
       if (cs->second()->length() == 0) {
         return this;
       }
       // There's little point in putting the flat string in new space if the
       // cons string is in old space.  It can never get GCed until there is
       // an old space GC.
       PretenureFlag tenure = Heap::InNewSpace(this) ? NOT_TENURED : TENURED;
-      int len = length(shape);
+      int len = length();
       Object* object;
       String* result;
-      if (shape.IsAsciiRepresentation()) {
+      if (StringShape(this).IsAsciiRepresentation()) {
         object = Heap::AllocateRawAsciiString(len, tenure);
         if (object->IsFailure()) return object;
         result = String::cast(object);
         String* first = cs->first();
-        StringShape first_shape(first);
-        int first_length = first->length(first_shape);
+        int first_length = first->length();
         char* dest = SeqAsciiString::cast(result)->GetChars();
-        WriteToFlat(first, first_shape, dest, 0, first_length);
+        WriteToFlat(first, dest, 0, first_length);
         String* second = cs->second();
         WriteToFlat(second,
-                    StringShape(second),
                     dest + first_length,
                     0,
                     len - first_length);
       } else {
         object = Heap::AllocateRawTwoByteString(len, tenure);
         if (object->IsFailure()) return object;
         result = String::cast(object);
         uc16* dest = SeqTwoByteString::cast(result)->GetChars();
         String* first = cs->first();
-        StringShape first_shape(first);
-        int first_length = first->length(first_shape);
-        WriteToFlat(first, first_shape, dest, 0, first_length);
+        int first_length = first->length();
+        WriteToFlat(first, dest, 0, first_length);
         String* second = cs->second();
         WriteToFlat(second,
-                    StringShape(second),
                     dest + first_length,
                     0,
                     len - first_length);
       }
       cs->set_first(result);
       cs->set_second(Heap::empty_string());
       return this;
     }
     default:
       return this;
@@ skipping 81 matching lines @@
   }
 
   // Fill the remainder of the string with dead wood.
   int new_size = this->Size();  // Byte size of the external String object.
   Heap::CreateFillerObjectAt(this->address() + new_size, size - new_size);
   return true;
 }
 
 
 void String::StringShortPrint(StringStream* accumulator) {
-  StringShape shape(this);
-  int len = length(shape);
+  int len = length();
   if (len > kMaxMediumStringSize) {
     accumulator->Add("<Very long string[%u]>", len);
     return;
   }
 
   if (!LooksValid()) {
     accumulator->Add("<Invalid String>");
     return;
   }
 
   StringInputBuffer buf(this);
 
   bool truncated = false;
   if (len > kMaxShortPrintLength) {
     len = kMaxShortPrintLength;
     truncated = true;
   }
   bool ascii = true;
   for (int i = 0; i < len; i++) {
     int c = buf.GetNext();
 
     if (c < 32 || c >= 127) {
       ascii = false;
     }
   }
   buf.Reset(this);
   if (ascii) {
-    accumulator->Add("<String[%u]: ", length(shape));
+    accumulator->Add("<String[%u]: ", length());
     for (int i = 0; i < len; i++) {
       accumulator->Put(buf.GetNext());
     }
     accumulator->Put('>');
   } else {
     // Backslash indicates that the string contains control
     // characters and that backslashes are therefore escaped.
-    accumulator->Add("<String[%u]\\: ", length(shape));
+    accumulator->Add("<String[%u]\\: ", length());
     for (int i = 0; i < len; i++) {
       int c = buf.GetNext();
       if (c == '\n') {
         accumulator->Add("\\n");
       } else if (c == '\r') {
         accumulator->Add("\\r");
       } else if (c == '\\') {
         accumulator->Add("\\\\");
       } else if (c < 32 || c > 126) {
         accumulator->Add("\\x%02x", c);
@@ skipping 160 matching lines @@
 }
 
 
 int HeapObject::SlowSizeFromMap(Map* map) {
   // Avoid calling functions such as FixedArray::cast during GC, which
   // read map pointer of this object again.
   InstanceType instance_type = map->instance_type();
 
   if (instance_type < FIRST_NONSTRING_TYPE
       && (StringShape(instance_type).IsSequential())) {
-    StringShape shape(instance_type);
-    if (shape.IsAsciiRepresentation()) {
-      return reinterpret_cast<SeqAsciiString*>(this)->SeqAsciiStringSize(shape);
+    if (StringShape(instance_type).IsAsciiRepresentation()) {
+      SeqAsciiString* seq_ascii_this = reinterpret_cast<SeqAsciiString*>(this);
+      return seq_ascii_this->SeqAsciiStringSize(instance_type);
     } else {
       SeqTwoByteString* self = reinterpret_cast<SeqTwoByteString*>(this);
-      return self->SeqTwoByteStringSize(shape);
+      return self->SeqTwoByteStringSize(instance_type);
     }
   }
 
   switch (instance_type) {
     case FIXED_ARRAY_TYPE:
       return reinterpret_cast<FixedArray*>(this)->FixedArraySize();
     case BYTE_ARRAY_TYPE:
       return reinterpret_cast<ByteArray*>(this)->ByteArraySize();
     case CODE_TYPE:
       return reinterpret_cast<Code*>(this)->CodeSize();
@@ skipping 1554 matching lines @@
   AssertNoContextChange ncc;
 
   // Check access rights if needed.
   if (IsAccessCheckNeeded() &&
       !Top::MayNamedAccess(this, name, v8::ACCESS_SET)) {
     Top::ReportFailedAccessCheck(this, v8::ACCESS_SET);
     return Heap::undefined_value();
   }
 
   // Try to flatten before operating on the string.
-  name->TryFlattenIfNotFlat(StringShape(name));
+  name->TryFlattenIfNotFlat();
 
   // Check if there is an API defined callback object which prohibits
   // callback overwriting in this object or it's prototype chain.
   // This mechanism is needed for instance in a browser setting, where
   // certain accessors such as window.location should not be allowed
   // to be overwritten because allowing overwriting could potentially
   // cause security problems.
   LookupResult callback_result;
   LookupCallback(name, &callback_result);
   if (callback_result.IsValid()) {
@@ skipping 694 matching lines @@
 static StaticResource<StringInputBuffer> string_input_buffer;
 
 
 bool String::LooksValid() {
   if (!Heap::Contains(this)) return false;
   return true;
 }
 
 
 int String::Utf8Length() {
-  StringShape shape(this);
-  if (shape.IsAsciiRepresentation()) return length(shape);
+  if (StringShape(this).IsAsciiRepresentation()) return length();
   // Attempt to flatten before accessing the string.  It probably
   // doesn't make Utf8Length faster, but it is very likely that
   // the string will be accessed later (for example by WriteUtf8)
   // so it's still a good idea.
-  TryFlattenIfNotFlat(shape);  // shape is now no longer valid.
+  TryFlattenIfNotFlat();
   Access<StringInputBuffer> buffer(&string_input_buffer);
   buffer->Reset(0, this);
   int result = 0;
   while (buffer->has_more())
     result += unibrow::Utf8::Length(buffer->GetNext());
   return result;
 }
 
 
 Vector<const char> String::ToAsciiVector() {
-  StringShape shape(this);
-  ASSERT(shape.IsAsciiRepresentation());
-  ASSERT(IsFlat(shape));
+  ASSERT(StringShape(this).IsAsciiRepresentation());
+  ASSERT(IsFlat());
 
   int offset = 0;
-  int length = this->length(shape);
-  StringRepresentationTag string_tag = shape.representation_tag();
+  int length = this->length();
+  StringRepresentationTag string_tag = StringShape(this).representation_tag();
   String* string = this;
   if (string_tag == kSlicedStringTag) {
     SlicedString* sliced = SlicedString::cast(string);
     offset += sliced->start();
     string = sliced->buffer();
-    shape = StringShape(string);
-    string_tag = shape.representation_tag();
+    string_tag = StringShape(string).representation_tag();
   } else if (string_tag == kConsStringTag) {
     ConsString* cons = ConsString::cast(string);
-    ASSERT(cons->second()->length(StringShape(cons->second())) == 0);
+    ASSERT(cons->second()->length() == 0);
     string = cons->first();
-    shape = StringShape(string);
-    string_tag = shape.representation_tag();
+    string_tag = StringShape(string).representation_tag();
   }
   if (string_tag == kSeqStringTag) {
     SeqAsciiString* seq = SeqAsciiString::cast(string);
     char* start = seq->GetChars();
     return Vector<const char>(start + offset, length);
   }
   ASSERT(string_tag == kExternalStringTag);
   ExternalAsciiString* ext = ExternalAsciiString::cast(string);
   const char* start = ext->resource()->data();
   return Vector<const char>(start + offset, length);
 }
 
 
 Vector<const uc16> String::ToUC16Vector() {
-  StringShape shape(this);
-  ASSERT(shape.IsTwoByteRepresentation());
-  ASSERT(IsFlat(shape));
+  ASSERT(StringShape(this).IsTwoByteRepresentation());
+  ASSERT(IsFlat());
 
   int offset = 0;
-  int length = this->length(shape);
-  StringRepresentationTag string_tag = shape.representation_tag();
+  int length = this->length();
+  StringRepresentationTag string_tag = StringShape(this).representation_tag();
   String* string = this;
   if (string_tag == kSlicedStringTag) {
     SlicedString* sliced = SlicedString::cast(string);
     offset += sliced->start();
     string = String::cast(sliced->buffer());
-    shape = StringShape(string);
-    string_tag = shape.representation_tag();
+    string_tag = StringShape(string).representation_tag();
   } else if (string_tag == kConsStringTag) {
     ConsString* cons = ConsString::cast(string);
-    ASSERT(cons->second()->length(StringShape(cons->second())) == 0);
+    ASSERT(cons->second()->length() == 0);
     string = cons->first();
-    shape = StringShape(string);
-    string_tag = shape.representation_tag();
+    string_tag = StringShape(string).representation_tag();
   }
   if (string_tag == kSeqStringTag) {
     SeqTwoByteString* seq = SeqTwoByteString::cast(string);
     return Vector<const uc16>(seq->GetChars() + offset, length);
   }
   ASSERT(string_tag == kExternalStringTag);
   ExternalTwoByteString* ext = ExternalTwoByteString::cast(string);
   const uc16* start =
       reinterpret_cast<const uc16*>(ext->resource()->data());
   return Vector<const uc16>(start + offset, length);
@@ skipping 59 matching lines @@
   return ToCString(allow_nulls, robust_flag, 0, -1, length_return);
 }
 
 
 const uc16* String::GetTwoByteData() {
   return GetTwoByteData(0);
 }
 
 
 const uc16* String::GetTwoByteData(unsigned start) {
-  StringShape shape(this);
-  ASSERT(!shape.IsAsciiRepresentation());
-  switch (shape.representation_tag()) {
+  ASSERT(!StringShape(this).IsAsciiRepresentation());
+  switch (StringShape(this).representation_tag()) {
     case kSeqStringTag:
       return SeqTwoByteString::cast(this)->SeqTwoByteStringGetData(start);
     case kExternalStringTag:
       return ExternalTwoByteString::cast(this)->
         ExternalTwoByteStringGetData(start);
     case kSlicedStringTag: {
       SlicedString* sliced_string = SlicedString::cast(this);
       String* buffer = sliced_string->buffer();
       if (StringShape(buffer).IsCons()) {
         ConsString* cs = ConsString::cast(buffer);
         // Flattened string.
-        ASSERT(cs->second()->length(StringShape(cs->second())) == 0);
+        ASSERT(cs->second()->length() == 0);
         buffer = cs->first();
       }
       return buffer->GetTwoByteData(start + sliced_string->start());
     }
     case kConsStringTag:
       UNREACHABLE();
       return NULL;
   }
   UNREACHABLE();
   return NULL;
@@ skipping 82 matching lines @@
 // *AsciiStringReadBlock routines.
 const unibrow::byte* ConsString::ConsStringReadBlock(ReadBlockBuffer* rbb,
                                                      unsigned* offset_ptr,
                                                      unsigned max_chars) {
   ConsString* current = this;
   unsigned offset = *offset_ptr;
   int offset_correction = 0;
 
   while (true) {
     String* left = current->first();
-    StringShape left_shape(left);
-    unsigned left_length = (unsigned)left->length(left_shape);
+    unsigned left_length = (unsigned)left->length();
     if (left_length > offset &&
         (max_chars <= left_length - offset ||
          (rbb->capacity <= left_length - offset &&
           (max_chars = left_length - offset, true)))) {  // comma operator!
       // Left hand side only - iterate unless we have reached the bottom of
       // the cons tree.  The assignment on the left of the comma operator is
       // in order to make use of the fact that the -IntoBuffer routines can
       // produce at most 'capacity' characters.  This enables us to postpone
       // the point where we switch to the -IntoBuffer routines (below) in order
       // to maximize the chances of delegating a big chunk of work to the
       // efficient *AsciiStringReadBlock routines.
-      if (left_shape.IsCons()) {
+      if (StringShape(left).IsCons()) {
         current = ConsString::cast(left);
         continue;
       } else {
         const unibrow::byte* answer =
             String::ReadBlock(left, rbb, &offset, max_chars);
         *offset_ptr = offset + offset_correction;
         return answer;
       }
     } else if (left_length <= offset) {
       // Right hand side only - iterate unless we have reached the bottom of
@@ skipping 144 matching lines @@
 // (see AsciiStringReadBlock).
 const unibrow::byte* String::ReadBlock(String* input,
                                        ReadBlockBuffer* rbb,
                                        unsigned* offset_ptr,
                                        unsigned max_chars) {
   ASSERT(*offset_ptr <= static_cast<unsigned>(input->length()));
   if (max_chars == 0) {
     rbb->remaining = 0;
     return NULL;
   }
-  StringShape shape(input);
-  switch (shape.representation_tag()) {
+  switch (StringShape(input).representation_tag()) {
     case kSeqStringTag:
-      if (shape.IsAsciiRepresentation()) {
+      if (StringShape(input).IsAsciiRepresentation()) {
         SeqAsciiString* str = SeqAsciiString::cast(input);
         return str->SeqAsciiStringReadBlock(&rbb->remaining,
                                             offset_ptr,
                                             max_chars);
       } else {
         SeqTwoByteString* str = SeqTwoByteString::cast(input);
         str->SeqTwoByteStringReadBlockIntoBuffer(rbb,
                                                  offset_ptr,
                                                  max_chars);
         return rbb->util_buffer;
       }
     case kConsStringTag:
       return ConsString::cast(input)->ConsStringReadBlock(rbb,
                                                           offset_ptr,
                                                           max_chars);
     case kSlicedStringTag:
       return SlicedString::cast(input)->SlicedStringReadBlock(rbb,
                                                               offset_ptr,
                                                               max_chars);
     case kExternalStringTag:
-      if (shape.IsAsciiRepresentation()) {
+      if (StringShape(input).IsAsciiRepresentation()) {
         return ExternalAsciiString::cast(input)->ExternalAsciiStringReadBlock(
             &rbb->remaining,
             offset_ptr,
             max_chars);
       } else {
         ExternalTwoByteString::cast(input)->
             ExternalTwoByteStringReadBlockIntoBuffer(rbb,
                                                      offset_ptr,
                                                      max_chars);
         return rbb->util_buffer;
@@ skipping 31 matching lines @@
 
 FlatStringReader::~FlatStringReader() {
   ASSERT_EQ(top_, this);
   top_ = prev_;
 }
 
 
 void FlatStringReader::RefreshState() {
   if (str_ == NULL) return;
   Handle<String> str(str_);
-  StringShape shape(*str);
-  ASSERT(str->IsFlat(shape));
-  is_ascii_ = shape.IsAsciiRepresentation();
+  ASSERT(str->IsFlat());
+  is_ascii_ = StringShape(*str).IsAsciiRepresentation();
   if (is_ascii_) {
     start_ = str->ToAsciiVector().start();
   } else {
     start_ = str->ToUC16Vector().start();
   }
 }
 
 
 void FlatStringReader::PostGarbageCollectionProcessing() {
   FlatStringReader* current = top_;
@@ skipping 15 matching lines @@
 
 
 // This method determines the type of string involved and then copies
 // a whole chunk of characters into a buffer.  It can be used with strings
 // that have been glued together to form a ConsString and which must cooperate
 // to fill up a buffer.
 void String::ReadBlockIntoBuffer(String* input,
                                  ReadBlockBuffer* rbb,
                                  unsigned* offset_ptr,
                                  unsigned max_chars) {
-  StringShape shape(input);
-  ASSERT(*offset_ptr <= (unsigned)input->length(shape));
+  ASSERT(*offset_ptr <= (unsigned)input->length());
   if (max_chars == 0) return;
 
-  switch (shape.representation_tag()) {
+  switch (StringShape(input).representation_tag()) {
     case kSeqStringTag:
-      if (shape.IsAsciiRepresentation()) {
+      if (StringShape(input).IsAsciiRepresentation()) {
         SeqAsciiString::cast(input)->SeqAsciiStringReadBlockIntoBuffer(rbb,
                                                                  offset_ptr,
                                                                  max_chars);
         return;
       } else {
         SeqTwoByteString::cast(input)->SeqTwoByteStringReadBlockIntoBuffer(rbb,
                                                                      offset_ptr,
                                                                      max_chars);
         return;
       }
     case kConsStringTag:
       ConsString::cast(input)->ConsStringReadBlockIntoBuffer(rbb,
                                                              offset_ptr,
                                                              max_chars);
       return;
     case kSlicedStringTag:
       SlicedString::cast(input)->SlicedStringReadBlockIntoBuffer(rbb,
                                                                  offset_ptr,
                                                                  max_chars);
       return;
     case kExternalStringTag:
-      if (shape.IsAsciiRepresentation()) {
+      if (StringShape(input).IsAsciiRepresentation()) {
          ExternalAsciiString::cast(input)->
              ExternalAsciiStringReadBlockIntoBuffer(rbb, offset_ptr, max_chars);
        } else {
          ExternalTwoByteString::cast(input)->
              ExternalTwoByteStringReadBlockIntoBuffer(rbb,
                                                       offset_ptr,
                                                       max_chars);
        }
        return;
     default:
       break;
   }
 
   UNREACHABLE();
   return;
 }
 
 
 const unibrow::byte* String::ReadBlock(String* input,
                                        unibrow::byte* util_buffer,
                                        unsigned capacity,
                                        unsigned* remaining,
                                        unsigned* offset_ptr) {
-  StringShape shape(input);
-  ASSERT(*offset_ptr <= (unsigned)input->length(shape));
-  unsigned chars = input->length(shape) - *offset_ptr;
+  ASSERT(*offset_ptr <= (unsigned)input->length());
+  unsigned chars = input->length() - *offset_ptr;
   ReadBlockBuffer rbb(util_buffer, 0, capacity, 0);
   const unibrow::byte* answer = ReadBlock(input, &rbb, offset_ptr, chars);
-  ASSERT(rbb.remaining <= static_cast<unsigned>(input->length(shape)));
+  ASSERT(rbb.remaining <= static_cast<unsigned>(input->length()));
   *remaining = rbb.remaining;
   return answer;
 }
 
 
 const unibrow::byte* String::ReadBlock(String** raw_input,
                                        unibrow::byte* util_buffer,
                                        unsigned capacity,
                                        unsigned* remaining,
                                        unsigned* offset_ptr) {
-  StringShape shape(*raw_input);
   Handle<String> input(raw_input);
-  ASSERT(*offset_ptr <= (unsigned)input->length(shape));
-  unsigned chars = input->length(shape) - *offset_ptr;
+  ASSERT(*offset_ptr <= (unsigned)input->length());
+  unsigned chars = input->length() - *offset_ptr;
   if (chars > capacity) chars = capacity;
   ReadBlockBuffer rbb(util_buffer, 0, capacity, 0);
   ReadBlockIntoBuffer(*input, &rbb, offset_ptr, chars);
-  ASSERT(rbb.remaining <= static_cast<unsigned>(input->length(shape)));
+  ASSERT(rbb.remaining <= static_cast<unsigned>(input->length()));
   *remaining = rbb.remaining;
   return rbb.util_buffer;
 }
 
 
 // This will iterate unless the block of string data spans two 'halves' of
 // a ConsString, in which case it will recurse.  Since the block of string
 // data to be read has a maximum size this limits the maximum recursion
 // depth to something sane.  Since C++ does not have tail call recursion
 // elimination, the iteration must be explicit.
 void ConsString::ConsStringReadBlockIntoBuffer(ReadBlockBuffer* rbb,
                                                unsigned* offset_ptr,
                                                unsigned max_chars) {
   ConsString* current = this;
   unsigned offset = *offset_ptr;
   int offset_correction = 0;
 
   while (true) {
     String* left = current->first();
-    StringShape left_shape(left);
-    unsigned left_length = (unsigned)left->length(left_shape);
+    unsigned left_length = (unsigned)left->length();
     if (left_length > offset &&
       max_chars <= left_length - offset) {
       // Left hand side only - iterate unless we have reached the bottom of
       // the cons tree.
-      if (left_shape.IsCons()) {
+      if (StringShape(left).IsCons()) {
         current = ConsString::cast(left);
         continue;
       } else {
         String::ReadBlockIntoBuffer(left, rbb, &offset, max_chars);
         *offset_ptr = offset + offset_correction;
         return;
       }
     } else if (left_length <= offset) {
       // Right hand side only - iterate unless we have reached the bottom of
       // the cons tree.
@@ skipping 47 matching lines @@
   IteratePointers(v, kFirstOffset, kSecondOffset + kPointerSize);
 }
 
 
 uint16_t ConsString::ConsStringGet(int index) {
   ASSERT(index >= 0 && index < this->length());
 
   // Check for a flattened cons string
   if (second()->length() == 0) {
     String* left = first();
-    return left->Get(StringShape(left), index);
+    return left->Get(index);
   }
 
   String* string = String::cast(this);
-  StringShape shape(string);
 
   while (true) {
-    if (shape.IsCons()) {
+    if (StringShape(string).IsCons()) {
       ConsString* cons_string = ConsString::cast(string);
       String* left = cons_string->first();
-      StringShape left_shape(left);
-      if (left->length(left_shape) > index) {
+      if (left->length() > index) {
         string = left;
-        shape = left_shape;
       } else {
-        index -= left->length(left_shape);
+        index -= left->length();
         string = cons_string->second();
-        shape = StringShape(string);
       }
     } else {
-      return string->Get(shape, index);
+      return string->Get(index);
     }
   }
 
   UNREACHABLE();
   return 0;
 }
 
 
 template <typename sinkchar>
 void String::WriteToFlat(String* src,
-                         StringShape src_shape,
                          sinkchar* sink,
                          int f,
                          int t) {
   String* source = src;
-  StringShape shape = src_shape;
   int from = f;
   int to = t;
   while (true) {
-    ASSERT(0 <= from && from <= to && to <= source->length(shape));
-    switch (shape.full_representation_tag()) {
+    ASSERT(0 <= from && from <= to && to <= source->length());
+    switch (StringShape(source).full_representation_tag()) {
       case kAsciiStringTag | kExternalStringTag: {
         CopyChars(sink,
                   ExternalAsciiString::cast(source)->resource()->data() + from,
                   to - from);
         return;
       }
       case kTwoByteStringTag | kExternalStringTag: {
         const uc16* data =
             ExternalTwoByteString::cast(source)->resource()->data();
         CopyChars(sink,
@@ skipping 13 matching lines @@
                   to - from);
         return;
       }
       case kAsciiStringTag | kSlicedStringTag:
       case kTwoByteStringTag | kSlicedStringTag: {
         SlicedString* sliced_string = SlicedString::cast(source);
         int start = sliced_string->start();
         from += start;
         to += start;
         source = String::cast(sliced_string->buffer());
-        shape = StringShape(source);
         break;
       }
       case kAsciiStringTag | kConsStringTag:
       case kTwoByteStringTag | kConsStringTag: {
         ConsString* cons_string = ConsString::cast(source);
         String* first = cons_string->first();
-        StringShape first_shape(first);
-        int boundary = first->length(first_shape);
+        int boundary = first->length();
         if (to - boundary >= boundary - from) {
           // Right hand side is longer.  Recurse over left.
           if (from < boundary) {
-            WriteToFlat(first, first_shape, sink, from, boundary);
+            WriteToFlat(first, sink, from, boundary);
             sink += boundary - from;
             from = 0;
           } else {
             from -= boundary;
           }
           to -= boundary;
           source = cons_string->second();
-          shape = StringShape(source);
         } else {
           // Left hand side is longer.  Recurse over right.
           if (to > boundary) {
             String* second = cons_string->second();
             WriteToFlat(second,
-                        StringShape(second),
                         sink + boundary - from,
                         0,
                         to - boundary);
             to = boundary;
           }
           source = first;
-          shape = first_shape;
         }
         break;
       }
     }
   }
 }
 
 
 void SlicedString::SlicedStringIterateBody(ObjectVisitor* v) {
   IteratePointer(v, kBufferOffset);
 }
 
 
 uint16_t SlicedString::SlicedStringGet(int index) {
   ASSERT(index >= 0 && index < this->length());
   // Delegate to the buffer string.
   String* underlying = buffer();
-  return underlying->Get(StringShape(underlying), start() + index);
+  return underlying->Get(start() + index);
 }
 
 
 template <typename IteratorA, typename IteratorB>
 static inline bool CompareStringContents(IteratorA* ia, IteratorB* ib) {
   // General slow case check.  We know that the ia and ib iterators
   // have the same length.
   while (ia->has_more()) {
     uc32 ca = ia->GetNext();
     uc32 cb = ib->GetNext();
@@ skipping 43 matching lines @@
   }
   return true;
 }
 
 
 static StringInputBuffer string_compare_buffer_b;
 
 
 template <typename IteratorA>
 static inline bool CompareStringContentsPartial(IteratorA* ia, String* b) {
-  StringShape b_shape(b);
-  if (b->IsFlat(b_shape)) {
-    if (b_shape.IsAsciiRepresentation()) {
+  if (b->IsFlat()) {
+    if (StringShape(b).IsAsciiRepresentation()) {
       VectorIterator<char> ib(b->ToAsciiVector());
       return CompareStringContents(ia, &ib);
     } else {
       VectorIterator<uc16> ib(b->ToUC16Vector());
       return CompareStringContents(ia, &ib);
     }
   } else {
     string_compare_buffer_b.Reset(0, b);
     return CompareStringContents(ia, &string_compare_buffer_b);
   }
 }
 
 
 static StringInputBuffer string_compare_buffer_a;
 
 
-bool String::SlowEquals(StringShape this_shape,
-                        String* other,
-                        StringShape other_shape) {
+bool String::SlowEquals(String* other) {
   // Fast check: negative check with lengths.
-  int len = length(this_shape);
-  if (len != other->length(other_shape)) return false;
+  int len = length();
+  if (len != other->length()) return false;
   if (len == 0) return true;
 
   // Fast check: if hash code is computed for both strings
   // a fast negative check can be performed.
   if (HasHashCode() && other->HasHashCode()) {
     if (Hash() != other->Hash()) return false;
   }
 
-  if (this_shape.IsSequentialAscii() && other_shape.IsSequentialAscii()) {
+  if (StringShape(this).IsSequentialAscii() && StringShape(other).IsSequentialAscii()) {
     const char* str1 = SeqAsciiString::cast(this)->GetChars();
     const char* str2 = SeqAsciiString::cast(other)->GetChars();
     return CompareRawStringContents(Vector<const char>(str1, len),
                                     Vector<const char>(str2, len));
   }
 
-  if (this->IsFlat(this_shape)) {
-    if (this_shape.IsAsciiRepresentation()) {
+  if (this->IsFlat()) {
+    if (StringShape(this).IsAsciiRepresentation()) {
       Vector<const char> vec1 = this->ToAsciiVector();
-      if (other->IsFlat(other_shape)) {
-        if (other_shape.IsAsciiRepresentation()) {
+      if (other->IsFlat()) {
+        if (StringShape(other).IsAsciiRepresentation()) {
           Vector<const char> vec2 = other->ToAsciiVector();
           return CompareRawStringContents(vec1, vec2);
         } else {
           VectorIterator<char> buf1(vec1);
           VectorIterator<uc16> ib(other->ToUC16Vector());
           return CompareStringContents(&buf1, &ib);
         }
       } else {
         VectorIterator<char> buf1(vec1);
         string_compare_buffer_b.Reset(0, other);
         return CompareStringContents(&buf1, &string_compare_buffer_b);
       }
     } else {
       Vector<const uc16> vec1 = this->ToUC16Vector();
-      if (other->IsFlat(other_shape)) {
-        if (other_shape.IsAsciiRepresentation()) {
+      if (other->IsFlat()) {
+        if (StringShape(other).IsAsciiRepresentation()) {
           VectorIterator<uc16> buf1(vec1);
           VectorIterator<char> ib(other->ToAsciiVector());
           return CompareStringContents(&buf1, &ib);
         } else {
           Vector<const uc16> vec2(other->ToUC16Vector());
           return CompareRawStringContents(vec1, vec2);
         }
       } else {
         VectorIterator<uc16> buf1(vec1);
         string_compare_buffer_b.Reset(0, other);
@@ skipping 29 matching lines @@
   } else if (map == Heap::long_ascii_string_map()) {
     this->set_map(Heap::undetectable_long_ascii_string_map());
     return true;
   }
   // Rest cannot be marked as undetectable
   return false;
 }
 
 
 bool String::IsEqualTo(Vector<const char> str) {
-  StringShape this_shape(this);
-  int slen = length(this_shape);
+  int slen = length();
   Access<Scanner::Utf8Decoder> decoder(Scanner::utf8_decoder());
   decoder->Reset(str.start(), str.length());
   int i;
   for (i = 0; i < slen && decoder->has_more(); i++) {
     uc32 r = decoder->GetNext();
-    if (Get(this_shape, i) != r) return false;
+    if (Get(i) != r) return false;
   }
   return i == slen && !decoder->has_more();
 }
 
 
 uint32_t String::ComputeAndSetHash() {
   // Should only be call if hash code has not yet been computed.
   ASSERT(!(length_field() & kHashComputedMask));
 
   // Compute the hash code.
@@ skipping 33 matching lines @@
     if (result > 429496729U - ((d > 5) ? 1 : 0)) return false;
     result = (result * 10) + d;
   }
 
   *index = result;
   return true;
 }
 
 
 bool String::SlowAsArrayIndex(uint32_t* index) {
-  StringShape shape(this);
-  if (length(shape) <= kMaxCachedArrayIndexLength) {
+  if (length() <= kMaxCachedArrayIndexLength) {
     Hash();  // force computation of hash code
     uint32_t field = length_field();
     if ((field & kIsArrayIndexMask) == 0) return false;
     *index = (field & ((1 << kShortLengthShift) - 1)) >> kLongLengthShift;
     return true;
   } else {
     StringInputBuffer buffer(this);
-    return ComputeArrayIndex(&buffer, index, length(shape));
+    return ComputeArrayIndex(&buffer, index, length());
   }
 }
 
 
 static inline uint32_t HashField(uint32_t hash, bool is_array_index) {
   uint32_t result =
       (hash << String::kLongLengthShift) | String::kHashComputedMask;
   if (is_array_index) result |= String::kIsArrayIndexMask;
   return result;
 }
@@ skipping 40 matching lines @@
   // index.
   while (buffer->has_more()) {
     hasher.AddCharacterNoIndex(buffer->GetNext());
   }
 
   return hasher.GetHashField();
 }
 
 
 Object* String::Slice(int start, int end) {
-  StringShape shape(this);
-  if (start == 0 && end == length(shape)) return this;
-  if (shape.representation_tag() == kSlicedStringTag) {
+  if (start == 0 && end == length()) return this;
+  if (StringShape(this).representation_tag() == kSlicedStringTag) {
     // Translate slices of a SlicedString into slices of the
     // underlying string buffer.
     SlicedString* str = SlicedString::cast(this);
     String* buf = str->buffer();
     return Heap::AllocateSlicedString(buf,
                                       str->start() + start,
                                       str->start() + end);
   }
   Object* result = Heap::AllocateSlicedString(this, start, end);
   if (result->IsFailure()) {
     return result;
   }
   // Due to the way we retry after GC on allocation failure we are not allowed
   // to fail on allocation after this point.  This is the one-allocation rule.
 
   // Try to flatten a cons string that is under the sliced string.
   // This is to avoid memory leaks and possible stack overflows caused by
   // building 'towers' of sliced strings on cons strings.
   // This may fail due to an allocation failure (when a GC is needed), but it
   // will succeed often enough to avoid the problem.  We only have to do this
   // if Heap::AllocateSlicedString actually returned a SlicedString.  It will
   // return flat strings for small slices for efficiency reasons.
   String* answer = String::cast(result);
-  StringShape answer_shape(answer);
-  if (answer_shape.IsSliced() &&
-      shape.representation_tag() == kConsStringTag) {
-    TryFlatten(shape);
+  if (StringShape(answer).IsSliced() &&
+      StringShape(this).representation_tag() == kConsStringTag) {
+    TryFlatten();
     // If the flatten succeeded we might as well make the sliced string point
     // to the flat string rather than the cons string.
     String* second = ConsString::cast(this)->second();
-    if (second->length(StringShape(second)) == 0) {
+    if (second->length() == 0) {
       SlicedString::cast(answer)->set_buffer(ConsString::cast(this)->first());
     }
   }
   return answer;
 }
 
 
 void String::PrintOn(FILE* file) {
-  StringShape shape(this);
-  int length = this->length(shape);
+  int length = this->length();
   for (int i = 0; i < length; i++) {
-    fprintf(file, "%c", Get(shape, i));
+    fprintf(file, "%c", Get(i));
   }
 }
 
 
 void Map::CreateBackPointers() {
   DescriptorArray* descriptors = instance_descriptors();
   for (DescriptorReader r(descriptors); !r.eos(); r.advance()) {
     if (r.type() == MAP_TRANSITION) {
       // Get target.
       Map* target = Map::cast(r.GetValue());
@@ skipping 1535 matching lines @@
     if (storage) {
       element_dictionary()->CopyKeysTo(storage, filter);
     }
     counter = element_dictionary()->NumberOfElementsFilterAttributes(filter);
   }
 
   if (this->IsJSValue()) {
     Object* val = JSValue::cast(this)->value();
     if (val->IsString()) {
       String* str = String::cast(val);
-      StringShape shape(str);
       if (storage) {
-        for (int i = 0; i < str->length(shape); i++) {
+        for (int i = 0; i < str->length(); i++) {
           storage->set(counter + i, Smi::FromInt(i), SKIP_WRITE_BARRIER);
         }
       }
-      counter += str->length(shape);
+      counter += str->length();
     }
   }
   ASSERT(!storage || storage->length() == counter);
   return counter;
 }
 
 
 int JSObject::GetEnumElementKeys(FixedArray* storage) {
   return GetLocalElementKeys(storage,
                              static_cast<PropertyAttributes>(DONT_ENUM));
@@ skipping 227 matching lines @@
 
   bool IsMatch(Object* string) {
     return String::cast(string)->Equals(string_);
   }
 
   uint32_t Hash() { return string_->Hash(); }
 
   Object* GetObject() {
     // If the string is a cons string, attempt to flatten it so that
     // symbols will most often be flat strings.
-    StringShape shape(string_);
-    if (shape.IsCons()) {
+    if (StringShape(string_).IsCons()) {
       ConsString* cons_string = ConsString::cast(string_);
-      cons_string->TryFlatten(shape);
+      cons_string->TryFlatten();
       if (cons_string->second() == Heap::empty_string()) {
         string_ = cons_string->first();
       }
     }
     // Transform string to symbol if possible.
     Map* map = Heap::SymbolMapForString(string_);
     if (map != NULL) {
       string_->set_map(map);
       return string_;
     }
@@ skipping 1100 matching lines @@
   // No break point.
   if (break_point_objects()->IsUndefined()) return 0;
   // Single beak point.
   if (!break_point_objects()->IsFixedArray()) return 1;
   // Multiple break points.
   return FixedArray::cast(break_point_objects())->length();
 }
 
 
 } }  // namespace v8::internal