New analyzer_experimental snapshot.

pkg/analyzer_experimental/lib/src/generated/java_core.dart

 library java.core;
 
 import "dart:math" as math;
-import "dart:collection" show ListBase;
 
 class JavaSystem {
   static int currentTimeMillis() {
     return (new DateTime.now()).millisecondsSinceEpoch;
   }
 
   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];
     }
@@ skipping 142 matching lines @@
   CharBuffer(String content) : super(content);
   static CharBuffer wrap(String content) => new CharBuffer(content);
 }
 
 class JavaString {
   static String format(String fmt, List args) {
     var index = 0;
     return fmt.replaceAllMapped(new RegExp(r'%(.)'), (match) {
       switch (match.group(1)) {
         case '%': return '%';
+        case 'd':
         case 's':
           if (index >= args.length) {
             throw new MissingFormatArgumentException(match.group(0));
           }
           return args[index++].toString();
         default: return match.group(1);
       }
     });
   }
   static int indexOf(String target, String str, int fromIndex) {
@@ skipping 145 matching lines @@
 }
 
 class MissingFormatArgumentException implements Exception {
   final String s;
 
   String toString() => "MissingFormatArgumentException: $s";
 
   MissingFormatArgumentException(this.s);
 }
 
-class ListWrapper<E> extends ListBase<E> implements List<E> {
-  List<E> elements = new List<E>();
-
-  Iterator<E> get iterator {
-    return elements.iterator;
-  }
-
-  E operator [](int index) {
-    return elements[index];
-  }
-
-  void operator []=(int index, E value) {
-    elements[index] = value;
-  }
-
-  void set length(int newLength) {
-    elements.length = newLength;
-  }
-
-  int get length => elements.length;
-
-  void add(E value) {
-    elements.add(value);
-  }
-
-  void addLast(E value) {
-    elements.add(value);
-  }
-
-  void addAll(Iterable<E> iterable) {
-    elements.addAll(iterable);
-  }
-
-  void setAll(int index, Iterable<E> iterable) {
-    elements.setAll(index, iterable);
-  }
-
-  void sort([int compare(E a, E b)]) {
-    elements.sort(compare);
-  }
-
-  void shuffle([math.Random random]) {
-    elements.shuffle(random);
-  }
-
-  int indexOf(E element, [int start = 0]) {
-    return elements.indexOf(element, start);
-  }
-
-  void insert(int index, E element) {
-    elements.insert(index, element);
-  }
-
-  void insertAll(int index, Iterable<E> iterable) {
-    elements.insertAll(index, iterable);
-  }
-
-  int lastIndexOf(E element, [int start]) {
-    return elements.lastIndexOf(element, start);
-  }
-
-  void clear() {
-    elements.clear();
-  }
-
-  bool remove(Object element) {
-    return elements.remove(element);
-  }
-
-  E removeAt(int index) {
-    return elements.removeAt(index);
-  }
-
-  E removeLast() {
-    return elements.removeLast();
-  }
-
-  Iterable<E> get reversed => elements.reversed;
-
-  List<E> sublist(int start, [int end]) => elements.sublist(start, end);
-
-  List<E> getRange(int start, int length) => sublist(start, start + length);
-
-  void setRange(int start, int end, Iterable<E> iterable, [int skipCount = 0]) {
-    elements.setRange(start, end, iterable, skipCount);
-  }
-
-  void removeRange(int start, int end) {
-    elements.removeRange(start, end);
-  }
-
-  void replaceRange(int start, int end, Iterable<E> iterable) {
-    elements.replaceRange(start, end, iterable);
-  }
-
-  void fillRange(int start, int end, [E fillValue]) {
-    elements.fillRange(start, end, fillValue);
-  }
-
-  Map<int, E> asMap() {
-    return elements.asMap();
-  }
-}
-
 class JavaIterator<E> {
   Iterable<E> _iterable;
   List<E> _elements = new List<E>();
   int _coPos = 0;
   int _elPos = 0;
   E _current = null;
   JavaIterator(this._iterable) {
     Iterator iterator = _iterable.iterator;
     while (iterator.moveNext()) {
       _elements.add(iterator.current);
@@ skipping 39 matching lines @@
 }
 
 Iterable<MapEntry> getMapEntrySet(Map m) {
   List<MapEntry> result = [];
   m.forEach((k, v) {
     result.add(new MapEntry(m, k, v));
   });
   return result;
 }
 
+javaListSet(List list, int index, newValue) {
+  var oldValue = list[index];
+  list[index] = newValue;
+  return oldValue;
+}
+
 bool javaSetAdd(Set s, o) {
   if (!s.contains(o)) {
     s.add(o);
     return true;
   }
   return false;
 }
 
 bool javaCollectionContainsAll(Iterable list, Iterable c) {
   return c.fold(true, (bool prev, e) => prev && list.contains(e));
@@ skipping 70 matching lines @@
     if (!_matches.moveNext()) {
       return false;
     }
     _match = _matches.current;
     return true;
   }
   String group(int i) => _match[i];
   int start() => _match.start;
   int end() => _match.end;
 }