Make dart:core strong-mode clean.

sdk/lib/core/uri.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.
 
 part of dart.core;
 
 /**
  * A parsed URI, such as a URL.
  *
  * **See also:**
@@ skipping 130 matching lines @@
    * When [queryParameters] is used the query is built from the
    * provided map. Each key and value in the map is percent-encoded
    * and joined using equal and ampersand characters.
    * A value in the map must be either a string, or an [Iterable] of strings,
    * where the latter corresponds to multiple values for the same key.
    *
    * The percent-encoding of the keys and values encodes all characters
    * except for the unreserved characters, and replaces spaces with `+`.
    * If `query` is the empty string, it is equivalent to omitting it.
    * To have an actual empty query part,
-   * use an empty list for `queryParameters`.
+   * use an empty map for `queryParameters`.
    *
    * If both `query` and `queryParameters` are omitted or `null`,
    * the URI has no query part.
    *
    * The fragment component is set through [fragment].
    * It should be a valid URI fragment, but invalid characters other than
    * general delimiters, are escaped if necessary.
    * If `fragment` is omitted or `null`, the URI has no fragment part.
    */
   factory Uri({String scheme : "",
                String userInfo : "",
                String host,
                int port,
                String path,
                Iterable<String> pathSegments,
                String query,
-               Map<String, dynamic> queryParameters,
+               Map<String, dynamic/*String|Iterable<String>*/> queryParameters,
                String fragment}) {
     scheme = _makeScheme(scheme, 0, _stringOrNullLength(scheme));
     userInfo = _makeUserInfo(userInfo, 0, _stringOrNullLength(userInfo));
     host = _makeHost(host, 0, _stringOrNullLength(host), false);
     // Special case this constructor for backwards compatibility.
     if (query == "") query = null;
     query = _makeQuery(query, 0, _stringOrNullLength(query), queryParameters);
     fragment = _makeFragment(fragment, 0, _stringOrNullLength(fragment));
     port = _makePort(port, scheme);
     bool isFile = (scheme == "file");
@@ skipping 824 matching lines @@
    * call above, but may also be slightly faster because the parts taken
    * from this `Uri` need not be checked for validity again.
    */
   Uri replace({String scheme,
                String userInfo,
                String host,
                int port,
                String path,
                Iterable<String> pathSegments,
                String query,
-               Map<String, String> queryParameters,
+               Map<String, dynamic/*String|Iterable<String>*/> queryParameters,
                String fragment}) {
     // Set to true if the scheme has (potentially) changed.
     // In that case, the default port may also have changed and we need
     // to check even the existing port.
     bool schemeChanged = false;
     if (scheme != null) {
       scheme = _makeScheme(scheme, 0, scheme.length);
       schemeChanged = true;
     } else {
       scheme = this.scheme;
@@ skipping 342 matching lines @@
   /// If the URI has neither scheme nor authority, it's considered a
   /// "pure path" and normalization won't remove leading ".." segments.
   /// Otherwise it follows the RFC 3986 "remove dot segments" algorithm.
   static String _normalizePath(String path, String scheme, bool hasAuthority) {
     if (scheme.isEmpty && !hasAuthority && !path.startsWith('/')) {
       return _normalizeRelativePath(path);
     }
     return _removeDotSegments(path);
   }
 
-  static String _makeQuery(String query, int start, int end,
-                           Map<String, String> queryParameters) {
+  static String _makeQuery(
+      String query, int start, int end,
+      Map<String, dynamic/*String|Iterable<String>*/> queryParameters) {
     if (query == null && queryParameters == null) return null;
     if (query != null && queryParameters != null) {
       throw new ArgumentError('Both query and queryParameters specified');
     }
     if (query != null) return _normalize(query, start, end, _queryCharTable);
 
     var result = new StringBuffer();
     var separator = "";
 
     void writeParameter(String key, String value) {
@@ skipping 74 matching lines @@
     if (digit <= 9) return digit;
     int lowerCase = char | 0x20;
     if (Uri._LOWER_CASE_A <= lowerCase && lowerCase <= _LOWER_CASE_F) {
       return lowerCase - (_LOWER_CASE_A - 10);
     }
     return -1;
   }
 
   static String _escapeChar(int char) {
     assert(char <= 0x10ffff);  // It's a valid unicode code point.
-    List codeUnits;
+    List<int> codeUnits;
     if (char < 0x80) {
       // ASCII, a single percent encoded sequence.
       codeUnits = new List(3);
       codeUnits[0] = _PERCENT;
       codeUnits[1] = _hexDigits.codeUnitAt(char >> 4);
       codeUnits[2] = _hexDigits.codeUnitAt(char & 0xf);
     } else {
       // Do UTF-8 encoding of character, then percent encode bytes.
       int flag = 0xc0;  // The high-bit markers on the first byte of UTF-8.
       int encodedBytes = 2;
@@ skipping 875 matching lines @@
         }
       }
     }
     if (wildcardSeen) {
       if (parts.length > 7) {
         error('an address with a wildcard must have less than 7 parts');
       }
     } else if (parts.length != 8) {
       error('an address without a wildcard must contain exactly 8 parts');
     }
-    // TODO(ajohnsen): Consider using Uint8List.
-    List bytes = new List<int>(16);
+    List<int> bytes = new Uint8List(16);
     for (int i = 0, index = 0; i < parts.length; i++) {
       int value = parts[i];
       if (value == -1) {
         int wildCardLength = 9 - parts.length;
         for (int j = 0; j < wildCardLength; j++) {
           bytes[index] = 0;
           bytes[index + 1] = 0;
           index += 2;
         }
       } else {
@@ skipping 443 matching lines @@
    *
    * Equivalent to `new Uri.dataFromString(...).data`, but may
    * be more efficient if the [uri] itself isn't used.
    */
   factory UriData.fromString(String content,
                              {String mimeType,
                               Encoding encoding,
                               Map<String, String> parameters,
                               bool base64: false}) {
     StringBuffer buffer = new StringBuffer();
-    List indices = [_noScheme];
+    List<int> indices = [_noScheme];
     String charsetName;
     String encodingName;
     if (parameters != null) charsetName = parameters["charset"];
     if (encoding == null) {
       if (charsetName != null) {
         encoding = Encoding.getByName(charsetName);
       }
     } else if (charsetName == null) {
       // Non-null only if parameters does not contain "charset".
       encodingName = encoding.name;
@@ skipping 16 matching lines @@
    * Creates a `data:` URI containing an encoding of [bytes].
    *
    * Equivalent to `new Uri.dataFromBytes(...).data`, but may
    * be more efficient if the [uri] itself isn't used.
    */
   factory UriData.fromBytes(List<int> bytes,
                             {mimeType: "application/octet-stream",
                              Map<String, String> parameters,
                              percentEncoded: false}) {
     StringBuffer buffer = new StringBuffer();
-    List indices = [_noScheme];
+    List<int> indices = [_noScheme];
     _writeUri(mimeType, null, parameters, buffer, indices);
     indices.add(buffer.length);
     if (percentEncoded) {
       buffer.write(',');
       _uriEncodeBytes(_uricTable, bytes, buffer);
     } else {
       buffer.write(';base64,');
       indices.add(buffer.length - 1);
       BASE64.encoder
             .startChunkedConversion(
@@ skipping 343 matching lines @@
 
   static UriData _parse(String text, int start, Uri sourceUri) {
     assert(start == 0 || start == 5);
     assert((start == 5) == text.startsWith("data:"));
 
     /// Character codes.
     const int comma     = 0x2c;
     const int slash     = 0x2f;
     const int semicolon = 0x3b;
     const int equals    = 0x3d;
-    List indices = [start - 1];
+    List<int> indices = [start - 1];
     int slashIndex = -1;
     var char;
     int i = start;
     for (; i < text.length; i++) {
       char = text.codeUnitAt(i);
       if (char == comma || char == semicolon) break;
       if (char == slash) {
         if (slashIndex < 0) {
           slashIndex = i;
           continue;
@@ skipping 100 matching lines @@
   // All non-escape RFC-2396 uric characters.
   //
   //  uric        =  reserved | unreserved | escaped
   //  reserved    =  ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" | "$" | ","
   //  unreserved  =  alphanum | mark
   //  mark        =  "-" | "_" | "." | "!" | "~" | "*" | "'" | "(" | ")"
   //
   // This is the same characters as in a URI query (which is URI pchar plus '?')
   static const _uricTable = Uri._queryCharTable;
 }