Adding isNotEmpty property to collection and string.

runtime/lib/collection_patch.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.
 
 patch class HashMap<K, V> {
   final _HashMapTable<K, V> _hashTable = new _HashMapTable<K, V>();
 
   /* patch */ HashMap() {
     _hashTable._container = this;
   }
@@ skipping 91 matching lines @@
     }
   }
 
   /* patch */ Iterable<K> get keys => new _HashTableKeyIterable<K>(_hashTable);
   /* patch */ Iterable<V> get values =>
       new _HashTableValueIterable<V>(_hashTable, _HashMapTable._VALUE_INDEX);
 
   /* patch */ int get length => _hashTable._elementCount;
 
   /* patch */ bool get isEmpty => _hashTable._elementCount == 0;
+
+  /* patch */ bool get isNotEmpty => !isEmpty;
 }
 
 patch class HashSet<E> {
   static const int _INITIAL_CAPACITY = 8;
   final _HashTable<E> _table;
 
   /* patch */ HashSet() : _table = new _HashTable(_INITIAL_CAPACITY) {
     _table._container = this;
   }
 
   factory HashSet.from(Iterable<E> iterable) {
     return new HashSet<E>()..addAll(iterable);
   }
 
   // Iterable.
   /* patch */ Iterator<E> get iterator => new _HashTableKeyIterator<E>(_table);
 
   /* patch */ int get length => _table._elementCount;
 
   /* patch */ bool get isEmpty => _table._elementCount == 0;
 
+  /* patch */ bool get isNotEmpty => !isEmpty;
+
   /* patch */ bool contains(Object object) => _table._get(object) >= 0;
 
   // Collection.
   /* patch */ void add(E element) {
     _table._put(element);
     _table._checkCapacity();
   }
 
   /* patch */ void addAll(Iterable<E> objects) {
     for (E object in objects) {
@@ skipping 150 matching lines @@
   /* patch */ Iterable<K> get keys =>
       new _LinkedHashTableKeyIterable<K>(_hashTable);
 
   /* patch */ Iterable<V> get values =>
       new _LinkedHashTableValueIterable<V>(_hashTable,
                                            _LinkedHashMapTable._VALUE_INDEX);
 
   /* patch */ int get length => _hashTable._elementCount;
 
   /* patch */ bool get isEmpty => _hashTable._elementCount == 0;
+
+  /* patch */ bool get isNotEmpty => !isEmpty;
 }
 
 patch class LinkedHashSet<E> extends _HashSetBase<E> {
   static const int _INITIAL_CAPACITY = 8;
   _LinkedHashTable<E> _table;
 
   /* patch */ LinkedHashSet() {
     _table = new _LinkedHashTable(_INITIAL_CAPACITY);
     _table._container = this;
   }
 
   // Iterable.
   /* patch */ Iterator<E> get iterator {
     return new _LinkedHashTableKeyIterator<E>(_table);
   }
 
   /* patch */ int get length => _table._elementCount;
 
   /* patch */ bool get isEmpty => _table._elementCount == 0;
 
+  /* patch */ bool get isNotEmpty => !isEmpty;
+
   /* patch */ bool contains(Object object) => _table._get(object) >= 0;
 
   /* patch */ void forEach(void action(E element)) {
     int offset = _table._next(_LinkedHashTable._HEAD_OFFSET);
     int modificationCount = _table._modificationCount;
     while (offset != _LinkedHashTable._HEAD_OFFSET) {
       E key = _table._key(offset);
       action(key);
       _table._checkModification(modificationCount);
       offset = _table._next(offset);
@@ skipping 660 matching lines @@
 
   _LinkedHashMapTable() : super(_INITIAL_CAPACITY);
 
   V _value(int offset) => _table[offset + _VALUE_INDEX];
   void _setValue(int offset, V value) { _table[offset + _VALUE_INDEX] = value; }
 
   _copyEntry(List oldTable, int fromOffset, int toOffset) {
     _table[toOffset + _VALUE_INDEX] = oldTable[fromOffset + _VALUE_INDEX];
   }
 }