Try to retain original structure of URI.

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:**
  *
  * * [URIs][uris] in the [library tour][libtour]
  * * [RFC-3986](http://tools.ietf.org/html/rfc3986)
  *
  * [uris]: http://www.dartlang.org/docs/dart-up-and-running/contents/ch03.html#ch03-uri
  * [libtour]: http://www.dartlang.org/docs/dart-up-and-running/contents/ch03.html
  */
 class Uri {
+  // The host name of the URI.
+  // Set to `null` if there is no authority in a URI.
   final String _host;
+  // The port. Set to null if there is no port. Normalized to null if
+  // the port is the default port for the scheme.
+  // Set to the value of the default port if an empty port was supplied.
   int _port;
+  // The path. Always non-null.
   String _path;
 
   /**
    * Returns the scheme component.
    *
    * Returns the empty string if there is no scheme component.
    */
+  // We represent the missing scheme as an empty string.
+  // A valid scheme cannot be empty.
   final String scheme;
 
   /**
    * Returns the authority component.
    *
    * The authority is formatted from the [userInfo], [host] and [port]
    * parts.
    *
    * Returns the empty string if there is no authority component.
    */
   String get authority {
     if (!hasAuthority) return "";
     var sb = new StringBuffer();
     _writeAuthority(sb);
     return sb.toString();
   }
 
   /**
+   * The user-info part of the authority.
+   *
+   * Does not distinguish between an empty user-info and an absent one.
+   * The value is always non-null.
+   */
+  final String _userInfo;
+
+  /**
    * Returns the user info part of the authority component.
    *
    * Returns the empty string if there is no user info in the
    * authority component.
    */
-  final String userInfo;
+  String get userInfo => _userInfo;
 
   /**
    * Returns the host part of the authority component.
    *
    * Returns the empty string if there is no authority component and
    * hence no host.
    *
    * If the host is an IP version 6 address, the surrounding `[` and `]` is
    * removed.
    */
   String get host {
-    if (_host != null && _host.startsWith('[')) {
+    if (_host == null) return "";
+    if (_host.startsWith('[')) {
       return _host.substring(1, _host.length - 1);
     }
     return _host;
   }
 
   /**
    * Returns the port part of the authority component.
    *
-   * Returns 0 if there is no port in the authority component.
+   * Returns the defualt port if there is no port number in the authority
+   * component. That's 80 for http, 443 for https, and 0 for everything else.
    */
   int get port {
-    if (_port == 0) {
-      if (scheme == "http") return 80;
-      if (scheme == "https") return 443;
-    }
+    if (_port == null) return _defaultPort(scheme);
     return _port;
   }
 
+  // The default port for the scheme of this Uri..
+  static int _defaultPort(String scheme) {
+    if (scheme == "http") return 80;
+    if (scheme == "https") return 443;
+    return 0;
+  }
+
   /**
    * Returns the path component.
    *
    * The returned path is encoded. To get direct access to the decoded
    * path use [pathSegments].
    *
    * Returns the empty string if there is no path component.
    */
   String get path => _path;
 
+  // The query content, or null if there is no query.
+  final String _query;
+
   /**
    * Returns the query component. The returned query is encoded. To get
    * direct access to the decoded query use [queryParameters].
    *
    * Returns the empty string if there is no query component.
    */
-  final String query;
+  String get query => (_query == null) ? "" : _query;
+
+  // The fragment content, or null if there is no fragment.
+  final String _fragment;
 
   /**
    * Returns the fragment identifier component.
    *
    * Returns the empty string if there is no fragment identifier
    * component.
    */
-  final String fragment;
+  String get fragment => (_fragment == null) ? "" : _fragment;
 
   /**
    * Cache the computed return value of [pathSegements].
    */
   List<String> _pathSegments;
 
   /**
    * Cache the computed return value of [queryParameters].
    */
   Map<String, String> _queryParameters;
@@ skipping 58 matching lines @@
     //
     // query         = *( pchar / "/" / "?" )
     //
     // fragment      = *( pchar / "/" / "?" )
     bool isRegName(int ch) {
       return ch < 128 && ((_regNameTable[ch >> 4] & (1 << (ch & 0x0f))) != 0);
     }
     const int EOI = -1;
 
     String scheme = "";
-    String path;
     String userinfo = "";
-    String host = "";
-    int port = 0;
-    String query = "";
-    String fragment = "";
+    String host = null;
+    int port = null;
+    String path = null;
+    String query = null;
+    String fragment = null;
 
     int index = 0;
     int pathStart = 0;
     // End of input-marker.
     int char = EOI;
 
     void parseAuth() {
       if (index == uri.length) {
         char = EOI;
         return;
@@ skipping 26 matching lines @@
         index++;
         char = EOI;
       }
       int hostStart = authStart;
       int hostEnd = index;
       if (lastAt >= 0) {
         userinfo = _makeUserInfo(uri, authStart, lastAt);
         hostStart = lastAt + 1;
       }
       if (lastColon >= 0) {
-        int portNumber = 0;
-        for (int i = lastColon + 1; i < index; i++) {
-          int digit = uri.codeUnitAt(i);
-          if (_ZERO > digit || _NINE < digit) {
-            _fail(uri, i, "Invalid port number");
+        int portNumber;
+        if (lastColon + 1 < index) {
+          portNumber = 0;
+          for (int i = lastColon + 1; i < index; i++) {
+            int digit = uri.codeUnitAt(i);
+            if (_ZERO > digit || _NINE < digit) {
+              _fail(uri, i, "Invalid port number");
+            }
+            portNumber = portNumber * 10 + (digit - _ZERO);
           }
-          portNumber = portNumber * 10 + (digit - _ZERO);
         }
         port = _makePort(portNumber, scheme);
         hostEnd = lastColon;
       }
       host = _makeHost(uri, hostStart, hostEnd, true);
       if (index < uri.length) {
         char = uri.codeUnitAt(index);
       }
     }
 
@@ skipping 79 matching lines @@
         char = uri.codeUnitAt(index);
         if (char == _QUESTION || char == _NUMBER_SIGN) {
           break;
         }
         char = EOI;
       }
       state = NOT_IN_PATH;
     }
 
     assert(state == NOT_IN_PATH);
-    bool ensureLeadingSlash = (host != "" || scheme == "file");
+    bool ensureLeadingSlash = (host != null || scheme == "file");
     path = _makePath(uri, pathStart, index, null, ensureLeadingSlash);
 
     if (char == _QUESTION) {
       int numberSignIndex = uri.indexOf('#', index + 1);
       if (numberSignIndex < 0) {
         query = _makeQuery(uri, index + 1, uri.length, null);
       } else {
         query = _makeQuery(uri, index + 1, numberSignIndex, null);
         fragment = _makeFragment(uri, numberSignIndex + 1, uri.length);
       }
@@ skipping 36 matching lines @@
       }
       // Combine message, slice and a caret pointing to the error index.
       message = "$message$pre${uri.substring(min, max)}$post\n"
                 "${' ' * (pre.length + index - min)}^";
     }
     throw new FormatException(message);
   }
 
   /// Internal non-verifying constructor. Only call with validated arguments.
   Uri._internal(this.scheme,
-                this.userInfo,
+                this._userInfo,
                 this._host,
                 this._port,
                 this._path,
-                this.query,
-                this.fragment);
+                this._query,
+                this._fragment);
 
   /**
    * Creates a new URI from its components.
    *
    * Each component is set through a named argument. Any number of
-   * components can be provided. The default value for the components
-   * not provided is the empry string, except for [port] which has a
-   * default value of 0. The [path] and [query] components can be set
-   * using two different named arguments.
+   * components can be provided. The [path] and [query] components can be set
+   * using either of two different named arguments.
    *
    * The scheme component is set through [scheme]. The scheme is
-   * normalized to all lowercase letters.
+   * normalized to all lowercase letters. If the scheme is omitted or empty,
+   * the URI will not have a scheme part.
    *
    * The user info part of the authority component is set through
-   * [userInfo].
+   * [userInfo]. It defaults to the empty string, which will be omitted
+   * from the string representation of the URI.
    *
    * The host part of the authority component is set through
    * [host]. The host can either be a hostname, an IPv4 address or an
    * IPv6 address, contained in '[' and ']'. If the host contains a
    * ':' character, the '[' and ']' are added if not already provided.
    * The host is normalized to all lowercase letters.
    *
    * The port part of the authority component is set through
-   * [port]. The port is normalized for scheme http and https where
-   * port 80 and port 443 respectively is set.
+   * [port].
+   * If [port] is omitted or `null`, it implies the default port for
+   * the URI's scheme, and is equivalent to passing that port explicitly.
+   * The recognized schemes, and their default ports, are "http" (80) and
+   * "https" (443). All other schemes are considered as having zero as the
+   * default port.
+   *
+   * If any of `userInfo`, `host` or `port` are provided,
+   * the URI will have an autority according to [hasAuthority].
    *
    * The path component is set through either [path] or
-   * [pathSegments]. When [path] is used, the provided string is
-   * expected to be fully percent-encoded, and is used in its literal
-   * form. When [pathSegments] is used, each of the provided segments
-   * is percent-encoded and joined using the forward slash
+   * [pathSegments]. When [path] is used, it should be a valid URI path,
+   * but invalid characters, except the general delimiters ':/@[]?#',
+   * will be escaped if necessary.
+   * When [pathSegments] is used, each of the provided segments
+   * is first percent-encoded and then joined using the forward slash
    * separator. The percent-encoding of the path segments encodes all
    * characters except for the unreserved characters and the following
    * list of characters: `!$&'()*+,;=:@`. If the other components
    * calls for an absolute path a leading slash `/` is prepended if
    * not already there.
    *
    * The query component is set through either [query] or
-   * [queryParameters]. When [query] is used the provided string is
-   * expected to be fully percent-encoded and is used in its literal
-   * form. When [queryParameters] is used the query is built from the
+   * [queryParameters]. When [query] is used the provided string should
+   * be a valid URI query, but invalid characters other than general delimiters,
+   * will be escaped if necessary.
+   * 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. The
    * percent-encoding of the keys and values encodes all characters
    * except for the unreserved characters.
+   * If both `query` and `queryParameters` are omitted or `null`, the
+   * URI will have no query part.
    *
    * The fragment component is set through [fragment].
+   * It should be a valid URI fragment, but invalid characters other than
+   * general delimiters, will be escaped if necessary.
+   * If `fragment` is omitted or `null`, the URI will have no fragment part.
    */
