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._classId) &&
+          (ccid != _GrowableObjectArray._classId) &&
+          (ccid != _ImmutableArray._classId)) {
         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._classId)) {
         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._classId) {
           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._classId) {
         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 _classId = "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._classId) && (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 {
-  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
-      (codePoint == 32) || // Space.
-      ((9 <= codePoint) && (codePoint <= 13)); // CR, LF, TAB, etc.
-  }
-}
-
-
 class _StringMatch implements Match {
   const _StringMatch(int this.start,
                      String this.str,
                      String this.pattern);
 
   int get end => start + pattern.length;
   String operator[](int g) => group(g);
   int get groupCount => 0;
 
   String group(int group) {
@@ skipping 22 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);
 }