Fix for FastUri.hashCode and hasAuthorizy (to fix ==).

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;
 
   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 hashcode.
    */
   int _hashCode;
 
   Uri _cachedFallbackUri;
 
-  FastUri._(this._cacheGeneration, this._text, this._scheme, this._path,
-      this._lastSlashIndex);
+  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 => false;
+  bool get hasAuthority => _hasEmptyAuthority;
 
   @override
   bool get hasEmptyPath => _path.isEmpty;
 
   @override
   bool get hasFragment => false;
 
   @override
   int get hashCode {
-    _hashCode ??= (scheme.hashCode * 31 + path.hashCode) & 0x3FFFFFFF;
-    return _hashCode;
+    // This code is copied from the standard Uri implementation.

[Paul Berry, 2016/05/23 15:34:01]

Nit: Consider including a comment explaining why it's necessary to copy this
code from the standard Uri implementation, e.g.

"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 _hashCode ??= combine(
+        scheme,
+        combine(
+            userInfo,
+            combine(
+                host,
+                combine(port,
+                    combine(path, combine(query, combine(fragment, 1)))))));
   }
 
   @override
   bool get hasPort => false;
 
   @override
   bool get hasQuery => false;
 
   @override
   bool get hasScheme => _scheme.isNotEmpty;
@@ skipping 178 matching lines @@
         if (schemeEnd != null) {
           return null;
         }
         schemeEnd = i;
         pathStart = i + 1;
       } else {
         return null;
       }
     }
     String scheme = schemeEnd != null ? text.substring(0, schemeEnd) : '';
+    bool hasEmptyAuthority = false;
     String path = text.substring(pathStart);
     if (path.startsWith('//')) {
+      hasEmptyAuthority = true;
       path = path.substring(2);
+      if (!path.startsWith('/')) {
+        return null;
+      }
     }
-    return new FastUri._(
-        _currentCacheGeneration, text, scheme, path, lastSlashIndex);
+    return new FastUri._(_currentCacheGeneration, text, scheme,
+        hasEmptyAuthority, path, lastSlashIndex);
   }
 }