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

test/cctest/test-strings.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 
 // Check that we can traverse very deep stacks of ConsStrings using
 // StringInputBuffer.  Check that Get(int) works on very deep stacks
 // of ConsStrings.  These operations may not be very fast, but they
 // should be possible without getting errors due to too deep recursion.
 
 #include <stdlib.h>
 
 #include "v8.h"
@@ skipping 44 matching lines @@
     }
     switch (gen() % 4) {
       case 0: {
         uc16 buf[2000];
         for (int j = 0; j < len; j++) {
           buf[j] = gen() % 65536;
         }
         building_blocks[i] =
             Factory::NewStringFromTwoByte(Vector<const uc16>(buf, len));
         for (int j = 0; j < len; j++) {
-          StringShape shape(*building_blocks[i]);
-          CHECK_EQ(buf[j], building_blocks[i]->Get(shape, j));
+          CHECK_EQ(buf[j], building_blocks[i]->Get(j));
         }
         break;
       }
       case 1: {
         char buf[2000];
         for (int j = 0; j < len; j++) {
           buf[j] = gen() % 128;
         }
         building_blocks[i] =
             Factory::NewStringFromAscii(Vector<const char>(buf, len));
         for (int j = 0; j < len; j++) {
-          StringShape shape(*building_blocks[i]);
-          CHECK_EQ(buf[j], building_blocks[i]->Get(shape, j));
+          CHECK_EQ(buf[j], building_blocks[i]->Get(j));
         }
         break;
       }
       case 2: {
         class Resource: public v8::String::ExternalStringResource,
                         public Malloced {
          public:
           explicit Resource(Vector<const uc16> string): data_(string.start()) {
             length_ = string.length();
           }
           virtual const uint16_t* data() const { return data_; }
           virtual size_t length() const { return length_; }
 
          private:
           const uc16* data_;
           size_t length_;
         };
         uc16* buf = NewArray<uc16>(len);
         for (int j = 0; j < len; j++) {
           buf[j] = gen() % 65536;
         }
         Resource* resource = new Resource(Vector<const uc16>(buf, len));
         building_blocks[i] = Factory::NewExternalStringFromTwoByte(resource);
         for (int j = 0; j < len; j++) {
-          StringShape shape(*building_blocks[i]);
-          CHECK_EQ(buf[j], building_blocks[i]->Get(shape, j));
+          CHECK_EQ(buf[j], building_blocks[i]->Get(j));
         }
         break;
       }
       case 3: {
         char* buf = NewArray<char>(len);
         for (int j = 0; j < len; j++) {
           buf[j] = gen() % 128;
         }
         building_blocks[i] =
             Factory::NewStringFromAscii(Vector<const char>(buf, len));
         for (int j = 0; j < len; j++) {
-          StringShape shape(*building_blocks[i]);
-          CHECK_EQ(buf[j], building_blocks[i]->Get(shape, j));
+          CHECK_EQ(buf[j], building_blocks[i]->Get(j));
         }
         DeleteArray<char>(buf);
         break;
       }
     }
   }
 }
 
 
 static Handle<String> ConstructLeft(
     Handle<String> building_blocks[NUMBER_OF_BUILDING_BLOCKS],
     int depth) {
   Handle<String> answer = Factory::NewStringFromAscii(CStrVector(""));
   for (int i = 0; i < depth; i++) {
     answer = Factory::NewConsString(
         answer,
-        StringShape(*answer),
-        building_blocks[i % NUMBER_OF_BUILDING_BLOCKS],
-        StringShape(*building_blocks[i % NUMBER_OF_BUILDING_BLOCKS]));
+        building_blocks[i % NUMBER_OF_BUILDING_BLOCKS]);
   }
   return answer;
 }
 
 
 static Handle<String> ConstructRight(
     Handle<String> building_blocks[NUMBER_OF_BUILDING_BLOCKS],
     int depth) {
   Handle<String> answer = Factory::NewStringFromAscii(CStrVector(""));
   for (int i = depth - 1; i >= 0; i--) {
     answer = Factory::NewConsString(
         building_blocks[i % NUMBER_OF_BUILDING_BLOCKS],
-        StringShape(*building_blocks[i % NUMBER_OF_BUILDING_BLOCKS]),
-        answer,
-        StringShape(*answer));
+        answer);
   }
   return answer;
 }
 
 
 static Handle<String> ConstructBalancedHelper(
     Handle<String> building_blocks[NUMBER_OF_BUILDING_BLOCKS],
     int from,
     int to) {
   ASSERT(to > from);
   if (to - from == 1) {
     return building_blocks[from % NUMBER_OF_BUILDING_BLOCKS];
   }
   if (to - from == 2) {
     return Factory::NewConsString(
         building_blocks[from % NUMBER_OF_BUILDING_BLOCKS],
-        StringShape(*building_blocks[from % NUMBER_OF_BUILDING_BLOCKS]),
-        building_blocks[(from+1) % NUMBER_OF_BUILDING_BLOCKS],
-        StringShape(*building_blocks[(from+1) % NUMBER_OF_BUILDING_BLOCKS]));
+        building_blocks[(from+1) % NUMBER_OF_BUILDING_BLOCKS]);
   }
   Handle<String> part1 =
     ConstructBalancedHelper(building_blocks, from, from + ((to - from) / 2));
   Handle<String> part2 =
     ConstructBalancedHelper(building_blocks, from + ((to - from) / 2), to);
