Detect the VM's Uri hashCode computation algorithm and use it in FastUri.

pkg/analyzer/lib/src/util/fast_uri.dart

 // Copyright (c) 2016, 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.
 
 import 'dart:collection';
 
 /**
  * Implementation of [Uri] that understands only a limited set of valid
  * URI formats, but works fast. In practice Dart code almost always uses such
  * limited URI format, so almost always can be processed fast.
  */
 class FastUri implements Uri {
   /***
    * The maximum [_cache] length before we flush it and start a new generation.
    */
   static const int _MAX_CACHE_LENGTH_BEFORE_FLUSH = 50000;
 
   static HashMap<String, Uri> _cache = new HashMap<String, Uri>();
   static int _currentCacheLength = 0;
   static int _currentCacheGeneration = 0;
 
+  static bool _hashUsingText = _shouldComputeHashCodeUsingText();
+
   final int _cacheGeneration;
   final String _text;
   final String _scheme;
   final bool _hasEmptyAuthority;
   final String _path;
 
   /**
    * The offset of the last `/` in [_text], or `null` if there isn't any.
    */
   final int _lastSlashIndex;
 
+  /**
+   * The cached hash code.
+   */
+  int _hashCode;
+
   Uri _cachedFallbackUri;
 
   FastUri._(this._cacheGeneration, this._text, this._scheme,
       this._hasEmptyAuthority, this._path, this._lastSlashIndex);
 
   @override
   String get authority => '';
 
   @override
   UriData get data => null;
 
   @override
   String get fragment => '';
 
   @override
   bool get hasAbsolutePath => path.startsWith('/');
 
   @override
   bool get hasAuthority => _hasEmptyAuthority;
 
   @override
   bool get hasEmptyPath => _path.isEmpty;
 
   @override
   bool get hasFragment => false;
 
   @override
-  int get hashCode => _text.hashCode;
+  int get hashCode {
+    return _hashCode ??= _hashUsingText
+        ? _computeHashUsingText(this)
+        : _computeHashUsingCombine(this);
+  }
 
   @override
   bool get hasPort => false;
 
   @override
   bool get hasQuery => false;
 
   @override
   bool get hasScheme => _scheme.isNotEmpty;
 
@@ skipping 139 matching lines @@
       // If the cache is too big, start a new generation.
       if (_currentCacheLength > _MAX_CACHE_LENGTH_BEFORE_FLUSH) {
         _cache.clear();
         _currentCacheLength = 0;
         _currentCacheGeneration++;
       }
     }
     return uri;
   }
 
+  /**
+   * This implementation was used before 'fast-URI' in Dart VM.
+   */
+  static int _computeHashUsingCombine(FastUri uri) {
+    // This code is copied from the standard Uri implementation.
+    // It is important that Uri and FastUri generate compatible hashCodes
+    // because Uri and FastUri may be used as keys in the same map.
+    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(
+        uri.scheme,
+        combine(
+            uri.userInfo,
+            combine(
+                uri.host,
+                combine(
+                    uri.port,
+                    combine(uri.path,
+                        combine(uri.query, combine(uri.fragment, 1)))))));
+  }
+
+  /**
+   * This implementation should be used with 'fast-URI' in Dart VM.
+   * https://github.com/dart-lang/sdk/commit/afbbbb97cfcd86a64d0ba5dcfe1ab758954adaf4
+   */
+  static int _computeHashUsingText(FastUri uri) {
+    return uri._text.hashCode;
+  }
+
   static bool _isAlphabetic(int char) {
     return char >= 'A'.codeUnitAt(0) && char <= 'Z'.codeUnitAt(0) ||
         char >= 'a'.codeUnitAt(0) && char <= 'z'.codeUnitAt(0);
   }
 
   static bool _isDigit(int char) {
     return char >= '0'.codeUnitAt(0) && char <= '9'.codeUnitAt(0);
   }
 
   /**
@@ skipping 30 matching lines @@
     if (path.startsWith('//')) {
       hasEmptyAuthority = true;
       path = path.substring(2);
       if (!path.startsWith('/')) {
         return null;
       }
     }
     return new FastUri._(_currentCacheGeneration, text, scheme,
         hasEmptyAuthority, path, lastSlashIndex);
   }
+
+  /**
+   * Determine whether VM has the text based hash code computation in [Uri],
+   * or the old combine style.
+   */
+  static bool _shouldComputeHashCodeUsingText() {
+    String text = 'package:foo/foo.dart';
+    return Uri.parse(text).hashCode == text.hashCode;
+  }
 }