Update analyzer-experimental.

pkg/analyzer-experimental/lib/src/generated/java_core.dart

 library java.core;
 
 import "dart:math" as math;
-import "dart:io";
 import "dart:uri";
 
-class System {
-  static final String pathSeparator = Platform.pathSeparator;
-  static final int pathSeparatorChar = Platform.pathSeparator.codeUnitAt(0);
-
+class JavaSystem {
   static int currentTimeMillis() {
     return (new DateTime.now()).millisecondsSinceEpoch;
   }
-  static String getProperty(String name) {
-    if (name == 'os.name') {
-      return Platform.operatingSystem;
+
+  static void arraycopy(List src, int srcPos, List dest, int destPos, int length) {
+    for (int i = 0; i < length; i++) {
+      dest[destPos + i] = src[srcPos + i];
     }
-    if (name == 'line.separator') {
-      if (Platform.operatingSystem == 'windows') {
-        return '\r\n';
-      }
-      return '\n';
-    }
-    return null;
   }
-  static String getenv(String name) => Platform.environment[name];
-
 }
 
 /**
  * Limited implementation of "o is instanceOfType", see
  * http://code.google.com/p/dart/issues/detail?id=8184
  */
 bool isInstanceOf(o, Type t) {
   if (o == null) {
     return false;
   }
   if (o.runtimeType == t) {
     return true;
   }
   String oTypeName = o.runtimeType.toString();
   String tTypeName = t.toString();
   if (oTypeName == tTypeName) {
     return true;
   }
   if (oTypeName == "${tTypeName}Impl") {
     return true;
   }
-  if (oTypeName.startsWith("_HashMap") && tTypeName == "Map") {
+  if (oTypeName.startsWith("HashMap") && tTypeName == "Map") {
     return true;
   }
   if (oTypeName.startsWith("List") && tTypeName == "List") {
     return true;
   }
   return false;
 }
 
 class JavaArrays {
   static bool equals(List a, List b) {
@@ skipping 23 matching lines @@
 
 class Character {
   static const int MAX_VALUE = 0xffff;
   static const int MAX_CODE_POINT = 0x10ffff;
   static bool isLetter(int c) {
     return c >= 0x41 && c <= 0x5A || c >= 0x61 && c <= 0x7A;
   }
   static bool isLetterOrDigit(int c) {
     return isLetter(c) || c >= 0x30 && c <= 0x39;
   }
+  static bool isWhitespace(int c) {
+    return c == 0x09 || c == 0x20 || c == 0x0A || c == 0x0D;
+  }
   static int digit(int codePoint, int radix) {
     if (radix != 16) {
       throw new ArgumentError("only radix == 16 is supported");
     }
     if (0x30 <= codePoint && codePoint <= 0x39) {
       return codePoint - 0x30;
     }
     if (0x41 <= codePoint && codePoint <= 0x46) {
       return 0xA + (codePoint - 0x41);
     }
+    if (0x61 <= codePoint && codePoint <= 0x66) {
+      return 0xA + (codePoint - 0x61);
+    }
+    return -1;
   }
   static String toChars(int codePoint) {
     throw new UnsupportedOperationException();
   }
 }
 
 class CharBuffer {
   final String _content;
   CharBuffer(this._content);
   static CharBuffer wrap(String content) => new CharBuffer(content);
@@ skipping 12 matching lines @@
  * Very limited printf implementation, supports only %s and %d.
  */
 String _printf(String fmt, List args) {
   StringBuffer sb = new StringBuffer();
   bool markFound = false;
   int argIndex = 0;
   for (int i = 0; i < fmt.length; i++) {
     int c = fmt.codeUnitAt(i);
     if (c == 0x25) {
       if (markFound) {
-        sb.addCharCode(c);
+        sb.writeCharCode(c);
         markFound = false;
       } else {
         markFound = true;
       }
       continue;
     }
     if (markFound) {
       markFound = false;
       // %d
       if (c == 0x64) {
-        sb.add(args[argIndex++]);
+        sb.writeCharCode(args[argIndex++]);
         continue;
       }
       // %s
       if (c == 0x73) {
-        sb.add(args[argIndex++]);
+        sb.writeCharCode(args[argIndex++]);
         continue;
       }
       // unknown
       throw new IllegalArgumentException('[$fmt][$i] = 0x${c.toRadixString(16)}');
     } else {
-      sb.addCharCode(c);
+      sb.writeCharCode(c);
     }
   }
   return sb.toString();
 }
 
 abstract class PrintWriter {
   void print(x);
 
   void println() {
     this.print('\n');
   }
 
   void printlnObject(String s) {
     this.print(s);
     this.println();
   }
 
   void printf(String fmt, List args) {
     this.print(_printf(fmt, args));
   }
 }
 
 class PrintStringWriter extends PrintWriter {
   final StringBuffer _sb = new StringBuffer();
 
   void print(x) {
-    _sb.add(x);
+    _sb.write(x);
   }
 
   String toString() => _sb.toString();
 }
 
 class StringUtils {
   static List<String> split(String s, String pattern) => s.split(pattern);
   static String replace(String s, String from, String to) => s.replaceAll(from, to);
   static String repeat(String s, int n) {
     StringBuffer sb = new StringBuffer();
     for (int i = 0; i < n; i++) {
-      sb.add(s);
+      sb.write(s);
     }
     return sb.toString();
   }
 }
 
 class Math {
   static num max(num a, num b) => math.max(a, b);
   static num min(num a, num b) => math.min(a, b);
 }
 
@@ skipping 54 matching lines @@
 
   void set length(int newLength) {
     elements.length = newLength;
   }
 
   void add(E value) {
     elements.add(value);
   }
 
   void addLast(E value) {
-    elements.addLast(value);
+    elements.add(value);
   }
 
   void addAll(Iterable<E> iterable) {
     elements.addAll(iterable);
   }
 
   void sort([int compare(E a, E b)]) {
     elements.sort(compare);
   }
 
@@ skipping 31 matching lines @@
     elements.setRange(start, length, from, startFrom);
   }
 
   void removeRange(int start, int length) {
     elements.removeRange(start, length);
   }
 
   void insertRange(int start, int length, [E fill]) {
     elements.insertRange(start, length, fill);
   }
+
+  Map<int, E> asMap() {
+    return elements.asMap();
+  }
 }
 
 class JavaIterator<E> {
   Collection<E> _collection;
   List<E> _elements = new List<E>();
   int _coPos = 0;
   int _elPos = 0;
   E _current = null;
   JavaIterator(this._collection) {
     Iterator iterator = _collection.iterator;
@@ skipping 48 matching lines @@
   }
   return false;
 }
 
 void javaMapPutAll(Map target, Map source) {
   source.forEach((k, v) {
     target[k] = v;
   });
 }
 
-File newRelativeFile(File base, String child) {
-  var childPath = new Path(base.fullPathSync()).join(new Path(child));
-  return new File.fromPath(childPath);
+bool javaStringEqualsIgnoreCase(String a, String b) {
+  return a.toLowerCase() == b.toLowerCase();
 }
-
-File newFileFromUri(Uri uri) {
-  return new File(uri.path);
-}
-
-File getAbsoluteFile(File file) {
-  var path = file.fullPathSync();
-  return new File(path);
-}
-
-Uri newUriFromFile(File file) {
-  return new Uri.fromComponents(path: file.fullPathSync());
-}