[observe] add isEmpty/isNotEmpty to ObservableList reflection

pkg/observe/lib/src/observable_list.dart

 // Copyright (c) 2013, 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.
 
 library observe.src.observable_list;
 
 import 'dart:async';
 import 'dart:collection' show ListBase, UnmodifiableListView;
 import 'package:observe/observe.dart';
 import 'list_diff.dart' show projectListSplices, calcSplices;
@@ skipping 64 matching lines @@
   bool get _hasListObservers =>
       _listChanges != null && _listChanges.hasListener;
 
   @reflectable int get length => _list.length;
 
   @reflectable set length(int value) {
     int len = _list.length;
     if (len == value) return;
 
     // Produce notifications if needed
-    notifyPropertyChange(#length, len, value);
+    _notifyChangeLength(len, value);
     if (_hasListObservers) {
       if (value < len) {
         _recordChange(new ListChangeRecord(this, value,
             removed: _list.getRange(value, len).toList()));
       } else {
         _recordChange(new ListChangeRecord(this, len, addedCount: value - len));
       }
     }
 
     _list.length = value;
   }
 
   @reflectable E operator [](int index) => _list[index];
 
   @reflectable void operator []=(int index, E value) {
     var oldValue = _list[index];
     if (_hasListObservers) {
       _recordChange(new ListChangeRecord(this, index, addedCount: 1,
           removed: [oldValue]));
     }
     _list[index] = value;
   }
 
+  // Forwarders so we can reflect on the properties.
+  @reflectable bool get isEmpty => super.isEmpty;
+  @reflectable bool get isNotEmpty => super.isNotEmpty;
+
+  // TODO(jmesserly): should we support first/last/single? They're kind of
+  // dangerous to use in a path because they throw exceptions. Also we'd need
+  // to produce property change notifications which seems to conflict with our
+  // existing list notifications.
+
   // The following methods are here so that we can provide nice change events.
 
   void setAll(int index, Iterable<E> iterable) {
     if (iterable is! List && iterable is! Set) {
       iterable = iterable.toList();
     }
     var len = iterable.length;
     if (_hasListObservers && len > 0) {
       _recordChange(new ListChangeRecord(this, index, addedCount: len,
           removed: _list.getRange(index, len).toList()));
     }
     _list.setAll(index, iterable);
   }
 
   void add(E value) {
     int len = _list.length;
-    notifyPropertyChange(#length, len, len + 1);
+    _notifyChangeLength(len, len + 1);
     if (_hasListObservers) {
       _recordChange(new ListChangeRecord(this, len, addedCount: 1));
     }
 
     _list.add(value);
   }
 
   void addAll(Iterable<E> iterable) {
     int len = _list.length;
     _list.addAll(iterable);
 
-    notifyPropertyChange(#length, len, _list.length);
+    _notifyChangeLength(len, _list.length);
 
     int added = _list.length - len;
     if (_hasListObservers && added > 0) {
       _recordChange(new ListChangeRecord(this, len, addedCount: added));
     }
   }
 
   bool remove(Object element) {
     for (int i = 0; i < this.length; i++) {
       if (this[i] == element) {
         removeRange(i, i + 1);
         return true;
       }
     }
     return false;
   }
 
   void removeRange(int start, int end) {
     _rangeCheck(start, end);
     int rangeLength = end - start;
     int len = _list.length;
 
-    notifyPropertyChange(#length, len, len - rangeLength);
+    _notifyChangeLength(len, len - rangeLength);
     if (_hasListObservers && rangeLength > 0) {
       _recordChange(new ListChangeRecord(this, start,
           removed: _list.getRange(start, end).toList()));
     }
 
     _list.removeRange(start, end);
   }
 
   void insertAll(int index, Iterable<E> iterable) {
     if (index < 0 || index > length) {
       throw new RangeError.range(index, 0, length);
     }
     // TODO(floitsch): we can probably detect more cases.
     if (iterable is! List && iterable is! Set) {
       iterable = iterable.toList();
     }
     int insertionLength = iterable.length;
     // There might be errors after the length change, in which case the list
     // will end up being modified but the operation not complete. Unless we
     // always go through a "toList" we can't really avoid that.
     int len = _list.length;
     _list.length += insertionLength;
 
     _list.setRange(index + insertionLength, this.length, this, index);
     _list.setAll(index, iterable);
 
-    notifyPropertyChange(#length, len, _list.length);
+    _notifyChangeLength(len, _list.length);
 
     if (_hasListObservers && insertionLength > 0) {
       _recordChange(new ListChangeRecord(this, index,
           addedCount: insertionLength));
     }
   }
 
   void insert(int index, E element) {
     if (index < 0 || index > length) {
       throw new RangeError.range(index, 0, length);
     }
     if (index == length) {
       add(element);
       return;
     }
     // We are modifying the length just below the is-check. Without the check
     // Array.copy could throw an exception, leaving the list in a bad state
     // (with a length that has been increased, but without a new element).
     if (index is! int) throw new ArgumentError(index);
     _list.length++;
     _list.setRange(index + 1, length, this, index);
 
-    notifyPropertyChange(#length, _list.length - 1, _list.length);
+    _notifyChangeLength(_list.length - 1, _list.length);
     if (_hasListObservers) {
       _recordChange(new ListChangeRecord(this, index, addedCount: 1));
     }
     _list[index] = element;
   }
 
 
   E removeAt(int index) {
     E result = this[index];
     removeRange(index, index + 1);
@@ skipping 12 matching lines @@
   void _recordChange(ListChangeRecord record) {
     if (!_hasListObservers) return;
 
     if (_listRecords == null) {
       _listRecords = [];
       scheduleMicrotask(deliverListChanges);
     }
     _listRecords.add(record);
   }
 
+  void _notifyChangeLength(int oldValue, int newValue) {
+    notifyPropertyChange(#length, oldValue, newValue);
+    notifyPropertyChange(#isEmpty, oldValue == 0, newValue == 0);
+    notifyPropertyChange(#isNotEmpty, oldValue != 0, newValue != 0);
+  }
+
   bool deliverListChanges() {
     if (_listRecords == null) return false;
     var records = projectListSplices(this, _listRecords);
     _listRecords = null;
 
     if (_hasListObservers) {
       _listChanges.add(new UnmodifiableListView<ListChangeRecord>(records));
       return true;
     }
     return false;
@@ skipping 10 matching lines @@
    * final state of a list. The basic approach is to calculate the edit distance
    * matrix and choose the shortest path through it.
    *
    * Complexity is `O(l * p)` where `l` is the length of the current list and
    * `p` is the length of the old list.
    */
   static List<ListChangeRecord> calculateChangeRecords(
       List<Object> oldValue, List<Object> newValue) =>
       calcSplices(newValue, 0, newValue.length, oldValue, 0, oldValue.length);
 }