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.
+    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('//')) {
+      if (!path.startsWith('/')) {

[Brian Wilkerson, 2016/05/23 13:53:53]

If the path starts with two slashes, how can it not start with a slash?

[scheglov, 2016/05/23 13:58:10]

Ouch...
This code should be after updating the path.
Fixed.
Thank you.

+        return null;
+      }
+      hasEmptyAuthority = true;
       path = path.substring(2);
     }
-    return new FastUri._(
-        _currentCacheGeneration, text, scheme, path, lastSlashIndex);
+    return new FastUri._(_currentCacheGeneration, text, scheme,
+        hasEmptyAuthority, path, lastSlashIndex);
   }
 }