-  factory Uri({String scheme,
-       String userInfo: "",
-       String host: "",
-       port: 0,
-       String path,
-       Iterable<String> pathSegments,
-       String query,
-       Map<String, String> queryParameters,
-       fragment: ""}) {
+  factory Uri({String scheme : "",
+               String userInfo : "",
+               String host,
+               int port,
+               String path,
+               Iterable<String> pathSegments,
+               String query,
+               Map<String, String> queryParameters,
+               fragment}) {
     scheme = _makeScheme(scheme, _stringOrNullLength(scheme));
     userInfo = _makeUserInfo(userInfo, 0, _stringOrNullLength(userInfo));
     host = _makeHost(host, 0, _stringOrNullLength(host), false);
     query = _makeQuery(query, 0, _stringOrNullLength(query), queryParameters);
     fragment = _makeFragment(fragment, 0, _stringOrNullLength(fragment));
     port = _makePort(port, scheme);
-    bool ensureLeadingSlash = (host != "" || scheme == "file");
+    bool isFile = (scheme == "file");
+    if (host == null &&
+        (userInfo.isNotEmpty || port != null || isFile)) {
+      host = "";
+    }
+    bool ensureLeadingSlash = (host != null || isFile);
     path = _makePath(path, 0, _stringOrNullLength(path), pathSegments,
                      ensureLeadingSlash);
 
     return new Uri._internal(scheme, userInfo, host, port,
                              path, query, fragment);
   }
 
   /**
    * Creates a new `http` URI from authority, path and query.
    *
    * Examples:
    *
    * ```
    * // http://example.org/path?q=dart.
    * new Uri.http("google.com", "/search", { "q" : "dart" });
    *
    * // http://user:pass@localhost:8080
    * new Uri.http("user:pass@localhost:8080", "");
    *
    * // http://example.org/a%20b
    * new Uri.http("example.org", "a b");
    *
    * // http://example.org/a%252F
    * new Uri.http("example.org", "/a%2F");
    * ```
    *
    * The `scheme` is always set to `http`.
    *
    * The `userInfo`, `host` and `port` components are set from the
-   * [authority] argument.
+   * [authority] argument. If `authority` is `null` or empty,
+   * the created `Uri` will have no authority, and will not be directly usable
+   * as an HTTP URL, which must have a non-empty host.
    *
    * The `path` component is set from the [unencodedPath]
    * argument. The path passed must not be encoded as this constructor
    * encodes the path.
    *
    * The `query` component is set from the optional [queryParameters]
    * argument.
    */
   factory Uri.http(String authority,
                    String unencodedPath,
@@ skipping 11 matching lines @@
                     String unencodedPath,
                     [Map<String, String> queryParameters]) {
     return _makeHttpUri("https", authority, unencodedPath, queryParameters);
   }
 
   static Uri _makeHttpUri(String scheme,
                           String authority,
                           String unencodedPath,
                           Map<String, String> queryParameters) {
     var userInfo = "";
-    var host = "";
-    var port = 0;
+    var host = null;
+    var port = null;
 
-    var hostStart = 0;
-    // Split off the user info.
-    bool hasUserInfo = false;
-    for (int i = 0; i < authority.length; i++) {
-      if (authority.codeUnitAt(i) == _AT_SIGN) {
-        hasUserInfo = true;
-        userInfo = authority.substring(0, i);
-        hostStart = i + 1;
-        break;
+    if (authority != null && authority.isNotEmpty) {
+      var hostStart = 0;
+      // Split off the user info.
+      bool hasUserInfo = false;
+      for (int i = 0; i < authority.length; i++) {
+        if (authority.codeUnitAt(i) == _AT_SIGN) {
+          hasUserInfo = true;
+          userInfo = authority.substring(0, i);
+          hostStart = i + 1;
+          break;
+        }
       }
+      var hostEnd = hostStart;
+      if (hostStart < authority.length &&
+          authority.codeUnitAt(hostStart) == _LEFT_BRACKET) {
+        // IPv6 host.
+        for (; hostEnd < authority.length; hostEnd++) {
+          if (authority.codeUnitAt(hostEnd) == _RIGHT_BRACKET) break;
+        }
+        if (hostEnd == authority.length) {
+          throw new FormatException("Invalid IPv6 host entry.");
+        }
+        parseIPv6Address(authority, hostStart + 1, hostEnd);
+        hostEnd++;  // Skip the closing bracket.
+        if (hostEnd != authority.length &&
+            authority.codeUnitAt(hostEnd) != _COLON) {
+          throw new FormatException("Invalid end of authority");
+        }
+      }
+      // Split host and port.
+      bool hasPort = false;
+      for (; hostEnd < authority.length; hostEnd++) {
+        if (authority.codeUnitAt(hostEnd) == _COLON) {
+          var portString = authority.substring(hostEnd + 1);
+          // We allow the empty port - falling back to initial value.
+          if (portString.isNotEmpty) port = int.parse(portString);
+          break;
+        }
+      }
+      host = authority.substring(hostStart, hostEnd);
     }
-    var hostEnd = hostStart;
-    if (hostStart < authority.length &&
-        authority.codeUnitAt(hostStart) == _LEFT_BRACKET) {
-      // IPv6 host.
-      for (; hostEnd < authority.length; hostEnd++) {
-        if (authority.codeUnitAt(hostEnd) == _RIGHT_BRACKET) break;
-      }
-      if (hostEnd == authority.length) {
-        throw new FormatException("Invalid IPv6 host entry.");
-      }
-      parseIPv6Address(authority, hostStart + 1, hostEnd);
-      hostEnd++;  // Skip the closing bracket.
-      if (hostEnd != authority.length &&
-          authority.codeUnitAt(hostEnd) != _COLON) {
-        throw new FormatException("Invalid end of authority");
-      }
-    }
-    // Split host and port.
-    bool hasPort = false;
-    for (; hostEnd < authority.length; hostEnd++) {
-      if (authority.codeUnitAt(hostEnd) == _COLON) {
-        var portString = authority.substring(hostEnd + 1);
-        // We allow the empty port - falling back to initial value.
-        if (portString.isNotEmpty) port = int.parse(portString);
-        break;
-      }
-    }
-    host = authority.substring(hostStart, hostEnd);
-
     return new Uri(scheme: scheme,
                    userInfo: userInfo,
                    host: host,
                    port: port,
                    pathSegments: unencodedPath.split("/"),
                    queryParameters: queryParameters);
   }
 
   /**
    * Creates a new file URI from an absolute or relative file path.
@@ skipping 130 matching lines @@
       throw new ArgumentError("Illegal drive letter " +
                               new String.fromCharCode(charCode));
     } else {
       throw new UnsupportedError("Illegal drive letter " +
                               new String.fromCharCode(charCode));
     }
   }
 
   static _makeFileUri(String path) {
     String sep = "/";
-    if (path.length > 0 && path[0] == sep) {
+  if (path.startsWith(sep)) {
       // Absolute file:// URI.
       return new Uri(scheme: "file", pathSegments: path.split(sep));
     } else {
       // Relative URI.
       return new Uri(pathSegments: path.split(sep));
     }
   }
 
   static _makeWindowsFileUrl(String path) {
     if (path.startsWith("\\\\?\\")) {
@@ skipping 88 matching lines @@
    */
   Map<String, String> get queryParameters {
     if (_queryParameters == null) {
       _queryParameters = new UnmodifiableMapView(splitQueryString(query));
     }
     return _queryParameters;
   }
 
   static int _makePort(int port, String scheme) {
     // Perform scheme specific normalization.
-    if (port == 80 && scheme == "http") {
-      return 0;
-    }
-    if (port == 443 && scheme == "https") {
-      return 0;
-    }
+    if (port != null && port == _defaultPort(scheme)) return null;
     return port;
   }
 
   /**
    * Check and normalize a most name.
    *
    * If the host name starts and ends with '[' and ']', it is considered an
    * IPv6 address. If [strictIPv6] is false, the address is also considered
    * an IPv6 address if it contains any ':' character.
    *
    * If it is not an IPv6 address, it is case- and escape-normalized.
    * This escapes all characters not valid in a reg-name,
    * and converts all non-escape upper-case letters to lower-case.
    */
   static String _makeHost(String host, int start, int end, bool strictIPv6) {
     // TODO(lrn): Should we normalize IPv6 addresses according to RFC 5952?
-
     if (host == null) return null;
     if (start == end) return "";
     // Host is an IPv6 address if it starts with '[' or contains a colon.
     if (host.codeUnitAt(start) == _LEFT_BRACKET) {
       if (host.codeUnitAt(end - 1) != _RIGHT_BRACKET) {
         _fail(host, start, 'Missing end `]` to match `[` in host');
       }
       parseIPv6Address(host, start + 1, end - 1);
       // RFC 5952 requires hex digits to be lower case.
       return host.substring(start, end).toLowerCase();
@@ skipping 112 matching lines @@
       if (_LOWER_CASE_A <= char && _LOWER_CASE_Z >= char) {
         allLowercase = false;
       }
     }
     scheme = scheme.substring(0, end);
     if (!allLowercase) scheme = scheme.toLowerCase();
     return scheme;
   }
 
   static String _makeUserInfo(String userInfo, int start, int end) {
-    if (userInfo == null) return "null";
+    if (userInfo == null) return "";
     return _normalize(userInfo, start, end, _userinfoTable);
   }
 
   static String _makePath(String path, int start, int end,
                           Iterable<String> pathSegments,
                           bool ensureLeadingSlash) {
     if (path == null && pathSegments == null) return "";
     if (path != null && pathSegments != null) {
       throw new ArgumentError('Both path and pathSegments specified');
     }
     var result;
     if (path != null) {
       result = _normalize(path, start, end, _pathCharOrSlashTable);
     } else {
       result = pathSegments.map((s) => _uriEncode(_pathCharTable, s)).join("/");
     }
     if (ensureLeadingSlash && result.isNotEmpty && !result.startsWith("/")) {
       return "/$result";
     }
     return result;
   }
 
   static String _makeQuery(String query, int start, int end,
                            Map<String, String> queryParameters) {
-    if (query == null && queryParameters == null) return "";
+    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 first = true;
     queryParameters.forEach((key, value) {
       if (!first) {
         result.write("&");
       }
       first = false;
       result.write(Uri.encodeQueryComponent(key));
       if (value != null && !value.isEmpty) {
         result.write("=");
         result.write(Uri.encodeQueryComponent(value));
       }
     });
     return result.toString();
   }
 
   static String _makeFragment(String fragment, int start, int end) {
-    if (fragment == null) return "";
+    if (fragment == null) return null;
     return _normalize(fragment, start, end, _queryCharTable);
   }
 
   static int _stringOrNullLength(String s) => (s == null) ? 0 : s.length;
 
   static bool _isHexDigit(int char) {
     if (_NINE >= char) return _ZERO <= char;
     char |= 0x20;
     return _LOWER_CASE_A <= char && _LOWER_CASE_F >= char;
   }
@@ skipping 219 matching lines @@
    *
    * Returns the resolved URI.
    *
    * The algorithm for resolving a reference is described in
    * [RFC-3986 Section 5]
    * (http://tools.ietf.org/html/rfc3986#section-5 "RFC-1123").
    */
   Uri resolveUri(Uri reference) {
     // From RFC 3986.
     String targetScheme;
-    String targetUserInfo;
+    String targetUserInfo = "";
     String targetHost;
     int targetPort;
     String targetPath;
     String targetQuery;
-    if (reference.scheme != "") {
+    if (reference.scheme.isNotEmpty) {
       targetScheme = reference.scheme;
-      targetUserInfo = reference.userInfo;
-      targetHost = reference.host;
-      targetPort = reference.port;
-      targetPath = _removeDotSegments(reference.path);
-      targetQuery = reference.query;
-    } else {
       if (reference.hasAuthority) {
         targetUserInfo = reference.userInfo;
         targetHost = reference.host;
-        targetPort = reference.port;
+        targetPort = reference.hasPort ? reference.port : null;
+      }
+      targetPath = _removeDotSegments(reference.path);
+      if (reference.hasQuery) {
+        targetQuery = reference.query;
+      }
+    } else {
+      targetScheme = this.scheme;
+      if (reference.hasAuthority) {
+        targetUserInfo = reference.userInfo;
+        targetHost = reference.host;
+        targetPort = _makePort(reference.hasPort ? reference.port : null,
+                               targetScheme);
         targetPath = _removeDotSegments(reference.path);
-        targetQuery = reference.query;
+        if (reference.hasQuery) targetQuery = reference.query;
       } else {
         if (reference.path == "") {
-          targetPath = this.path;
-          if (reference.query != "") {
+          targetPath = this._path;
+          if (reference.hasQuery) {
             targetQuery = reference.query;
           } else {
-            targetQuery = this.query;
+            targetQuery = this._query;
           }
         } else {
           if (reference.path.startsWith("/")) {
             targetPath = _removeDotSegments(reference.path);
           } else {
-            targetPath = _removeDotSegments(_merge(this.path, reference.path));
+            targetPath = _removeDotSegments(_merge(this._path, reference.path));
           }
-          targetQuery = reference.query;
+          if (reference.hasQuery) targetQuery = reference.query;
         }
-        targetUserInfo = this.userInfo;
-        targetHost = this.host;
-        targetPort = this.port;
+        targetUserInfo = this._userInfo;
+        targetHost = this._host;
+        targetPort = this._port;
       }
-      targetScheme = this.scheme;
     }
-    return new Uri(scheme: targetScheme,
-                   userInfo: targetUserInfo,
-                   host: targetHost,
-                   port: targetPort,
-                   path: targetPath,
-                   query: targetQuery,
-                   fragment: reference.fragment);
+    String fragment = reference.hasFragment ? reference.fragment : null;
+    return new Uri._internal(targetScheme,
+                             targetUserInfo,
+                             targetHost,
+                             targetPort,
+                             targetPath,
+                             targetQuery,
+                             fragment);
   }
 
   /**
    * Returns whether the URI has an [authority] component.
    */
-  bool get hasAuthority => host != "";
+  bool get hasAuthority => _host != null;
+
+  /**
+   * Returns whether the URI has an explicit port.
+   *
+   * If the port number is the default port number
+   * (zero for unrecognized schemes, with http (80) and https (443) being
+   * recognized),
+   * then the port is made implicit and omitted from the URI.
+   */
+  bool get hasPort => _port != null;
+
+  /**
+   * Returns whether the URI has a query part.
+   */
+  bool get hasQuery => _query != null;
+
+  /**
+   * Returns whether the URI has a fragment part.
+   */
+  bool get hasFragment => _fragment != null;
 
   /**
    * Returns the origin of the URI in the form scheme://host:port for the
    * schemes http and https.
    *
    * It is an error if the scheme is not "http" or "https".
    *
    * See: http://www.w3.org/TR/2011/WD-html5-20110405/origin-0.html#origin
    */
   String get origin {
     if (scheme == "" || _host == null || _host == "") {
       throw new StateError("Cannot use origin without a scheme: $this");
     }
     if (scheme != "http" && scheme != "https") {
       throw new StateError(
         "Origin is only applicable schemes http and https: $this");
     }
-    if (_port == 0) return "$scheme://$_host";
+    if (_port == null) return "$scheme://$_host";
     return "$scheme://$_host:$_port";
   }
 
   /**
    * Returns the file path from a file URI.
    *
    * The returned path has either Windows or non-Windows
    * semantics.
    *
    * For non-Windows semantics the slash ("/") is used to separate
@@ skipping 106 matching lines @@
     if (hasDriveLetter && segments.length == 1) result.write("\\");
     return result.toString();
   }
 
   bool get _isPathAbsolute {
     if (path == null || path.isEmpty) return false;
     return path.startsWith('/');
   }
 
   void _writeAuthority(StringSink ss) {
-    _addIfNonEmpty(ss, userInfo, userInfo, "@");
-    ss.write(_host == null ? "null" : _host);
-    if (_port != 0) {
+    if (_userInfo.isNotEmpty) {
+      ss.write(_userInfo);
+      ss.write("@");
+    }
+    if (_host != null) ss.write(_host);
+    if (_port != null) {
       ss.write(":");
-      ss.write(_port.toString());
+      ss.write(_port);
     }
   }
 
   String toString() {
     StringBuffer sb = new StringBuffer();
     _addIfNonEmpty(sb, scheme, scheme, ':');
     if (hasAuthority || path.startsWith("//") || (scheme == "file")) {
       // File URIS always have the authority, even if it is empty.
       // The empty URI means "localhost".
       sb.write("//");
       _writeAuthority(sb);
     }
     sb.write(path);
-    _addIfNonEmpty(sb, query, "?", query);
-    _addIfNonEmpty(sb, fragment, "#", fragment);
+    if (_query != null) { sb..write("?")..write(_query); }
+    if (_fragment != null) { sb..write("#")..write(_fragment); }
     return sb.toString();
   }
 
   bool operator==(other) {
     if (other is! Uri) return false;
     Uri uri = other;
     return scheme == uri.scheme &&
+        hasAuthority == uri.hasAuthority &&
         userInfo == uri.userInfo &&
         host == uri.host &&
         port == uri.port &&
         path == uri.path &&
+        hasQuery == uri.hasQuery &&
         query == uri.query &&
+        hasFragment == uri.hasFragment &&
         fragment == uri.fragment;
   }
 
   int get hashCode {
     int combine(part, current) {
       // The sum is truncated to 30 bits to make sure it fits into a Smi.
       return (current * 31 + part.hashCode) & 0x3FFFFFFF;
     }
     return combine(scheme, combine(userInfo, combine(host, combine(port,
         combine(path, combine(query, combine(fragment, 1)))))));
@@ skipping 679 matching lines @@
       0xafff,   // 0x30 - 0x3f  1111111111110101
                 //              @ABCDEFGHIJKLMNO
       0xffff,   // 0x40 - 0x4f  1111111111111111
                 //              PQRSTUVWXYZ    _
       0x87ff,   // 0x50 - 0x5f  1111111111100001
                 //               abcdefghijklmno
       0xfffe,   // 0x60 - 0x6f  0111111111111111
                 //              pqrstuvwxyz   ~
       0x47ff];  // 0x70 - 0x7f  1111111111100010
 }