unfork DDC's copy of most SDK libraries

pkg/dev_compiler/tool/input_sdk/patch/core_patch.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.
 
 // Patch file for dart:core classes.
 import "dart:_internal" as _symbol_dev;
 import 'dart:_interceptors';
 import 'dart:_js_helper' show patch,
                               checkInt,
                               getRuntimeType,
@@ skipping 11 matching lines @@
 
 String _symbolToString(Symbol symbol) => _symbol_dev.Symbol.getName(symbol);
 
 @patch
 int identityHashCode(Object object) => objectHashCode(object);
 
 // Patch for Object implementation.
 @patch
 class Object {
   @patch
+  bool operator==(other) => identical(this, other);
+
+  @patch
   int get hashCode => Primitives.objectHashCode(this);
 
-
   @patch
   String toString() => Primitives.objectToString(this);
 
   @patch
   dynamic noSuchMethod(Invocation invocation) {
     throw new NoSuchMethodError(
         this,
         invocation.memberName,
         invocation.positionalArguments,
         invocation.namedArguments);
   }
 
   @patch
   Type get runtimeType =>
       JS('Type', 'dart.wrapType(dart.getReifiedType(#))', this);
 }
 
+@patch
+class Null {
+  @patch
+  int get hashCode => super.hashCode;
+}
+
 // Patch for Function implementation.
 @patch
 class Function {
   @patch
   static apply(Function f,
                List positionalArguments,
                [Map<Symbol, dynamic> namedArguments]) {
     positionalArguments ??= [];
     // dcall expects the namedArguments as a JS map in the last slot.
     if (namedArguments != null && namedArguments.isNotEmpty) {
@@ skipping 87 matching lines @@
 
   @patch
   static String _stringToSafeString(String string) {
     return jsonEncodeNative(string);
   }
 
   @patch
   StackTrace get stackTrace => Primitives.extractStackTrace(this);
 }
 
+@patch
+class FallThroughError {
+  @patch
+  String toString() => super.toString();
+}
+
+@patch
+class AbstractClassInstantiationError {
+  @patch
+  String toString() => "Cannot instantiate abstract class: '$_className'";
+}
+
 /// An interface type for all Strong-mode errors.
 class StrongModeError extends Error {}
 
 // Patch for DateTime implementation.
 @patch
 class DateTime {
   @patch
   DateTime.fromMillisecondsSinceEpoch(int millisecondsSinceEpoch,
                                       {bool isUtc: false})
       : this._withValue(millisecondsSinceEpoch, isUtc: isUtc);
@@ skipping 251 matching lines @@
   }
 }
 
 @patch
 class bool {
   @patch
   factory bool.fromEnvironment(String name, {bool defaultValue: false}) {
     throw new UnsupportedError(
         'bool.fromEnvironment can only be used as a const constructor');
   }
+
+  @patch
+  int get hashCode => super.hashCode;  
 }
 
 @patch
 class RegExp {
   @patch
   factory RegExp(String source,
                        {bool multiLine: false,
                         bool caseSensitive: true})
     => new JSSyntaxRegExp(source,
                           multiLine: multiLine,
@@ skipping 66 matching lines @@
   }
 
   static String _writeOne(String string, Object obj) {
     return Primitives.stringConcatUnchecked(string, '$obj');
   }
 }
 
 @patch
 class NoSuchMethodError {
   @patch
+  NoSuchMethodError(Object receiver,
+                    Symbol memberName,
+                    List positionalArguments,
+                    Map<Symbol, dynamic> namedArguments,
+                    [List existingArgumentNames = null])
+      : _receiver = receiver,
+        _memberName = memberName,
+        _arguments = positionalArguments,
+        _namedArguments = namedArguments,
+        _existingArgumentNames = existingArgumentNames;
+
+  @patch
   String toString() {
     StringBuffer sb = new StringBuffer();
     int i = 0;
     if (_arguments != null) {
       for (; i < _arguments.length; i++) {
         if (i > 0) {
           sb.write(", ");
         }
         sb.write(Error.safeToString(_arguments[i]));
       }
@@ skipping 28 matching lines @@
           "Receiver: ${Error.safeToString(_receiver)}\n"
           "Tried calling: $_memberName($actualParameters)\n"
           "Found: $_memberName($formalParameters)";
     }
   }
 }
 
 @patch
 class Uri {
   @patch
-  static bool get _isWindows => false;
-
-  @patch
   static Uri get base {
     String uri = Primitives.currentUri();
     if (uri != null) return Uri.parse(uri);
     throw new UnsupportedError("'Uri.base' is not supported");
   }
+}
 
+@patch
+class _Uri {
+  @patch
+  static bool get _isWindows => false;
 
   // Matches a String that _uriEncodes to itself regardless of the kind of
   // component.  This corresponds to [_unreservedTable], i.e. characters that
   // are not encoded by any encoding table.
   static final RegExp _needsNoEncoding = new RegExp(r'^[\-\.0-9A-Z_a-z~]*$');
 
   /**
    * This is the internal implementation of JavaScript's encodeURI function.
    * It encodes all characters in the string [text] except for those
    * that appear in [canonicalTable], and returns the escaped string.
    */
   @patch
   static String _uriEncode(List<int> canonicalTable,
                            String text,
                            Encoding encoding,
                            bool spaceToPlus) {
     if (identical(encoding, UTF8) && _needsNoEncoding.hasMatch(text)) {
       return text;
     }
 
     // Encode the string into bytes then generate an ASCII only string
     // by percent encoding selected bytes.
-    StringBuffer result = new StringBuffer();
+    StringBuffer result = new StringBuffer('');
     var bytes = encoding.encode(text);
     for (int i = 0; i < bytes.length; i++) {
       int byte = bytes[i];
       if (byte < 128 &&
           ((canonicalTable[byte >> 4] & (1 << (byte & 0x0f))) != 0)) {
         result.writeCharCode(byte);
       } else if (spaceToPlus && byte == _SPACE) {
         result.write('+');
       } else {
         const String hexDigits = '0123456789ABCDEF';
         result.write('%');
         result.write(hexDigits[(byte >> 4) & 0x0f]);
         result.write(hexDigits[byte & 0x0f]);
       }
     }
     return result.toString();
   }
 }
 
 @patch
 class StackTrace {
   @patch
   @NoInline()
   static StackTrace get current {
     return getTraceFromException(JS('', 'new Error()'));
   }
 }