Add class id constants fields to dart:_internal class 'ClassID'. Use the fields in the library (mor…

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);
   }
 
   /* patch */ factory String.fromCharCode(int charCode) {
@@ skipping 38 matching lines @@
 
   /**
    *  Create the most efficient string representation for specified
    *  [codePoints].
    */
   static String createFromCharCodes(Iterable<int> charCodes) {
     if (charCodes != null) {
       // TODO(srdjan): Also skip copying of wide typed arrays.
       final ccid = ClassID.getID(charCodes);
       bool isOneByteString = false;
-      if ((ccid != _List._classId) &&
-          (ccid != _GrowableList._classId) &&
-          (ccid != _ImmutableList._classId)) {
+      if ((ccid != ClassID.cidArray) &&
+          (ccid != ClassID.cidGrowableObjectArray) &&
+          (ccid != ClassID.cidImmutableArray)) {
         if ((charCodes is Uint8List) || (charCodes is Int8List)) {
           isOneByteString = true;
         } else {
           charCodes = new List<int>.from(charCodes, growable: false);
         }
       }
       final len = charCodes.length;
       if (!isOneByteString) {
         for (int i = 0; i < len; i++) {
           int e = charCodes[i];
@@ skipping 431 matching lines @@
    * Convert all objects in [values] to strings and concat them
    * into a result string.
    */
   static String _interpolate(List<String> values) {
     final numValues = values.length;
     _List stringList = new List<String>(numValues);
     bool isOneByteString = true;
     int totalLength = 0;
     for (int i = 0; i < numValues; i++) {
       var s = values[i].toString();
-      if (isOneByteString && (ClassID.getID(s) == _OneByteString._classId)) {
+      if (isOneByteString && (ClassID.getID(s) == ClassID.cidOneByteString)) {
         totalLength += s.length;
       } else {
         isOneByteString = false;
         if (s is! String) {
           throw new ArgumentError(s);
         }
       }
       stringList[i] = s;
     }
     if (isOneByteString) {
@@ skipping 94 matching lines @@
   }
 
   // Call this method if not all list elements are known to be OneByteString(s).
   // 'strings' must be an _List or _GrowableList.
   static String _concatRangeNative(List<String> strings, int start, int end)
       native "String_concatRange";
 }
 
 
 class _OneByteString extends _StringBase implements String {
-  static final int _classId = ClassID.getID("A");
 
   factory _OneByteString._uninstantiable() {
     throw new UnsupportedError(
         "_OneByteString can only be allocated by the VM");
   }
 
   int get hashCode native "String_getHashCode";
 
   bool _isWhitespace(int codePoint) {
     return _StringBase._isOneByteWhitespace(codePoint);
   }
 
   bool operator ==(Object other) {
     return super == other;
   }
 
   String _substringUncheckedNative(int startIndex, int endIndex)
       native "OneByteString_substringUnchecked";
 
   List<String> _splitWithCharCode(int charCode)
       native "OneByteString_splitWithCharCode";
 
   List<String> split(Pattern pattern) {
-    if ((ClassID.getID(pattern) == _OneByteString._classId) &&
+    if ((ClassID.getID(pattern) == ClassID.cidOneByteString) &&
         (pattern.length == 1)) {
       return _splitWithCharCode(pattern.codeUnitAt(0));
     }
     return super.split(pattern);
   }
 
   // All element of 'strings' must be OneByteStrings.
   static _concatAll(List<String> strings, int totalLength) {
     // TODO(srdjan): Improve code below and raise or eliminate the limit.
     if (totalLength > 128) {
       // Native is quicker.
       return _StringBase._concatRangeNative(strings, 0, strings.length);
     }
     var res = _OneByteString._allocate(totalLength);
     final stringsLength = strings.length;
     int rIx = 0;
     for (int i = 0; i < stringsLength; i++) {
       _OneByteString e = strings[i];
       final eLength = e.length;
       for (int s = 0; s < eLength; s++) {
         res._setAt(rIx++, e.codeUnitAt(s));
       }
     }
     return res;
   }
 
   int indexOf(Pattern pattern, [int start = 0]) {
     // Specialize for single character pattern.
     final pCid = ClassID.getID(pattern);
-    if ((pCid == _OneByteString._classId) ||
-        (pCid == _TwoByteString._classId) ||
-        (pCid == _ExternalOneByteString._classId)) {
+    if ((pCid == ClassID.cidOneByteString) ||
+        (pCid == ClassID.cidTwoByteString) ||
+        (pCid == ClassID.cidExternalOneByteString)) {
       final len = this.length;
       if ((pattern.length == 1) && (start >= 0) && (start < len)) {
         final patternCu0 = pattern.codeUnitAt(0);
         if (patternCu0 > 0xFF) {
           return -1;
         }
         for (int i = start; i < len; i++) {
           if (this.codeUnitAt(i) == patternCu0) {
             return i;
           }
         }
         return -1;
       }
     }
     return super.indexOf(pattern, start);
   }
 
   bool contains(Pattern pattern, [int start = 0]) {
     final pCid = ClassID.getID(pattern);
-    if ((pCid == _OneByteString._classId) ||
-        (pCid == _TwoByteString._classId) ||
-        (pCid == _ExternalOneByteString._classId)) {
+    if ((pCid == ClassID.cidOneByteString) ||
+        (pCid == ClassID.cidTwoByteString) ||
+        (pCid == ClassID.cidExternalOneByteString)) {
       final len = this.length;
       if ((pattern.length == 1) && (start >= 0) && (start < len)) {
         final patternCu0 = pattern.codeUnitAt(0);
         if (patternCu0 > 0xFF) {
           return false;
         }
         for (int i = start; i < len; i++) {
           if (this.codeUnitAt(i) == patternCu0) {
             return true;
           }
@@ skipping 14 matching lines @@
     for (int i = 0; i < times; i ++) {
       for (int j = 0; j < length; j++) {
         result._setAt(index++, this.codeUnitAt(j));
       }
     }
     return result;
   }
 
   String padLeft(int width, [String padding = ' ']) {
     int padCid = ClassID.getID(padding);
-    if (padCid != _OneByteString._classId &&
-        padCid != _ExternalOneByteString._classId) {
+    if ((padCid != ClassID.cidOneByteString) &&
+        (padCid != ClassID.cidExternalOneByteString)) {
       return super.padLeft(width, padding);
     }
     int length = this.length;
     int delta = width - length;
     if (delta <= 0) return this;
     int padLength = padding.length;
     int resultLength = padLength * delta + length;
     _OneByteString result = _OneByteString._allocate(resultLength);
     int index = 0;
     if (padLength == 1) {
       int padChar = padding.codeUnitAt(0);
       for (int i = 0; i < delta; i++) {
         result._setAt(index++, padChar);
       }
     } else {
       for (int i = 0; i < delta; i++) {
         for (int j = 0; j < padLength; j++) {
           result._setAt(index++, padding.codeUnitAt(j));
         }
       }
     }
     for (int i = 0; i < length; i++) {
       result._setAt(index++, this.codeUnitAt(i));
     }
     return result;
   }
 
   String padRight(int width, [String padding = ' ']) {
     int padCid = ClassID.getID(padding);
-    if (padCid != _OneByteString._classId &&
-        padCid != _ExternalOneByteString._classId) {
+    if ((padCid != ClassID.cidOneByteString) &&
+        (padCid != ClassID.cidExternalOneByteString)) {
       return super.padRight(width, padding);
     }
     int length = this.length;
     int delta = width - length;
     if (delta <= 0) return this;
     int padLength = padding.length;
     int resultLength = length + padLength * delta;
     _OneByteString result = _OneByteString._allocate(resultLength);
     int index = 0;
     for (int i = 0; i < length; i++) {
@@ skipping 116 matching lines @@
   static _OneByteString _allocateFromOneByteList(List<int> list)
       native "OneByteString_allocateFromOneByteList";
 
   // This is internal helper method. Code point value must be a valid
   // Latin1 value (0..0xFF), index must be valid.
   void _setAt(int index, int codePoint) native "OneByteString_setAt";
 }
 
 
 class _TwoByteString extends _StringBase implements String {
-  static final int _classId = ClassID.getID("\u{FFFF}");
-
   factory _TwoByteString._uninstantiable() {
     throw new UnsupportedError(
         "_TwoByteString can only be allocated by the VM");
   }
 
   bool _isWhitespace(int codePoint) {
     return _StringBase._isTwoByteWhitespace(codePoint);
   }
 
   bool operator ==(Object other) {
     return super == other;
   }
 }
 
 
 class _ExternalOneByteString extends _StringBase implements String {
-  static final int _classId = _getCid();
-
   factory _ExternalOneByteString._uninstantiable() {
     throw new UnsupportedError(
         "_ExternalOneByteString can only be allocated by the VM");
   }
 
   bool _isWhitespace(int codePoint) {
     return _StringBase._isOneByteWhitespace(codePoint);
   }
 
   bool operator ==(Object other) {
@@ skipping 55 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);
 }