Adapt private variables with trailing underscores.

runtime/lib/immutable_map.dart

 // Copyright (c) 2012, 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.
 // Immutable map class for compiler generated map literals.
 
 class ImmutableMap<K, V> implements Map<K, V> {
-  final _ImmutableArray kvPairs_;
+  final _ImmutableArray _kvPairs;
 
   const ImmutableMap._create(_ImmutableArray keyValuePairs)
-      : kvPairs_ = keyValuePairs;
+      : _kvPairs = keyValuePairs;
 
 
   V operator [](Object key) {
     // TODO(hausner): Since the keys are sorted, we could do a binary
     // search. But is it worth it?

[Lasse Reichstein Nielsen, 2013/09/24 07:43:21]

Add a comment here: Yes, it may be worth it if maps a large.

I fully expect users to create const maps that are large and assume constant
time lookup - that how you would build a static table in Dart.
For small maps, by all means make them linear. The limit is likely around 10
elements.

[floitsch, 2013/09/24 11:19:13]

There is already a TODO. No need to add our expectations.

-    for (int i = 0; i < kvPairs_.length - 1; i += 2) {
-      if (key == kvPairs_[i]) {
-        return kvPairs_[i+1];
+    for (int i = 0; i < _kvPairs.length - 1; i += 2) {
+      if (key == _kvPairs[i]) {
+        return _kvPairs[i+1];
       }
     }
     return null;
   }
 
   bool get isEmpty {
-    return kvPairs_.length == 0;
+    return _kvPairs.length == 0;
   }
 
   bool get isNotEmpty => !isEmpty;
 
   int get length {
-    return kvPairs_.length ~/ 2;
+    return _kvPairs.length ~/ 2;
   }
 
   void forEach(void f(K key, V value)) {
-    for (int i = 0; i < kvPairs_.length; i += 2) {
-      f(kvPairs_[i], kvPairs_[i+1]);
+    for (int i = 0; i < _kvPairs.length; i += 2) {
+      f(_kvPairs[i], _kvPairs[i+1]);
     }
   }
 
   Iterable<K> get keys {
     return new _ImmutableMapKeyIterable<K>(this);
   }
 
   Iterable<V> get values {
     return new _ImmutableMapValueIterable<V>(this);
   }
 
   bool containsKey(Object key) {
-    for (int i = 0; i < kvPairs_.length; i += 2) {
-      if (key == kvPairs_[i]) {
+    for (int i = 0; i < _kvPairs.length; i += 2) {
+      if (key == _kvPairs[i]) {
         return true;
       }
     }
     return false;
   }
 
   bool containsValue(Object value) {
-    for (int i = 1; i < kvPairs_.length; i += 2) {
-      if (value == kvPairs_[i]) {
+    for (int i = 1; i < _kvPairs.length; i += 2) {
+      if (value == _kvPairs[i]) {
         return true;
       }
     }
     return false;
   }
 
   void operator []=(K key, V value) {
     throw new UnsupportedError("Cannot set value in unmodifiable Map");
   }
 
@@ skipping 36 matching lines @@
   ImmutableMap _map;
   int _index = -1;
   E _current;
 
   _ImmutableMapKeyIterator(this._map);
 
   bool moveNext() {
     int newIndex = _index + 1;
     if (newIndex < _map.length) {
       _index = newIndex;
-      _current = _map.kvPairs_[newIndex * 2];
+      _current = _map._kvPairs[newIndex * 2];
       return true;
     }
     _current = null;
     _index = _map.length;
     return false;
   }
 
   E get current => _current;
 }
 
 class _ImmutableMapValueIterator<E> implements Iterator<E> {
   ImmutableMap _map;
   int _index = -1;
   E _current;
 
   _ImmutableMapValueIterator(this._map);
 
   bool moveNext() {
     int newIndex = _index + 1;
     if (newIndex < _map.length) {
       _index = newIndex;
-      _current = _map.kvPairs_[newIndex * 2 + 1];
+      _current = _map._kvPairs[newIndex * 2 + 1];
       return true;
     }
     _current = null;
     _index = _map.length;
     return false;
   }
 
   E get current => _current;
 }