Revert "Remove unmodifiable map wrappers that could instead use UnmodifiableMapView."

runtime/lib/mirrors_impl.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.
 
 // VM-specific implementation of the dart:mirrors library.
 
 import "dart:collection";
 
 final emptyList = new UnmodifiableListView([]);
-final emptyMap = new UnmodifiableMapView({});
+final emptyMap = new _UnmodifiableMapView({});
+
+// TODO(14314): Move to dart:collection.
+class _UnmodifiableMapView<K, V> implements Map<K, V> {
+  final Map<K, V> _source;
+
+  _UnmodifiableMapView(Map<K, V> source) : _source = source;
+
+ static void _throw() {
+    throw new UnsupportedError("Cannot modify an unmodifiable Map");
+  }
+
+  int get length => _source.length;
+  bool get isEmpty => _source.isEmpty;
+  bool get isNotEmpty => _source.isNotEmpty;
+  V operator [](K key) => _source[key];
+  bool containsKey(K key) => _source.containsKey(key);
+  bool containsValue(V value) => _source.containsValue(value);
+  void forEach(void f(K key, V value)) => _source.forEach(f);
+  Iterable<K> get keys => _source.keys;
+  Iterable<V> get values => _source.values;
+  void operator []=(K key, V value) => _throw();
+  V putIfAbsent(K key, V ifAbsent()) { _throw(); }
+  void addAll(Map<K, V> other) => _throw();
+  V remove(K key) { _throw(); }
+  void clear() => _throw();
+}
 
 class _InternalMirrorError {
   final String _msg;
   const _InternalMirrorError(String this._msg);
   String toString() => _msg;
 }
 
 Map _filterMap(Map<Symbol, dynamic> old_map, bool filter(Symbol key, value)) {
   Map new_map = new Map<Symbol, dynamic>();
   old_map.forEach((key, value) {
     if (filter(key, value)) {
       new_map[key] = value;
     }
   });
-  return new UnmodifiableMapView(new_map);
+  return new _UnmodifiableMapView(new_map);
 }
 
 Map _makeMemberMap(List mirrors) {
-  return new UnmodifiableMapView<Symbol, DeclarationMirror>(
+  return new _UnmodifiableMapView<Symbol, DeclarationMirror>(
       new Map<Symbol, DeclarationMirror>.fromIterable(
           mirrors, key: (e) => e.simpleName));
 }
 
 String _n(Symbol symbol) => _symbol_dev.Symbol.getName(symbol);
 
 Symbol _s(String name) {
   if (name == null) return null;
   return new _symbol_dev.Symbol.unvalidated(name);
 }
@@ skipping 567 matching lines @@
           result[getterName] =
               new _SyntheticAccessor(this, getterName, true, true, false, decl);
           if (!decl.isFinal) {
             var setterName = _asSetter(decl.simpleName, this.owner);
             result[setterName] = new _SyntheticAccessor(
                 this, setterName, false, true, false, decl);
           }
         }
       });
       _cachedStaticMembers =
-          new UnmodifiableMapView<Symbol, MethodMirror>(result);
+          new _UnmodifiableMapView<Symbol, MethodMirror>(result);
     }
     return _cachedStaticMembers;
   }
 
   var _cachedInstanceMembers;
   Map<Symbol, MethodMirror> get instanceMembers {
     if (_cachedInstanceMembers == null) {
       var result = new Map<Symbol, MethodMirror>();
       if (superclass != null) {
         result.addAll(superclass.instanceMembers);
       }
       declarations.values.forEach((decl) {
         if (decl is MethodMirror && !decl.isStatic &&
             !decl.isConstructor && !decl.isAbstract) {
           result[decl.simpleName] = decl;
         }
         if (decl is VariableMirror && !decl.isStatic) {
           var getterName = decl.simpleName;
           result[getterName] =
               new _SyntheticAccessor(this, getterName, true, false, false, decl);
           if (!decl.isFinal) {
             var setterName = _asSetter(decl.simpleName, this.owner);
             result[setterName] = new _SyntheticAccessor(
                 this, setterName, false, false, false, decl);
           }
         }
       });
       _cachedInstanceMembers =
-          new UnmodifiableMapView<Symbol, MethodMirror>(result);
+          new _UnmodifiableMapView<Symbol, MethodMirror>(result);
     }
     return _cachedInstanceMembers;
   }
 
   Map<Symbol, DeclarationMirror> _declarations;
   Map<Symbol, DeclarationMirror> get declarations {
     if (_declarations != null) return _declarations;
     var decls = new Map<Symbol, DeclarationMirror>();
     decls.addAll(_members);
     decls.addAll(_constructors);
     typeVariables.forEach((tv) => decls[tv.simpleName] = tv);
     return _declarations =
-        new UnmodifiableMapView<Symbol, DeclarationMirror>(decls);
+        new _UnmodifiableMapView<Symbol, DeclarationMirror>(decls);
   }
 
   Map<Symbol, Mirror> _cachedMembers;
   Map<Symbol, Mirror> get _members {
     if (_cachedMembers == null) {
       var whoseMembers = _isMixinAlias ? _trueSuperclass : this;
       _cachedMembers = _makeMemberMap(mixin._computeMembers(whoseMembers._reflectee));
     }
     return _cachedMembers;
   }
@@ skipping 316 matching lines @@
 
   List<TypeVariableMirror> get typeVariables => emptyList;
   List<TypeMirror> get typeArguments => emptyList;
 
   bool get isOriginalDeclaration => true;
   TypeMirror get originalDeclaration => this;
 
   String toString() => "TypeVariableMirror on '${_n(simpleName)}'";
 
   operator ==(other) {
-    return other is TypeVariableMirror
+    return other is TypeVariableMirror 
         && simpleName == other.simpleName
         && owner == other.owner;
   }
   int get hashCode => simpleName.hashCode;
 
   bool isSubtypeOf(TypeMirror other) {
     if (other == currentMirrorSystem().dynamicType) return true;
     if (other == currentMirrorSystem().voidType) return false;
     return _subtypeTest(_reflectedType, other._reflectedType);
   }
@@ skipping 148 matching lines @@
   Type get _instantiator => null;
 
   SourceLocation get location {
     throw new UnimplementedError('LibraryMirror.location is not implemented');
   }
 
   Map<Symbol, DeclarationMirror> _declarations;
   Map<Symbol, DeclarationMirror> get declarations {
     if (_declarations != null) return _declarations;
     return _declarations =
-        new UnmodifiableMapView<Symbol, DeclarationMirror>(_members);
+        new _UnmodifiableMapView<Symbol, DeclarationMirror>(_members);
   }
 
   Map<Symbol, Mirror> _cachedMembers;
   Map<Symbol, Mirror> get _members {
     if (_cachedMembers == null) {
       _cachedMembers = _makeMemberMap(_computeMembers(_reflectee));
     }
     return _cachedMembers;
   }
 
@@ skipping 416 matching lines @@
     if (typeMirror == null) {
       typeMirror = makeLocalTypeMirror(key);
       _instanitationCache[key] = typeMirror;
       if (typeMirror is ClassMirror && !typeMirror._isGeneric) {
         _declarationCache[key] = typeMirror;
       }
     }
     return typeMirror;
   }
 }