-  return Factory::NewConsString(
-      part1,
-      StringShape(*part1),
-      part2,
-      StringShape(*part2));
+  return Factory::NewConsString(part1, part2);
 }
 
 
 static Handle<String> ConstructBalanced(
     Handle<String> building_blocks[NUMBER_OF_BUILDING_BLOCKS]) {
   return ConstructBalancedHelper(building_blocks, 0, DEEP_DEPTH);
 }
 
 
 static StringInputBuffer buffer;
@@ skipping 17 matching lines @@
 static void TraverseFirst(Handle<String> s1, Handle<String> s2, int chars) {
   int i = 0;
   buffer.Reset(*s1);
   StringInputBuffer buffer2(*s2);
   while (buffer.has_more() && i < chars) {
     CHECK(buffer2.has_more());
     uint16_t c = buffer.GetNext();
     CHECK_EQ(c, buffer2.GetNext());
     i++;
   }
-  s1->Get(StringShape(*s1), s1->length() - 1);
-  s2->Get(StringShape(*s2), s2->length() - 1);
+  s1->Get(s1->length() - 1);
+  s2->Get(s2->length() - 1);
 }
 
 
 TEST(Traverse) {
   printf("TestTraverse\n");
   InitializeVM();
   v8::HandleScope scope;
   Handle<String> building_blocks[NUMBER_OF_BUILDING_BLOCKS];
   InitializeBuildingBlocks(building_blocks);
   Handle<String> flat = ConstructBalanced(building_blocks);
@@ skipping 61 matching lines @@
   ASSERT(to > from);
   if (to - from <= 1)
     return SliceOf(building_blocks[from % NUMBER_OF_BUILDING_BLOCKS]);
   if (to - from == 2) {
     Handle<String> lhs = building_blocks[from % NUMBER_OF_BUILDING_BLOCKS];
     if (gen() % 2 == 0)
       lhs = SliceOf(lhs);
     Handle<String> rhs = building_blocks[(from+1) % NUMBER_OF_BUILDING_BLOCKS];
     if (gen() % 2 == 0)
       rhs = SliceOf(rhs);
-    return Factory::NewConsString(lhs,
-                                  StringShape(*lhs),
-                                  rhs,
-                                  StringShape(*rhs));
+    return Factory::NewConsString(lhs, rhs);
   }
   Handle<String> part1 =
     ConstructBalancedHelper(building_blocks, from, from + ((to - from) / 2));
   Handle<String> part2 =
     ConstructBalancedHelper(building_blocks, from + ((to - from) / 2), to);
-  Handle<String> branch = Factory::NewConsString(part1,
-                                                 StringShape(*part1),
-                                                 part2,
-                                                 StringShape(*part2));
+  Handle<String> branch = Factory::NewConsString(part1, part2);
   if (gen() % 2 == 0)
     return branch;
   return(SliceOf(branch));
 }
 
 
 TEST(Slice) {
   printf("TestSlice\n");
   InitializeVM();
   v8::HandleScope scope;
@@ skipping 19 matching lines @@
   v8::HandleScope scope;
 
   char* foo = NewArray<char>(DEEP_ASCII_DEPTH);
   for (int i = 0; i < DEEP_ASCII_DEPTH; i++) {
     foo[i] = "foo "[i % 4];
   }
   Handle<String> string =
       Factory::NewStringFromAscii(Vector<const char>(foo, DEEP_ASCII_DEPTH));
   Handle<String> foo_string = Factory::NewStringFromAscii(CStrVector("foo"));
   for (int i = 0; i < DEEP_ASCII_DEPTH; i += 10) {
-    string = Factory::NewConsString(string,
-                                    StringShape(*string),
-                                    foo_string,
-                                    StringShape(*foo_string));
+    string = Factory::NewConsString(string, foo_string);
   }
-  Handle<String> flat_string = Factory::NewConsString(string,
-                                                      StringShape(*string),
-                                                      foo_string,
-                                                      StringShape(*foo_string));
+  Handle<String> flat_string = Factory::NewConsString(string, foo_string);
   FlattenString(flat_string);
 
   for (int i = 0; i < 500; i++) {
     TraverseFirst(flat_string, string, DEEP_ASCII_DEPTH);
   }
   DeleteArray<char>(foo);
 }
 
 
 TEST(Utf8Conversion) {
@@ skipping 28 matching lines @@
     int written = mixed->WriteUtf8(buffer, i);
     CHECK_EQ(lengths[i], written);
     // Check that the contents are correct
     for (int j = 0; j < lengths[i]; j++)
       CHECK_EQ(as_utf8[j], static_cast<unsigned char>(buffer[j]));
     // Check that the rest of the buffer hasn't been touched
     for (int j = lengths[i]; j < 11; j++)
       CHECK_EQ(kNoChar, buffer[j]);
   }
 }