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

src/objects.h

 // 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 3121 matching lines @@
 
 
 // The characteristics of a string are stored in its map.  Retrieving these
 // few bits of information is moderately expensive, involving two memory
 // loads where the second is dependent on the first.  To improve efficiency
 // the shape of the string is given its own class so that it can be retrieved
 // once and used for several string operations.  A StringShape is small enough
 // to be passed by value and is immutable, but be aware that flattening a
 // string can potentially alter its shape.  Also be aware that a GC caused by
 // something else can alter the shape of a string due to ConsString
-// shortcutting.
-//
-// Most of the methods designed to interrogate a string as to its exact nature
-// have been made into methods on StringShape in order to encourage the use of
-// StringShape.  The String class has both a length() and a length(StringShape)
-// operation.  The former is simpler to type, but the latter is faster if you
-// need the StringShape for some other operation immediately before or after.
+// shortcutting.  Keeping these restrictions in mind has proven to be error-
+// prone and so we no longer put StringShapes in variables unless there is a
+// concrete performance benefit at that particular point in the code.
 class StringShape BASE_EMBEDDED {
  public:
   inline explicit StringShape(String* s);
   inline explicit StringShape(Map* s);
   inline explicit StringShape(InstanceType t);
   inline bool IsAsciiRepresentation();
   inline bool IsTwoByteRepresentation();
   inline bool IsSequential();
   inline bool IsExternal();
   inline bool IsCons();
@@ skipping 28 matching lines @@
 //
 // Ecma-262:
 //  4.3.16 String Value
 //    A string value is a member of the type String and is a finite
 //    ordered sequence of zero or more 16-bit unsigned integer values.
 //
 // All string values have a length field.
 class String: public HeapObject {
  public:
   // Get and set the length of the string.
-  // Fast version.
-  inline int length(StringShape shape);
-  // Easy version.
   inline int length();
   inline void set_length(int value);
 
   // Get and set the uninterpreted length field of the string.  Notice
   // that the length field is also used to cache the hash value of
   // strings.  In order to get or set the actual length of the string
   // use the length() and set_length methods.
   inline uint32_t length_field();
   inline void set_length_field(uint32_t value);
 
   // Get and set individual two byte chars in the string.
-  inline void Set(StringShape shape, int index, uint16_t value);
+  inline void Set(int index, uint16_t value);
   // Get individual two byte char in the string.  Repeated calls
   // to this method are not efficient unless the string is flat.
-  inline uint16_t Get(StringShape shape, int index);
+  inline uint16_t Get(int index);
 
   // Try to flatten the top level ConsString that is hiding behind this
   // string.  This is a no-op unless the string is a ConsString or a
   // SlicedString.  Flatten mutates the ConsString and might return a
   // failure.
-  Object* TryFlatten(StringShape shape);
+  Object* TryFlatten();
 
   // Try to flatten the string.  Checks first inline to see if it is necessary.
   // Do not handle allocation failures.  After calling TryFlattenIfNotFlat, the
   // string could still be a ConsString, in which case a failure is returned.
   // Use FlattenString from Handles.cc to be sure to flatten.
-  inline Object* TryFlattenIfNotFlat(StringShape shape);
+  inline Object* TryFlattenIfNotFlat();
 
   Vector<const char> ToAsciiVector();
   Vector<const uc16> ToUC16Vector();
 
   // Mark the string as an undetectable object. It only applies to
   // ascii and two byte string types.
   bool MarkAsUndetectable();
 
   // Slice the string and return a substring.
   Object* Slice(int from, int to);
@@ skipping 58 matching lines @@
 
   // For use during stack traces.  Performs rudimentary sanity check.
   bool LooksValid();
 
   // Dispatched behavior.
   void StringShortPrint(StringStream* accumulator);
 #ifdef DEBUG
   void StringPrint();
   void StringVerify();
 #endif
-  inline bool IsFlat(StringShape shape);
+  inline bool IsFlat();
 
   // Layout description.
   static const int kLengthOffset = HeapObject::kHeaderSize;
   static const int kSize = kLengthOffset + kIntSize;
 
   // Limits on sizes of different types of strings.
   static const int kMaxShortStringSize = 63;
   static const int kMaxMediumStringSize = 16383;
 
   static const int kMaxArrayIndexSize = 10;
@@ skipping 41 matching lines @@
                                         unsigned* offset);
   static const unibrow::byte* ReadBlock(String** input,
                                         unibrow::byte* util_buffer,
                                         unsigned capacity,
                                         unsigned* remaining,
                                         unsigned* offset);
 
   // Helper function for flattening strings.
   template <typename sinkchar>
   static void WriteToFlat(String* source,
-                          StringShape shape,
                           sinkchar* sink,
                           int from,
                           int to);
 
  protected:
   class ReadBlockBuffer {
    public:
     ReadBlockBuffer(unibrow::byte* util_buffer_,
                     unsigned cursor_,
                     unsigned capacity_,
@@ skipping 20 matching lines @@
                                                unsigned* offset,
                                                unsigned max_chars);
   static void ReadBlockIntoBuffer(String* input,
                                   ReadBlockBuffer* buffer,
                                   unsigned* offset_ptr,
                                   unsigned max_chars);
 
  private:
   // Slow case of String::Equals.  This implementation works on any strings
   // but it is most efficient on strings that are almost flat.
-  bool SlowEquals(StringShape this_shape,
-                  String* other,
-                  StringShape other_shape);
+  bool SlowEquals(String* other);
 
   // Slow case of AsArrayIndex.
   bool SlowAsArrayIndex(uint32_t* index);
 
   // Compute and set the hash code.
   uint32_t ComputeAndSetHash();
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(String);
 };
 
@@ skipping 26 matching lines @@
   inline Address GetCharsAddress();
 
   inline char* GetChars();
 
   // Casting
   static inline SeqAsciiString* cast(Object* obj);
 
   // Garbage collection support.  This method is called by the
   // garbage collector to compute the actual size of an AsciiString
   // instance.
-  inline int SeqAsciiStringSize(StringShape shape);
+  inline int SeqAsciiStringSize(InstanceType instance_type);
 
   // Computes the size for an AsciiString instance of a given length.
   static int SizeFor(int length) {
     return kHeaderSize + OBJECT_SIZE_ALIGN(length * kCharSize);
   }
 
   // Layout description.
   static const int kHeaderSize = String::kSize;
 
   // Support for StringInputBuffer.
@@ skipping 24 matching lines @@
 
   // For regexp code.
   const uint16_t* SeqTwoByteStringGetData(unsigned start);
 
   // Casting
   static inline SeqTwoByteString* cast(Object* obj);
 
   // Garbage collection support.  This method is called by the
   // garbage collector to compute the actual size of a TwoByteString
   // instance.
-  inline int SeqTwoByteStringSize(StringShape shape);
+  inline int SeqTwoByteStringSize(InstanceType instance_type);
 
   // Computes the size for a TwoByteString instance of a given length.
   static int SizeFor(int length) {
     return kHeaderSize + OBJECT_SIZE_ALIGN(length * kShortSize);
   }
 
   // Layout description.
   static const int kHeaderSize = String::kSize;
 
   // Support for StringInputBuffer.
@@ skipping 805 matching lines @@
     } else {
       value &= ~(1 << bit_position);
     }
     return value;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_H_