Adapt to breaking change in SDK (TBR)

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.
@@ skipping 116 matching lines @@
         return identical(other, this);
       }
       return _text == other._text;
     } else if (other is Uri) {
       return _fallbackUri == other;
     }
     return false;
   }
 
   @override
+  bool isScheme(String scheme) {
+    String thisScheme = this.scheme;
+    if (scheme == null) return thisScheme.isEmpty;
+    if (scheme.length != thisScheme.length) return false;
+    return _compareScheme(scheme, thisScheme);
+  }
+
+  @override
   Uri normalizePath() {
     return this;
   }
 
   @override
   Uri removeFragment() {
     return this;
   }
 
   @override
@@ skipping 76 matching lines @@
       if (_currentCacheLength > _MAX_CACHE_LENGTH_BEFORE_FLUSH) {
         _cache.clear();
         _currentCacheLength = 0;
         _currentCacheGeneration++;
       }
     }
     return uri;
   }
 
   /**
+   * Compares scheme characters in [scheme] and at the start of [uri].
+   *
+   * Returns `true` if [scheme] represents the same scheme as the start of
+   * [uri]. That means having the same characters, but possibly different case
+   * for letters.
+   *
+   * This function doesn't check that the characters are valid URI scheme
+   * characters. The [uri] is assumed to be valid, so if [scheme] matches
+   * it, it has to be valid too.
+   *
+   * The length should be tested before calling this function,
+   * so the scheme part of [uri] is known to have the same length as [scheme].
+   */
+  static bool _compareScheme(String scheme, String uri) {
+    for (int i = 0; i < scheme.length; i++) {
+      int schemeChar = scheme.codeUnitAt(i);
+      int uriChar = uri.codeUnitAt(i);
+      int delta = schemeChar ^ uriChar;
+      if (delta != 0) {
+        if (delta == 0x20) {
+          // Might be a case difference.
+          int lowerChar = uriChar | delta;
+          if (0x61 /*a*/ <= lowerChar && lowerChar <= 0x7a /*z*/) {
+            continue;
+          }
+        }
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /**
    * 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;
     }
@@ skipping 73 matching lines @@
    * Determine whether VM has the text based hash code computation in [Uri],
    * or the old combine style.
    *
    * See https://github.com/dart-lang/sdk/issues/27159 for details.
    */
   static bool _shouldComputeHashCodeUsingText() {
     String text = 'package:foo/foo.dart';
     return Uri.parse(text).hashCode == text.hashCode;
   }
 }