Big merge from experimental to bleeding edge.

sdk/lib/_internal/compiler/implementation/lib/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.
 
 // Patch for 'print' function.
 patch void print(var object) {
   if (object is String) {
     Primitives.printString(object);
@@ skipping 57 matching lines @@
     }
     return key;
   }
 
   static const String _KEY_PROPERTY_NAME = 'expando\$key';
   static const String _EXPANDO_PROPERTY_NAME = 'expando\$values';
   static int _keyCount = 0;
 }
 
 patch class int {
-  patch static int parse(String source) => Primitives.parseInt(source);
+  patch static int parse(String source,
+                         { int radix,
+                           int onError(String source) }) {
+    return Primitives.parseInt(source, radix, onError);
+  }
 }
 
 patch class double {
-  patch static double parse(String source) => Primitives.parseDouble(source);
+  patch static double parse(String source, [int handleError(String source)]) {
+    return Primitives.parseDouble(source, handleError);
+  }
 }
 
 patch class Error {
   patch static String _objectToString(Object object) {
     return Primitives.objectToString(object);
   }
 }
 
 
 // Patch for Date implementation.
@@ skipping 55 matching lines @@
 
 // Patch for Stopwatch implementation.
 patch class _StopwatchImpl {
   patch static int _frequency() => 1000000;
   patch static int _now() => Primitives.numMicroseconds();
 }
 
 
 // Patch for List implementation.
 patch class List<E> {
-  patch factory List([int length]) => Primitives.newList(length);
+  patch factory List([int length = 0]) {
+    if ((length is !int) || (length < 0)) {
+      String lengthString = Error.safeToString(length);
+      throw new ArgumentError(
+          "Length must be a positive integer: $lengthString.");
+    }
+    return Primitives.newGrowableList(length);
+  }
+
+  patch factory List.fixedLength(int length, {E fill: null}) {
+    if ((length is !int) || (length < 0)) {
+      throw new ArgumentError("Length must be a positive integer: $length.");
+    }
+    List result = Primitives.newFixedList(length);
+    if (length != 0 && fill != null) {
+      for (int i = 0; i < result.length; i++) {
+        result[i] = fill;
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Creates an extendable list of the given [length] where each entry is
+   * filled with [fill].
+   */
+  patch factory List.filled(int length, E fill) {
+    if ((length is !int) || (length < 0)) {
+      throw new ArgumentError("Length must be a positive integer: $length.");
+    }
+    List result = Primitives.newGrowableList(length);
+    if (length != 0 && fill != null) {
+      for (int i = 0; i < result.length; i++) {
+        result[i] = fill;
+      }
+    }
+    return result;
+  }
 }
 
 
 patch class String {
   patch factory String.fromCharCodes(List<int> charCodes) {
     if (!isJsArray(charCodes)) {
       if (charCodes is !List) throw new ArgumentError(charCodes);
       charCodes = new List.from(charCodes);
     }
     return Primitives.stringFromCharCodes(charCodes);
   }
 }
 
 // Patch for String implementation.
 patch class Strings {
-  patch static String join(List<String> strings, String separator) {
+  patch static String join(Iterable<String> strings, String separator) {
     checkNull(strings);
     if (separator is !String) throw new ArgumentError(separator);
     return stringJoinUnchecked(_toJsStringArray(strings), separator);
   }
 
-  patch static String concatAll(List<String> strings) {
+  patch static String concatAll(Iterable<String> strings) {
     return stringJoinUnchecked(_toJsStringArray(strings), "");
   }
 
-  static List _toJsStringArray(List<String> strings) {
+  static List _toJsStringArray(Iterable<String> strings) {
     checkNull(strings);
     var array;
+    if (!isJsArray(strings)) {
+      strings = new List.from(strings);
+    }
     final length = strings.length;
-    if (isJsArray(strings)) {
-      array = strings;
-      for (int i = 0; i < length; i++) {
-        final string = strings[i];
-        if (string is !String) throw new ArgumentError(string);
-      }
-    } else {
-      array = new List(length);
-      for (int i = 0; i < length; i++) {
-        final string = strings[i];
-        if (string is !String) throw new ArgumentError(string);
-        array[i] = string;
-      }
+    for (int i = 0; i < length; i++) {
+      final string = strings[i];
+      if (string is !String) throw new ArgumentError(string);
     }
-    return array;
+    return strings;
   }
 }
 
 patch class RegExp {
   patch factory RegExp(String pattern,
                        {bool multiLine: false,
-                        bool ignoreCase: false})
+                        bool caseSensitive: true})
     => new JSSyntaxRegExp(pattern,
                           multiLine: multiLine,
-                          ignoreCase: ignoreCase);
+                          caseSensitive: caseSensitive);
 }
 
 // Patch for 'identical' function.
 patch bool identical(Object a, Object b) {
   throw new Error('Should not reach the body of identical');
 }