Optimize DDC private library files.

pkg/dev_compiler/tool/input_sdk/private/linked_hash_map.dart

 // Copyright (c) 2014, 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.
 
 // Efficient JavaScript based implementation of a linked hash map used as a
 // backing map for constant maps and the [LinkedHashMap] patch
 
 part of dart._js_helper;
 
 // DDC-specific, just use Object-backed maps
 //const _USE_ES6_MAPS = const bool.fromEnvironment("dart2js.use.es6.maps");
 
 class JsLinkedHashMap<K, V> implements LinkedHashMap<K, V>, InternalMap<K, V> {
+  @notNull
   int _length = 0;
 
   // The hash map contents are divided into three parts: one part for
   // string keys, one for numeric keys, and one for the rest. String
   // and numeric keys map directly to their linked cells, but the rest
   // of the entries are stored in bucket lists of the form:
   //
   //    [cell-0, cell-1, ...]
   //
   // where all keys in the same bucket share the same hash code.
   var _strings;
   var _nums;
   var _rest;
 
   // The keys and values are stored in cells that are linked together
   // to form a double linked list.
-  LinkedHashMapCell/*<K, V>*/ _first;
-  LinkedHashMapCell/*<K, V>*/ _last;
+  LinkedHashMapCell<K, V> _first;
+  LinkedHashMapCell<K, V> _last;
 
   // We track the number of modifications done to the key set of the
   // hash map to be able to throw when the map is modified while being
   // iterated over.
   int _modifications = 0;
 
 //  static bool get _supportsEs6Maps {
 //    return JS('returns:bool;depends:none;effects:none;throws:never;gvn:true',
 //              'typeof Map != "undefined"');
 //  }
 
   JsLinkedHashMap();
 
   /// If ES6 Maps are available returns a linked hash-map backed by an ES6 Map.
 //  @ForceInline()
   factory JsLinkedHashMap.es6() {
 //    return (_USE_ES6_MAPS && JsLinkedHashMap._supportsEs6Maps)
 //        ? new Es6LinkedHashMap<K, V>()
 //        : new JsLinkedHashMap<K, V>();
     return new JsLinkedHashMap<K, V>();
   }
 
+  @notNull
   int get length => _length;
+  @notNull
   bool get isEmpty => _length == 0;
+  @notNull
   bool get isNotEmpty => !isEmpty;
 
   Iterable<K> get keys {
     return new LinkedHashMapKeyIterable<K>(this);
   }
 
   Iterable<V> get values {
     return new MappedIterable<K, V>(keys, (each) => this[each]);
   }
 
+  @notNull
   bool containsKey(Object key) {
     if (_isStringKey(key)) {
       var strings = _strings;
       if (strings == null) return false;
       return _containsTableEntry(strings, key);
     } else if (_isNumericKey(key)) {
       var nums = _nums;
       if (nums == null) return false;
       return _containsTableEntry(nums, key);
     } else {
       return internalContainsKey(key);
     }
   }
 
+  @notNull
   bool internalContainsKey(Object key) {
     var rest = _rest;
     if (rest == null) return false;
     var bucket = _getBucket(rest, key);
     return internalFindBucketIndex(bucket, key) >= 0;
   }
 
   bool containsValue(Object value) {
     return keys.any((each) => this[each] == value);
   }
@@ skipping 172 matching lines @@
     if (next == null) {
       assert(cell == _last);
       _last = previous;
     } else {
       next._previous = previous;
     }
     _length--;
     _modified();
   }
 
+  @notNull
   static bool _isStringKey(var key) {
     return key is String;
   }
 
+  @notNull
   static bool _isNumericKey(var key) {
     // Only treat unsigned 30-bit integers as numeric keys. This way,
     // we avoid converting them to strings when we use them as keys in
     // the JavaScript hash table object.
     return key is num && JS('bool', '(# & 0x3ffffff) === #', key, key);
   }
 
   int internalComputeHashCode(var key) {
     // We force the hash codes to be unsigned 30-bit integers to avoid
     // issues with problematic keys like '__proto__'. Another option
     // would be to throw an exception if the hash code isn't a number.
     return JS('int', '# & 0x3ffffff', key.hashCode);
   }
 
   List<dynamic/*=LinkedHashMapCell<K, V>*/ > _getBucket(var table, var key) {
     var hash = internalComputeHashCode(key);
     return _getTableBucket(table, hash);
   }
 
+  @notNull
   int internalFindBucketIndex(var bucket, var key) {
     if (bucket == null) return -1;
     int length = JS('int', '#.length', bucket);
     for (int i = 0; i < length; i++) {
       LinkedHashMapCell/*<K, V>*/ cell = JS('var', '#[#]', bucket, i);
       if (cell.hashMapCellKey == key) return i;
     }
     return -1;
   }
 
   String toString() => Maps.mapToString(this);
 
   /*=LinkedHashMapCell<K, V>*/ _getTableCell(var table, var key) {
     return JS('var', '#[#]', table, key);
   }
 
   /*=List<LinkedHashMapCell<K, V>>*/ _getTableBucket(var table, var key) {
     return JS('var', '#[#]', table, key);
   }
 
   void _setTableEntry(var table, var key, var value) {
     assert(value != null);
     JS('void', '#[#] = #', table, key, value);
   }
 
   void _deleteTableEntry(var table, var key) {
     JS('void', 'delete #[#]', table, key);
   }
 
+  @notNull
   bool _containsTableEntry(var table, var key) {
     LinkedHashMapCell/*<K, V>*/ cell = _getTableCell(table, key);
     return cell != null;
   }
 
   _newHashTable() {
     // Create a new JavaScript object to be used as a hash table. Use
     // Object.create to avoid the properties on Object.prototype
     // showing up as entries.
     var table = JS('var', 'Object.create(null)');
@@ skipping 94 matching lines @@
     } else if (_cell == null) {
       _current = null;
       return false;
     } else {
       _current = _cell.hashMapCellKey;
       _cell = _cell._next;
       return true;
     }
   }
 }