sdk files reorganization to make dart2js a proper package

sdk/lib/_internal/compiler/js_lib/constant_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.
-
-part of _js_helper;
-
-class ConstantMapView<K, V> extends UnmodifiableMapView
-                      implements ConstantMap {
-  ConstantMapView(Map base) : super(base);
-}
-
-abstract class ConstantMap<K, V> implements Map<K, V> {
-  // Used to create unmodifiable maps from other maps.
-  factory ConstantMap.from(Map other) {
-    List keys = other.keys.toList();
-    bool allStrings = true;
-    for (var k in keys) {
-      if (k is! String) {
-        allStrings = false;
-        break;
-      }
-    }
-    if (allStrings) {
-      bool containsProto = false;
-      var protoValue = null;
-      var object = JS('=Object', '{}');
-      int length = 0;
-      for (var k in keys) {
-        var v = other[k];
-        if (k != "__proto__") {
-          if (!jsHasOwnProperty(object, k)) length++;
-          JS("void", "#[#] = #", object, k, v);
-        } else {
-          containsProto = true;
-          protoValue = v;
-        }
-      }
-      if (containsProto) {
-        length++;
-        return new ConstantProtoMap<K, V>._(length, object, keys, protoValue);
-      }
-      return new ConstantStringMap<K, V>._(length, object, keys);
-    }
-    // TODO(lrn): Make a proper unmodifiable map implementation.
-    return new ConstantMapView<K, V>(new Map.from(other));
-  }
-
-  const ConstantMap._();
-
-  bool get isEmpty => length == 0;
-
-  bool get isNotEmpty => !isEmpty;
-
-  String toString() => Maps.mapToString(this);
-
-  static _throwUnmodifiable() {
-    throw new UnsupportedError("Cannot modify unmodifiable Map");
-  }
-  void operator []=(K key, V val) => _throwUnmodifiable();
-  V putIfAbsent(K key, V ifAbsent()) => _throwUnmodifiable();
-  V remove(K key) => _throwUnmodifiable();
-  void clear() => _throwUnmodifiable();
-  void addAll(Map<K, V> other) => _throwUnmodifiable();
-}
-
-class ConstantStringMap<K, V> extends ConstantMap<K, V> {
-
-  // This constructor is not used for actual compile-time constants.
-  // The instantiation of constant maps is shortcut by the compiler.
-  const ConstantStringMap._(this.length, this._jsObject, this._keys)
-      : super._();
-
-  final int length;
-  // A constant map is backed by a JavaScript object.
-  final _jsObject;
-  final List<K> _keys;
-
-  bool containsValue(V needle) {
-    return values.any((V value) => value == needle);
-  }
-
-  bool containsKey(Object key) {
-    if (key is! String) return false;
-    if ('__proto__' == key) return false;
-    return jsHasOwnProperty(_jsObject, key);
-  }
-
-  V operator [](Object key) {
-    if (!containsKey(key)) return null;
-    return _fetch(key);
-  }
-
-  // [_fetch] is the indexer for keys for which `containsKey(key)` is true.
-  _fetch(key) => jsPropertyAccess(_jsObject, key);
-
-  void forEach(void f(K key, V value)) {
-    // Use a JS 'cast' to get efficient loop.  Type inferrence doesn't get this
-    // since constant map representation is chosen after type inferrence and the
-    // instantiation is shortcut by the compiler.
-    var keys = JS('JSArray', '#', _keys);
-    for (int i = 0; i < keys.length; i++) {
-      var key = keys[i];
-      f(key, _fetch(key));
-    }
-  }
-
-  Iterable<K> get keys {
-    return new _ConstantMapKeyIterable<K>(this);
-  }
-
-  Iterable<V> get values {
-    return new MappedIterable<K, V>(_keys, (key) => _fetch(key));
-  }
-}
-
-class ConstantProtoMap<K, V> extends ConstantStringMap<K, V> {
-  // This constructor is not used.  The instantiation is shortcut by the
-  // compiler. It is here to make the uninitialized final fields legal.
-  ConstantProtoMap._(length, jsObject, keys, this._protoValue)
-      : super._(length, jsObject, keys);
-
-  final V _protoValue;
-
-  bool containsKey(Object key) {
-    if (key is! String) return false;
-    if ('__proto__' == key) return true;
-    return jsHasOwnProperty(_jsObject, key);
-  }
-
-  _fetch(key) =>
-      '__proto__' == key ? _protoValue : jsPropertyAccess(_jsObject, key);
-}
-
-class _ConstantMapKeyIterable<K> extends Iterable<K> {
-  ConstantStringMap<K, dynamic> _map;
-  _ConstantMapKeyIterable(this._map);
-
-  Iterator<K> get iterator => _map._keys.iterator;
-
-  int get length => _map._keys.length;
-}
-
-class GeneralConstantMap<K, V> extends ConstantMap<K, V> {
-  // This constructor is not used.  The instantiation is shortcut by the
-  // compiler. It is here to make the uninitialized final fields legal.
-  GeneralConstantMap(this._jsData) : super._();
-
-  // [_jsData] holds a key-value pair list.
-  final _jsData;
-
-  // We cannot create the backing map on creation since hashCode interceptors
-  // have not been defined when constants are created.
-  Map<K, V> _getMap() {
-    LinkedHashMap<K, V> backingMap = JS('LinkedHashMap|Null', r'#.$map', this);
-    if (backingMap == null) {
-      backingMap = new JsLinkedHashMap<K, V>();
-      fillLiteralMap(_jsData, backingMap);
-      JS('', r'#.$map = #', this, backingMap);
-    }
-    return backingMap;
-  }
-
-  bool containsValue(V needle) {
-    return _getMap().containsValue(needle);
-  }
-
-  bool containsKey(Object key) {
-    return _getMap().containsKey(key);
-  }
-
-  V operator [](Object key) {
-    return _getMap()[key];
-  }
-
-  void forEach(void f(K key, V value)) {
-    _getMap().forEach(f);
-  }
-
-  Iterable<K> get keys {
-    return _getMap().keys;
-  }
-
-  Iterable<V> get values {
-    return _getMap().values;
-  }
-
-  int get length => _getMap().length;
-}