anchor.diff:  abstract class Completer<T> {
     factory Completer() => null;
     factory Completer.sync() => null;
  +
     Future<T> get future;
  +  bool get isCompleted;
  +
     void complete([value]);
     void completeError(Object error, [StackTrace stackTrace]);
  -  bool get isCompleted;
   }
   
   abstract class Timer {
  
positive.code:   void add(E value) {}
    void addAll(Iterable<E> iterable) {}
    void clear() {}
  
    noSuchMethod(Invocation invocation) => null;
  }
  
  class Map<K, V> {
    factory Map() => null;
    factory Map.fromIterable(Iterable iterable,
        {K key(element), V value(element)}) => null;
    Iterable<K> get keys => null;
    int get length => 0;
    Iterable<V> get values => null;
    V operator [](K key) => null;
    void operator []=(K key, V value) {}
    Map<RK, RV> cast<RK, RV>() => null;
    bool containsKey(Object key) => false;
  }
  
negative.code:   double roundToDouble();
    int truncate();
    double truncateToDouble();
  
    external static double parse(String source, [double onError(String source)]);
  }
  
  class Duration implements Comparable<Duration> {}
  
  class Error {
    Error();
    static String safeToString(Object object) => '';
    external StackTrace get stackTrace;
  }
  
  class Exception {
    factory Exception([var message]) => null;
  