Add a const qualifier to string handles which are not reassigned.

runtime/vm/object.cc

 // Copyright (c) 2011, 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 "vm/assembler.h"
 #include "vm/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 5242 matching lines @@
 
   // This string is a symbol if we found a matching entry.
   return !symbol.IsNull();
 }
 
 
 RawString* String::New(const char* str, Heap::Space space) {
   intptr_t width = 0;
   intptr_t len = Utf8::CodePointCount(str, &width);
   if (width == 1) {
-    OneByteString& onestr
+    const OneByteString& onestr
         = OneByteString::Handle(OneByteString::New(len, space));
     if (len > 0) {
       NoGCScope no_gc;
       Utf8::Decode(str, onestr.CharAddr(0), len);
     }
     return onestr.raw();
   } else if (width == 2) {
-    TwoByteString& twostr =
+    const TwoByteString& twostr =
         TwoByteString::Handle(TwoByteString::New(len, space));
     NoGCScope no_gc;
     Utf8::Decode(str, twostr.CharAddr(0), len);
     return twostr.raw();
   }
   ASSERT(width == 4);
-  FourByteString& fourstr =
+  const FourByteString& fourstr =
       FourByteString::Handle(FourByteString::New(len, space));
   NoGCScope no_gc;
   Utf8::Decode(str, fourstr.CharAddr(0), len);
   return fourstr.raw();
 }
 
 
 RawString* String::New(const uint8_t* characters,
                        intptr_t len,
                        Heap::Space space) {
@@ skipping 448 matching lines @@
     result.SetLength(len);
     result.SetHash(0);
   }
   return result.raw();
 }
 
 
 RawOneByteString* OneByteString::New(const uint8_t* characters,
                                      intptr_t len,
                                      Heap::Space space) {
-  OneByteString& result = OneByteString::Handle(OneByteString::New(len, space));
+  const OneByteString& result =
+      OneByteString::Handle(OneByteString::New(len, space));
   String::Copy(result, 0, characters, len);
   return result.raw();
 }
 
 
 RawOneByteString* OneByteString::New(const uint16_t* characters,
                                      intptr_t len,
                                      Heap::Space space) {
-  OneByteString& result = OneByteString::Handle(OneByteString::New(len, space));
+  const OneByteString& result =
+      OneByteString::Handle(OneByteString::New(len, space));
   String::Copy(result, 0, characters, len);
   return result.raw();
 }
 
 
 RawOneByteString* OneByteString::New(const uint32_t* characters,
                                      intptr_t len,
                                      Heap::Space space) {
-  OneByteString& result = OneByteString::Handle(OneByteString::New(len, space));
+  const OneByteString& result =
+      OneByteString::Handle(OneByteString::New(len, space));
   String::Copy(result, 0, characters, len);
   return result.raw();
 }
 
 
 RawOneByteString* OneByteString::New(const OneByteString& str,
                                      Heap::Space space) {
   intptr_t len = str.Length();
-  OneByteString& result = OneByteString::Handle(OneByteString::New(len, space));
+  const OneByteString& result =
+      OneByteString::Handle(OneByteString::New(len, space));
   String::Copy(result, 0, str, 0, len);
   return result.raw();
 }
 
 
 RawOneByteString* OneByteString::Concat(const String& str1,
                                         const String& str2,
                                         Heap::Space space) {
   intptr_t len1 = str1.Length();
   intptr_t len2 = str2.Length();
   intptr_t len = len1 + len2;
-  OneByteString& result = OneByteString::Handle(OneByteString::New(len, space));
+  const OneByteString& result =
+      OneByteString::Handle(OneByteString::New(len, space));
   String::Copy(result, 0, str1, 0, len1);
   String::Copy(result, len1, str2, 0, len2);
   return result.raw();
 }
 
 
 RawOneByteString* OneByteString::ConcatAll(const Array& strings,
                                            intptr_t len,
                                            Heap::Space space) {
-  OneByteString& result = OneByteString::Handle(OneByteString::New(len, space));
+  const OneByteString& result =
+      OneByteString::Handle(OneByteString::New(len, space));
   OneByteString& str = OneByteString::Handle();
   intptr_t strings_len = strings.Length();
   intptr_t pos = 0;
   for (intptr_t i = 0; i < strings_len; i++) {
     str ^= strings.At(i);
     intptr_t str_len = str.Length();
     String::Copy(result, pos, str, 0, str_len);
     pos += str_len;
   }
   return result.raw();
@@ skipping 37 matching lines @@
     result.SetLength(len);
     result.SetHash(0);
   }
   return result.raw();
 }
 
 
 RawTwoByteString* TwoByteString::New(const uint16_t* characters,
                                      intptr_t len,
                                      Heap::Space space) {
-  TwoByteString& result = TwoByteString::Handle(TwoByteString::New(len, space));
+  const TwoByteString& result =
+      TwoByteString::Handle(TwoByteString::New(len, space));
   String::Copy(result, 0, characters, len);
   return result.raw();
 }
 
 
 RawTwoByteString* TwoByteString::New(const uint32_t* characters,
                                      intptr_t len,
                                      Heap::Space space) {
-  TwoByteString& result = TwoByteString::Handle(TwoByteString::New(len, space));
+  const TwoByteString& result =
+      TwoByteString::Handle(TwoByteString::New(len, space));
   String::Copy(result, 0, characters, len);
   return result.raw();
 }
 
 
 RawTwoByteString* TwoByteString::New(const TwoByteString& str,
                                      Heap::Space space) {
   intptr_t len = str.Length();
-  TwoByteString& result = TwoByteString::Handle(TwoByteString::New(len, space));
+  const TwoByteString& result =
+      TwoByteString::Handle(TwoByteString::New(len, space));
   String::Copy(result, 0, str, 0, len);
   return result.raw();
 }
 
 
 RawTwoByteString* TwoByteString::Concat(const String& str1,
                                         const String& str2,
                                         Heap::Space space) {
-  TwoByteString& result = TwoByteString::Handle();
   intptr_t len1 = str1.Length();
   intptr_t len2 = str2.Length();
   intptr_t len = len1 + len2;
-  result ^= TwoByteString::New(len, space);
+  const TwoByteString& result =
+      TwoByteString::Handle(TwoByteString::New(len, space));
   String::Copy(result, 0, str1, 0, len1);
   String::Copy(result, len1, str2, 0, len2);
   return result.raw();
 }
 
 
 RawTwoByteString* TwoByteString::ConcatAll(const Array& strings,
                                            intptr_t len,
                                            Heap::Space space) {
-  TwoByteString& result = TwoByteString::Handle(TwoByteString::New(len, space));
+  const TwoByteString& result =
+      TwoByteString::Handle(TwoByteString::New(len, space));
   String& str = String::Handle();
   intptr_t strings_len = strings.Length();
   intptr_t pos = 0;
   for (intptr_t i = 0; i < strings_len; i++) {
     str ^= strings.At(i);
     intptr_t str_len = str.Length();
     String::Copy(result, pos, str, 0, str_len);
     pos += str_len;
   }
   return result.raw();
@@ skipping 38 matching lines @@
     result.SetLength(len);
     result.SetHash(0);
   }
   return result.raw();
 }
 
 
 RawFourByteString* FourByteString::New(const uint32_t* characters,
                                        intptr_t len,
                                        Heap::Space space) {
-  FourByteString& result =
+  const FourByteString& result =
       FourByteString::Handle(FourByteString::New(len, space));
   String::Copy(result, 0, characters, len);
   return result.raw();
 }
 
 
 RawFourByteString* FourByteString::New(const FourByteString& str,
                                        Heap::Space space) {
   return FourByteString::New(str.CharAddr(0), str.Length(), space);
 }
 
 
 RawFourByteString* FourByteString::Concat(const String& str1,
                                           const String& str2,
                                           Heap::Space space) {
   intptr_t len1 = str1.Length();
   intptr_t len2 = str2.Length();
   intptr_t len = len1 + len2;
-  FourByteString& result =
+  const FourByteString& result =
       FourByteString::Handle(FourByteString::New(len, space));
   String::Copy(result, 0, str1, 0, len1);
   String::Copy(result, len1, str2, 0, len2);
   return result.raw();
 }
 
 
 RawFourByteString* FourByteString::ConcatAll(const Array& strings,
                                              intptr_t len,
                                              Heap::Space space) {
-  FourByteString& result =
+  const FourByteString& result =
       FourByteString::Handle(FourByteString::New(len, space));
   String& str = String::Handle();
   {
     intptr_t strings_len = strings.Length();
     intptr_t pos = 0;
     for (intptr_t i = 0; i < strings_len; i++) {
       str ^= strings.At(i);
       intptr_t str_len = str.Length();
       String::Copy(result, pos, str, 0, str_len);
       pos += str_len;
@@ skipping 450 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