Rename Cell properties to avoid name clashes in type inference.

sdk/lib/_internal/compiler/js_lib/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 _js_helper;
 
 class JsLinkedHashMap<K, V> implements LinkedHashMap<K, V>, InternalMap {
@@ skipping 67 matching lines @@
     other.forEach((K key, V value) {
       this[key] = value;
     });
   }
 
   V operator[](Object key) {
     if (_isStringKey(key)) {
       var strings = _strings;
       if (strings == null) return null;
       LinkedHashMapCell cell = _getTableEntry(strings, key);
-      return (cell == null) ? null : cell.value;
+      return (cell == null) ? null : cell.hashMapCellValue;
     } else if (_isNumericKey(key)) {
       var nums = _nums;
       if (nums == null) return null;
       LinkedHashMapCell cell = _getTableEntry(nums, key);
-      return (cell == null) ? null : cell.value;
+      return (cell == null) ? null : cell.hashMapCellValue;
     } else {
       return internalGet(key);
     }
   }
 
   V internalGet(Object key) {
     var rest = _rest;
     if (rest == null) return null;
     var bucket = _getBucket(rest, key);
     int index = internalFindBucketIndex(bucket, key);
     if (index < 0) return null;
     LinkedHashMapCell cell = JS('var', '#[#]', bucket, index);
-    return cell.value;
+    return cell.hashMapCellValue;
   }
 
   void operator[]=(K key, V value) {
     if (_isStringKey(key)) {
       var strings = _strings;
       if (strings == null) _strings = strings = _newHashTable();
       _addHashTableEntry(strings, key, value);
     } else if (_isNumericKey(key)) {
       var nums = _nums;
       if (nums == null) _nums = nums = _newHashTable();
       _addHashTableEntry(nums, key, value);
     } else {
       internalSet(key, value);
     }
   }
 
   void internalSet(K key, V value) {
     var rest = _rest;
     if (rest == null) _rest = rest = _newHashTable();
     var hash = internalComputeHashCode(key);
     var bucket = JS('var', '#[#]', rest, hash);
     if (bucket == null) {
       LinkedHashMapCell cell = _newLinkedCell(key, value);
       _setTableEntry(rest, hash, JS('var', '[#]', cell));
     } else {
       int index = internalFindBucketIndex(bucket, key);
       if (index >= 0) {
         LinkedHashMapCell cell = JS('var', '#[#]', bucket, index);
-        cell.value = value;
+        cell.hashMapCellValue = value;
       } else {
         LinkedHashMapCell cell = _newLinkedCell(key, value);
         JS('void', '#.push(#)', bucket, cell);
       }
     }
   }
 
   V putIfAbsent(K key, V ifAbsent()) {
     if (containsKey(key)) return this[key];
     V value = ifAbsent();
@@ skipping 16 matching lines @@
     if (rest == null) return null;
     var bucket = _getBucket(rest, key);
     int index = internalFindBucketIndex(bucket, key);
     if (index < 0) return null;
     // Use splice to remove the [cell] element at the index and
     // unlink the cell before returning its value.
     LinkedHashMapCell cell = JS('var', '#.splice(#, 1)[0]', bucket, index);
     _unlinkCell(cell);
     // TODO(kasperl): Consider getting rid of the bucket list when
     // the length reaches zero.
-    return cell.value;
+    return cell.hashMapCellValue;
   }
 
   void clear() {
     if (_length > 0) {
       _strings = _nums = _rest = _first = _last = null;
       _length = 0;
       _modified();
     }
   }
 
   void forEach(void action(K key, V value)) {
     LinkedHashMapCell cell = _first;
     int modifications = _modifications;
     while (cell != null) {
-      action(cell.key, cell.value);
+      action(cell.hashMapCellKey, cell.hashMapCellValue);
       if (modifications != _modifications) {
         throw new ConcurrentModificationError(this);
       }
       cell = cell._next;
     }
   }
 
   void _addHashTableEntry(var table, K key, V value) {
     LinkedHashMapCell cell = _getTableEntry(table, key);
     if (cell == null) {
       _setTableEntry(table, key, _newLinkedCell(key, value));
     } else {
-      cell.value = value;
+      cell.hashMapCellValue = value;
     }
   }
 
   V _removeHashTableEntry(var table, Object key) {
     if (table == null) return null;
     LinkedHashMapCell cell = _getTableEntry(table, key);
     if (cell == null) return null;
     _unlinkCell(cell);
     _deleteTableEntry(table, key);
-    return cell.value;
+    return cell.hashMapCellValue;
   }
 
   void _modified() {
     // Value cycles after 2^30 modifications. If you keep hold of an
     // iterator for that long, you might miss a modification
     // detection, and iteration can go sour. Don't do that.
     _modifications = (_modifications + 1) & 0x3ffffff;
   }
 
   // Create a new cell and link it in as the last one in the list.
@@ skipping 65 matching lines @@
   List _getBucket(var table, var key) {
     var hash = internalComputeHashCode(key);
     return JS('var', '#[#]', table, hash);
   }
 
   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 cell = JS('var', '#[#]', bucket, i);
-      if (cell.key == key) return i;
+      if (cell.hashMapCellKey == key) return i;
     }
     return -1;
   }
 
   static _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)');
     // Attempt to force the hash table into 'dictionary' mode by
     // adding a property to it and deleting it again.
     var temporaryKey = '<non-identifier-key>';
     _setTableEntry(table, temporaryKey, table);
     _deleteTableEntry(table, temporaryKey);
     return table;
   }
 
   String toString() => Maps.mapToString(this);
 }
 
 class LinkedHashMapCell {
-  final key;
-  var value;
+  final hashMapCellKey;
+  var hashMapCellValue;
 
   LinkedHashMapCell _next;
   LinkedHashMapCell _previous;
 
-  LinkedHashMapCell(this.key, this.value);
+  LinkedHashMapCell(this.hashMapCellKey, this.hashMapCellValue);
 }
 
 class LinkedHashMapKeyIterable<E> extends IterableBase<E>
                                   implements EfficientLength {
   final _map;
   LinkedHashMapKeyIterable(this._map);
 
   int get length => _map._length;
   bool get isEmpty => _map._length == 0;
 
   Iterator<E> get iterator {
     return new LinkedHashMapKeyIterator<E>(_map, _map._modifications);
   }
 
   bool contains(Object element) {
     return _map.containsKey(element);
   }
 
   void forEach(void f(E element)) {
     LinkedHashMapCell cell = _map._first;
     int modifications = _map._modifications;
     while (cell != null) {
-      f(cell.key);
+      f(cell.hashMapCellKey);
       if (modifications != _map._modifications) {
         throw new ConcurrentModificationError(_map);
       }
       cell = cell._next;
     }
   }
 }
 
 class LinkedHashMapKeyIterator<E> implements Iterator<E> {
   final _map;
   final int _modifications;
   LinkedHashMapCell _cell;
   E _current;
 
   LinkedHashMapKeyIterator(this._map, this._modifications) {
     _cell = _map._first;
   }
 
   E get current => _current;
 
   bool moveNext() {
     if (_modifications != _map._modifications) {
       throw new ConcurrentModificationError(_map);
     } else if (_cell == null) {
       _current = null;
       return false;
     } else {
-      _current = _cell.key;
+      _current = _cell.hashMapCellKey;
       _cell = _cell._next;
       return true;
     }
   }
 }