Remove deprecated string features.

sdk/lib/json/json_base.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.
 
 // JSON parsing and serialization.
 
 /**
  * Error thrown by JSON serialization if an object cannot be serialized.
  *
  * The [unsupportedObject] field holds that object that failed to be serialized.
@@ skipping 306 matching lines @@
   final JsonListener listener;
   JsonParser(this.source, this.listener);
 
   /** Parses [source], or throws if it fails. */
   void parse() {
     final List<int> states = <int>[];
     int state = STATE_INITIAL;
     int position = 0;
     int length = source.length;
     while (position < length) {
-      int char = source.charCodeAt(position);
+      int char = source.codeUnitAt(position);
       switch (char) {
         case SPACE:
         case CARRIAGE_RETURN:
         case NEWLINE:
         case TAB:
           position++;
           break;
         case QUOTE:
           if ((state & ALLOW_STRING_MASK) != 0) fail(position);
           position = parseString(position + 1);
@@ skipping 80 matching lines @@
     }
     if (state != STATE_END) fail(position);
   }
 
   /**
    * Parses a "true" literal starting at [position].
    *
    * [:source[position]:] must be "t".
    */
   int parseTrue(int position) {
-    assert(source.charCodeAt(position) == CHAR_t);
+    assert(source.codeUnitAt(position) == CHAR_t);
     if (source.length < position + 4) fail(position, "Unexpected identifier");
-    if (source.charCodeAt(position + 1) != CHAR_r ||
-        source.charCodeAt(position + 2) != CHAR_u ||
-        source.charCodeAt(position + 3) != CHAR_e) {
+    if (source.codeUnitAt(position + 1) != CHAR_r ||
+        source.codeUnitAt(position + 2) != CHAR_u ||
+        source.codeUnitAt(position + 3) != CHAR_e) {
       fail(position);
     }
     listener.handleBool(true);
     return position + 4;
   }
 
   /**
    * Parses a "false" literal starting at [position].
    *
    * [:source[position]:] must be "f".
    */
   int parseFalse(int position) {
-    assert(source.charCodeAt(position) == CHAR_f);
+    assert(source.codeUnitAt(position) == CHAR_f);
     if (source.length < position + 5) fail(position, "Unexpected identifier");
-    if (source.charCodeAt(position + 1) != CHAR_a ||
-        source.charCodeAt(position + 2) != CHAR_l ||
-        source.charCodeAt(position + 3) != CHAR_s ||
-        source.charCodeAt(position + 4) != CHAR_e) {
+    if (source.codeUnitAt(position + 1) != CHAR_a ||
+        source.codeUnitAt(position + 2) != CHAR_l ||
+        source.codeUnitAt(position + 3) != CHAR_s ||
+        source.codeUnitAt(position + 4) != CHAR_e) {
       fail(position);
     }
     listener.handleBool(false);
     return position + 5;
   }
 
   /** Parses a "null" literal starting at [position].
    *
    * [:source[position]:] must be "n".
    */
   int parseNull(int position) {
-    assert(source.charCodeAt(position) == CHAR_n);
+    assert(source.codeUnitAt(position) == CHAR_n);
     if (source.length < position + 4) fail(position, "Unexpected identifier");
-    if (source.charCodeAt(position + 1) != CHAR_u ||
-        source.charCodeAt(position + 2) != CHAR_l ||
-        source.charCodeAt(position + 3) != CHAR_l) {
+    if (source.codeUnitAt(position + 1) != CHAR_u ||
+        source.codeUnitAt(position + 2) != CHAR_l ||
+        source.codeUnitAt(position + 3) != CHAR_l) {
       fail(position);
     }
     listener.handleNull();
     return position + 4;
   }
 
   int parseString(int position) {
     // Format: '"'([^\x00-\x1f\\\"]|'\\'[bfnrt/\\"])*'"'
     // Initial position is right after first '"'.
     int start = position;
     int char;
     do {
       if (position == source.length) {
         fail(start - 1, "Unterminated string");
       }
-      char = source.charCodeAt(position);
+      char = source.codeUnitAt(position);
       if (char == QUOTE) {
         listener.handleString(source.substring(start, position));
         return position + 1;
       }
       if (char < SPACE) {
         fail(position, "Control character in string");
       }
       position++;
     } while (char != BACKSLASH);
     // Backslash escape detected. Collect character codes for rest of string.
     int firstEscape = position - 1;
     List<int> chars = <int>[];
     while (true) {
       if (position == source.length) {
         fail(start - 1, "Unterminated string");
       }
-      char = source.charCodeAt(position);
+      char = source.codeUnitAt(position);
       switch (char) {
         case CHAR_b: char = BACKSPACE; break;
         case CHAR_f: char = FORM_FEED; break;
         case CHAR_n: char = NEWLINE; break;
         case CHAR_r: char = CARRIAGE_RETURN; break;
         case CHAR_t: char = TAB; break;
         case SLASH:
         case BACKSLASH:
         case QUOTE:
           break;
         case CHAR_u:
           int hexStart = position - 1;
           int value = 0;
           for (int i = 0; i < 4; i++) {
             position++;
             if (position == source.length) {
               fail(start - 1, "Unterminated string");
             }
-            char = source.charCodeAt(position);
+            char = source.codeUnitAt(position);
             char -= 0x30;
             if (char < 0) fail(hexStart, "Invalid unicode escape");
             if (char < 10) {
               value = value * 16 + char;
             } else {
               char = (char | 0x20) - 0x31;
               if (char < 0 || char > 5) {
                 fail(hexStart, "Invalid unicode escape");
               }
               value = value * 16 + char + 10;
             }
           }
           char = value;
           break;
         default:
           if (char < SPACE) fail(position, "Control character in string");
           fail(position, "Unrecognized string escape");
       }
       do {
         chars.add(char);
         position++;
         if (position == source.length) fail(start - 1, "Unterminated string");
-        char = source.charCodeAt(position);
+        char = source.codeUnitAt(position);
         if (char == QUOTE) {
           String result = new String.fromCharCodes(chars);
           if (start < firstEscape) {
             result = "${source.substring(start, firstEscape)}$result";
           }
           listener.handleString(result);
           return position + 1;
         }
         if (char < SPACE) {
           fail(position, "Control character in string");
         }
       } while (char != BACKSLASH);
       position++;
     }
   }
 
   int parseNumber(int char, int position) {
     // Format:
     //  '-'?('0'|[1-9][0-9]*)('.'[0-9]+)?([eE][+-]?[0-9]+)?
     int start = position;
     int length = source.length;
     bool isDouble = false;
     if (char == MINUS) {
       position++;
       if (position == length) fail(position, "Missing expected digit");
-      char = source.charCodeAt(position);
+      char = source.codeUnitAt(position);
     }
     if (char < CHAR_0 || char > CHAR_9) {
       fail(position, "Missing expected digit");
     }
     int handleLiteral(position) {
       String literal = source.substring(start, position);
       // This correctly creates -0 for doubles.
       num value = (isDouble ? double.parse(literal) : int.parse(literal));
       listener.handleNumber(value);
       return position;
     }
     if (char == CHAR_0) {
       position++;
       if (position == length) return handleLiteral(position);
-      char = source.charCodeAt(position);
+      char = source.codeUnitAt(position);
       if (CHAR_0 <= char && char <= CHAR_9) {
         fail(position);
       }
     } else {
       do {
         position++;
         if (position == length) return handleLiteral(position);
-        char = source.charCodeAt(position);
+        char = source.codeUnitAt(position);
       } while (CHAR_0 <= char && char <= CHAR_9);
     }
     if (char == DECIMALPOINT) {
       isDouble = true;
       position++;
       if (position == length) fail(position, "Missing expected digit");
-      char = source.charCodeAt(position);
+      char = source.codeUnitAt(position);
       if (char < CHAR_0 || char > CHAR_9) fail(position);
       do {
         position++;
         if (position == length) return handleLiteral(position);
-        char = source.charCodeAt(position);
+        char = source.codeUnitAt(position);
       } while (CHAR_0 <= char && char <= CHAR_9);
     }
     if (char == CHAR_e || char == CHAR_E) {
       isDouble = true;
       position++;
       if (position == length) fail(position, "Missing expected digit");
-      char = source.charCodeAt(position);
+      char = source.codeUnitAt(position);
       if (char == PLUS || char == MINUS) {
         position++;
         if (position == length) fail(position, "Missing expected digit");
-        char = source.charCodeAt(position);
+        char = source.codeUnitAt(position);
       }
       if (char < CHAR_0 || char > CHAR_9) {
         fail(position, "Missing expected digit");
       }
       do {
         position++;
         if (position == length) return handleLiteral(position);
-        char = source.charCodeAt(position);
+        char = source.codeUnitAt(position);
       } while (CHAR_0 <= char && char <= CHAR_9);
     }
     return handleLiteral(position);
   }
 
   void fail(int position, [String message]) {
     if (message == null) message = "Unexpected character";
     listener.fail(source, position, message);
     // If the listener didn't throw, do it here.
     String slice;
@@ skipping 31 matching lines @@
   }
 
   // ('0' + x) or ('a' + x - 10)
   static int hexDigit(int x) => x < 10 ? 48 + x : 87 + x;
 
   static void escape(StringBuffer sb, String s) {
     final int length = s.length;
     bool needsEscape = false;
     final charCodes = new List<int>();
     for (int i = 0; i < length; i++) {
-      int charCode = s.charCodeAt(i);
+      int charCode = s.codeUnitAt(i);
       if (charCode < 32) {
         needsEscape = true;
         charCodes.add(JsonParser.BACKSLASH);
         switch (charCode) {
         case JsonParser.BACKSPACE:
           charCodes.add(JsonParser.CHAR_b);
           break;
         case JsonParser.TAB:
           charCodes.add(JsonParser.CHAR_t);
           break;
@@ skipping 111 matching lines @@
         first = false;
       });
       sb.add('}');
       seen.removeLast();
       return true;
     } else {
       return false;
     }
   }
 }