Added Object._cid getter, optimized it. Added to (some) classes a static final _clCid. Use those to…

runtime/lib/string_patch.dart

 // 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.
 
 patch class String {
   /* patch */ factory String.fromCharCodes(Iterable<int> charCodes) {
     return _StringBase.createFromCharCodes(charCodes);
   }
 }
 
@@ skipping 11 matching lines @@
 
   int get hashCode native "String_getHashCode";
 
   /**
    *  Create the most efficient string representation for specified
    *  [codePoints].
    */
   static String createFromCharCodes(Iterable<int> charCodes) {
     if (charCodes != null) {
       // TODO(srdjan): Also skip copying of typed arrays.
-      if (charCodes is! _ObjectArray &&
-          charCodes is! _GrowableObjectArray &&
-          charCodes is! _ImmutableArray) {
+      final ccid = charCodes._cid;
+      if ((ccid != _ObjectArray._clCid) &&
+          (ccid != _GrowableObjectArray._clCid) &&
+          (ccid != _ImmutableArray._clCid)) {

[siva, 2013/05/13 20:38:00]

It might be more readable to have static methods in the Object class for these

Object.IsArray(charCodes);

[srdjan, 2013/05/14 17:46:31]

I am open to change it, but I think this is more readable. I would be more in
favor of the change if we need the same test on various places. TODO says that
we need to add typed array as well. IsArray should return true for typed array
as well, but createFromCharCodes does not support it yet.

         charCodes = new List<int>.from(charCodes, growable: false);
       }
 
       bool isOneByteString = true;
       for (int i = 0; i < charCodes.length; i++) {
         int e = charCodes[i];
-        if (e is! int) throw new ArgumentError(e);
+        if (e is! _Smi) throw new ArgumentError(e);
         // Is e Latin1?
         if ((e < 0) || (e > 0xFF)) {
           isOneByteString = false;
           break;
         }
       }
       if (isOneByteString) {
         var s = _OneByteString._allocate(charCodes.length);
         for (int i = 0; i < charCodes.length; i++) {
           s._setAt(i, charCodes[i]);
@@ skipping 283 matching lines @@
    * Convert all objects in [values] to strings and concat them
    * into a result string.
    */
   static String _interpolate(List values) {
     final int numValues = values.length;
     _ObjectArray stringList = new List(numValues);
     bool isOneByteString = true;
     int totalLength = 0;
     for (int i = 0; i < numValues; i++) {
       var s = values[i].toString();
-      if (isOneByteString && (s is _OneByteString)) {
+      if (isOneByteString && (s._cid == _OneByteString._clCid)) {

[siva, 2013/05/13 20:38:00]

Object.IsOneByteString(s);

[srdjan, 2013/05/14 17:46:31]

Next CL as discussed offline.

         totalLength += s.length;
       } else {
         isOneByteString = false;
       }
       stringList[i] = s;
     }
     if (isOneByteString) {
       return _OneByteString._concatAll(stringList, totalLength);
     }
     return _concatAllNative(stringList);
@@ skipping 85 matching lines @@
       stringsList.add(string);
     }
     return concatAll(stringsList);
   }
 
   static String concatAll(Iterable<String> strings) {
     _ObjectArray stringsArray;
     final len = strings.length;
     bool isOneByteString = true;
     int totalLength = 0;
-    if (strings is _ObjectArray) {
+    if (strings._cid == _ObjectArray._clCId) {
       stringsArray = strings;
       for (int i = 0; i < len; i++) {
         var string = strings[i];
-        if (string is _OneByteString) {
+        if (string._cid == _OneByteString._clCid) {
           totalLength += string.length;
         } else {
           isOneByteString = false;
           if (string is! String) throw new ArgumentError(string);
         }
       }
     } else {
       // Copy into an _ObjectArray.
       stringsArray = new _ObjectArray(len);
       int i = 0;
       for (int i = 0; i < len; i++) {
         var string = strings[i];
-        if (string is _OneByteString) {
+        if (string._cid == _OneByteString.clCid) {
           totalLength += s.length;
         } else {
           isOneByteString = false;
           if (string is! String) throw new ArgumentError(string);
         }
         stringsArray[i++] = string;
       }
     }
     if (isOneByteString) {
       return _OneByteString._concatAll(stringsArray, totalLength);
     }
     return _concatAllNative(stringsArray);
   }
 
   static String _concatAll(_ObjectArray<String> strings) {
     int totalLength = 0;
     final stringsLength = strings.length;
     for (int i = 0; i < stringsLength; i++) {
       var e = strings[i];
-      if (e is! _OneByteString) {
+      if (e._cid != _OneByteString._clCid) {
         return _concatAllNative(strings);
       }
       totalLength += e.length;
     }
     return _OneByteString._concatAll(strings, totalLength);
   }
 
   // Call this method if not all list elements are OneByteString-s.
   static String _concatAllNative(_ObjectArray<String> strings)
       native "Strings_concatAll";
 }
 
 
 class _OneByteString extends _StringBase implements String {
+  static final int _clCid = "A"._cid;
+
   factory _OneByteString._uninstantiable() {
     throw new UnsupportedError(
         "_OneByteString can only be allocated by the VM");
   }
 
   int get hashCode native "String_getHashCode";
 
   // Checks for one-byte whitespaces only.
   // TODO(srdjan): Investigate if 0x85 (NEL) and 0xA0 (NBSP) are valid
   // whitespaces for one byte strings.
   bool _isWhitespace(int codePoint) {
     return
       (codePoint == 32) || // Space.
       ((9 <= codePoint) && (codePoint <= 13)); // CR, LF, TAB, etc.
   }
 
   String _substringUncheckedNative(int startIndex, int endIndex)
       native "OneByteString_substringUnchecked";
 
   List<String> _splitWithCharCode(int charCode)
       native "OneByteString_splitWithCharCode";
 
   List<String> split(Pattern pattern) {
-    if ((pattern is _OneByteString) && (pattern.length == 1)) {
+    if ((pattern._cid == _OneByteString._clCid) && (pattern.length == 1)) {
       return _splitWithCharCode(pattern.codeUnitAt(0));
     }
     return super.split(pattern);
   }
 
   // All element of 'strings' must be OneByteStrings.
   static _concatAll(_ObjectArray<String> strings, int totalLength) {
     // TODO(srdjan): Improve code below and raise or eliminate the limit.
     if (totalLength > 128) {
       // Native is quicker.
@@ skipping 83 matching lines @@
   // TODO(srdjan): Investigate if 0x85 (NEL) and 0xA0 (NBSP) are valid
   // whitespaces. Add checking for multi-byte whitespace codepoints.
   bool _isWhitespace(int codePoint) {
     return
       (codePoint == 32) || // Space.
       ((9 <= codePoint) && (codePoint <= 13)); // CR, LF, TAB, etc.
   }
 }
 
 
 class _ExternalFourByteString extends _StringBase implements String {

[Ivan Posva, 2013/05/13 22:12:37]

I don't think this needs to be here anymore. Four-byte strings are a thing of
the past.

[srdjan, 2013/05/14 17:46:31]

Removed.

   factory _ExternalFourByteString._uninstantiable() {
     throw new UnsupportedError(
         "ExternalFourByteString can only be allocated by the VM");
   }
 
   // Checks for one-byte whitespaces only.
   // TODO(srdjan): Investigate if 0x85 (NEL) and 0xA0 (NBSP) are valid
   // whitespaces. Add checking for multi-byte whitespace codepoints.
   bool _isWhitespace(int codePoint) {
     return
@@ skipping 38 matching lines @@
 class _CodeUnits extends Object with ListMixin<int>,
                                      UnmodifiableListMixin<int> {
   /** The string that this is the code units of. */
   String _string;
 
   _CodeUnits(this._string);
 
   int get length => _string.length;
   int operator[](int i) => _string.codeUnitAt(i);
 }