Cache hashCode in Uri implementations to improve performance when used as, e.g., Map key.

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;
 
 // Frequently used character codes.
 const int _SPACE = 0x20;
 const int _PERCENT = 0x25;
 const int _PLUS = 0x2B;
@@ skipping 1352 matching lines @@
    * Cache the computed return value of [pathSegements].
    */
   List<String> _pathSegments;
 
   /**
    * Cache of the full normalized text representation of the URI.
    */
   String _text;
 
   /**
+   * Cache of the hashCode of [_text].
+   *
+   * Is null until computed.
+   */
+  int _hashCodeCache;
+
+  /**
    * Cache the computed return value of [queryParameters].
    */
   Map<String, String> _queryParameters;
   Map<String, List<String>> _queryParameterLists;
 
   /// Internal non-verifying constructor. Only call with validated arguments.
   _Uri._internal(this.scheme,
                  this._userInfo,
                  this._host,
                  this._port,
@@ skipping 1190 matching lines @@
    * Access the structure of a `data:` URI.
    *
    * Returns a [UriData] object for `data:` URIs and `null` for all other
    * URIs.
    * The [UriData] object can be used to access the media type and data
    * of a `data:` URI.
    */
   UriData get data => (scheme == "data") ? new UriData.fromUri(this) : null;
 
   String toString() {
-    if (_text != null) return _text;
+    return _text ??= _initializeText();
+  }
+
+  String _initializeText() {
+    assert(_text == null);
     StringBuffer sb = new StringBuffer();
     if (scheme.isNotEmpty) sb..write(scheme)..write(":");
     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);
     if (_query != null) sb..write("?")..write(_query);
     if (_fragment != null) sb..write("#")..write(_fragment);
-    _text = sb.toString();
-    return _text;
+    return sb.toString();
   }
 
   bool operator==(other) {
     if (identical(this, other)) return true;
     if (other is Uri) {
       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;
     }
     return false;
   }
 
   int get hashCode {
-    return (_text ?? toString()).hashCode;
+    return _hashCodeCache ??= toString().hashCode;
   }
 
   static List _createList() => [];
 
   static Map _splitQueryStringAll(
       String query, {Encoding encoding: UTF8}) {
     Map result = {};
     int i = 0;
     int start = 0;
     int equalsIndex = -1;
@@ skipping 1366 matching lines @@
   final int _schemeEnd;
   final int _hostStart;
   final int _portStart;
   final int _pathStart;
   final int _queryStart;
   final int _fragmentStart;
   /// The scheme is often used to distinguish URIs.
   /// To make comparisons more efficient, we cache the value, and
   /// canonicalize a few known types.
   String _schemeCache;
+  int _hashCodeCache;
 
   _SimpleUri(
       this._uri,
       this._schemeEnd,
       this._hostStart,
       this._portStart,
       this._pathStart,
       this._queryStart,
       this._fragmentStart,
       this._schemeCache);
@@ skipping 387 matching lines @@
         "with an authority");
     }
     return this.path;
   }
 
   UriData get data {
     assert(scheme != "data");
     return null;
   }
 
-  int get hashCode => _uri.hashCode;
+  int get hashCode => _hashCodeCache ??= _uri.hashCode;
 
   bool operator==(Object other) {
     if (identical(this, other)) return true;
     if (other is Uri) return _uri == other.toString();
     return false;
   }
 
   Uri _toNonSimple() {
     return new _Uri._internal(
       this.scheme,
@@ skipping 22 matching lines @@
   int delta = (text.codeUnitAt(start + 4) ^ _COLON) * 3;
   delta |= text.codeUnitAt(start)     ^ 0x64 /*d*/;
   delta |= text.codeUnitAt(start + 1) ^ 0x61 /*a*/;
   delta |= text.codeUnitAt(start + 2) ^ 0x74 /*t*/;
   delta |= text.codeUnitAt(start + 3) ^ 0x61 /*a*/;
   return delta;
 }
 
 /// Helper function returning the length of a string, or `0` for `null`.
 int _stringOrNullLength(String s) => (s == null) ? 0 : s.length;