Use UnmodifiableMapView in compiler

sdk/lib/_internal/compiler/implementation/mirrors/dart2js_mirrors.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.
 
 library dart2js.mirrors;
 
-import 'dart:collection' show UnmodifiableListView;
+import 'dart:collection' show UnmodifiableListView, UnmodifiableMapView;
 
 import '../elements/elements.dart';
 import '../scanner/scannerlib.dart';
 import '../resolution/resolution.dart' show Scope;
 import '../dart2jslib.dart';
 import '../dart_types.dart';
 import '../tree/tree.dart';
 import '../util/util.dart'
-    show Spannable,
-         Link,
-         LinkBuilder,
-         NO_LOCATION_SPANNABLE;
+    show Link,
+         LinkBuilder;
 import '../util/characters.dart' show $CR, $LF;
 
 import 'source_mirrors.dart';
 import 'mirrors_util.dart';
-import 'util.dart';
 
 part 'dart2js_library_mirror.dart';
 part 'dart2js_type_mirrors.dart';
 part 'dart2js_member_mirrors.dart';
 part 'dart2js_instance_mirrors.dart';
 
 //------------------------------------------------------------------------------
 // Utility types and functions for the dart2js mirror system
 //------------------------------------------------------------------------------
 
+bool _includeLibrary(Dart2JsLibraryMirror mirror) {
+  return const bool.fromEnvironment("list_all_libraries") ||
+      !mirror._element.isInternalLibrary;
+}
+
 bool _isPrivate(String name) {
   return name.startsWith('_');
 }
 
 List<ParameterMirror> _parametersFromFunctionSignature(
     Dart2JsDeclarationMirror owner,
     FunctionSignature signature) {
   var parameters = <ParameterMirror>[];
   Link<Element> link = signature.requiredParameters;
   while (!link.isEmpty) {
@@ skipping 230 matching lines @@
     return 13 * _element.hashCode + 17 * owner.hashCode;
   }
 }
 
 //------------------------------------------------------------------------------
 // Mirror system implementation.
 //------------------------------------------------------------------------------
 
 class Dart2JsMirrorSystem extends MirrorSystem {
   final Compiler compiler;
-  Map<Uri, Dart2JsLibraryMirror> _libraries;
   Map<LibraryElement, Dart2JsLibraryMirror> _libraryMap;
+  UnmodifiableMapView<Uri, LibraryMirror> _filteredLibraries;
 
-  Dart2JsMirrorSystem(this.compiler)
-    : _libraryMap = new Map<LibraryElement, Dart2JsLibraryMirror>();
+  Dart2JsMirrorSystem(this.compiler);
 
   IsolateMirror get isolate => null;
 
   void _ensureLibraries() {
-    if (_libraries == null) {
-      _libraries = new Map<Uri, Dart2JsLibraryMirror>();
+    if (_filteredLibraries == null) {
+      var filteredLibs = new Map<Uri, LibraryMirror>();
+      _libraryMap = new Map<LibraryElement, Dart2JsLibraryMirror>();
       compiler.libraries.forEach((_, LibraryElement v) {
         var mirror = new Dart2JsLibraryMirror(mirrorSystem, v);
-        _libraries[mirror.uri] = mirror;
+        if (_includeLibrary(mirror)) {
+          filteredLibs[mirror.uri] = mirror;
+        }
         _libraryMap[v] = mirror;
       });
+
+      _filteredLibraries =
+          new UnmodifiableMapView<Uri, LibraryMirror>(filteredLibs);
     }
   }
 
   Map<Uri, LibraryMirror> get libraries {
     _ensureLibraries();
-    return new FilteredImmutableMap<Uri, LibraryMirror>(_libraries,
-        (library) => const bool.fromEnvironment("list_all_libraries") ||
-                     !library._element.isInternalLibrary);
+    return _filteredLibraries;
   }
 
   Dart2JsLibraryMirror _getLibrary(LibraryElement element) =>
       _libraryMap[element];
 
   Dart2JsMirrorSystem get mirrorSystem => this;
 
   TypeMirror get dynamicType =>
       _convertTypeToTypeMirror(compiler.types.dynamicType);
 
@@ skipping 34 matching lines @@
       return new Dart2JsClassDeclarationMirror(this, element.thisType);
     } else if (element.isTypedef()) {
       return new Dart2JsTypedefDeclarationMirror(this, element.thisType);
     }
     compiler.internalError(element, "Unexpected element $element.");
     return null;
   }
 }
 
 abstract class ContainerMixin {
-  Map<Symbol, DeclarationMirror> _declarations;
+  UnmodifiableMapView<Symbol, DeclarationMirror> _declarations;
 
   void _ensureDeclarations() {
     if (_declarations == null) {
-      _declarations = <Symbol, DeclarationMirror>{};
+      var declarations = <Symbol, DeclarationMirror>{};
       _forEachElement((Element element) {
         for (DeclarationMirror mirror in _getDeclarationMirrors(element)) {
           assert(invariant(_element,
-              !_declarations.containsKey(mirror.simpleName),
+              !declarations.containsKey(mirror.simpleName),
               message: "Declaration name '${nameOf(mirror)}' "
                        "is not unique in $_element."));
-          _declarations[mirror.simpleName] = mirror;
+          declarations[mirror.simpleName] = mirror;
         }
       });
+      _declarations =
+          new UnmodifiableMapView<Symbol, DeclarationMirror>(declarations);
     }
   }
 
   Element get _element;
 
   void _forEachElement(f(Element element));
 
   Iterable<Dart2JsMemberMirror> _getDeclarationMirrors(Element element);
 
   Map<Symbol, DeclarationMirror> get declarations {
     _ensureDeclarations();
-    return new ImmutableMapWrapper<Symbol, DeclarationMirror>(_declarations);
+    return _declarations;
   }
 }
 
 /**
  * Converts [element] into its corresponding [DeclarationMirror], if any.
  *
  * If [element] is an [AbstractFieldElement] the mirror for its getter is
  * returned or, if not present, the mirror for its setter.
  */
 DeclarationMirror _convertElementToDeclarationMirror(Dart2JsMirrorSystem system,
@@ skipping 27 matching lines @@
       container._getDeclarationMirrors(element);
   if (members.isEmpty) return null;
   return members.first;
 }
 
 /**
  * Experimental API for accessing compilation units defined in a
  * library.
  */
 // TODO(ahe): Superclasses? Is this really a mirror?
-class Dart2JsCompilationUnitMirror extends Dart2JsMirror
-    with ContainerMixin {
+class Dart2JsCompilationUnitMirror extends Dart2JsMirror with ContainerMixin {
   final Dart2JsLibraryMirror _library;
   final CompilationUnitElement _element;
 
   Dart2JsCompilationUnitMirror(this._element, this._library);
 
   Dart2JsMirrorSystem get mirrorSystem => _library.mirrorSystem;
 
   // TODO(johnniwinther): make sure that these are returned in declaration
   // order.
   void _forEachElement(f(Element element)) => _element.forEachLocalMember(f);
@@ skipping 10 matching lines @@
  *
  * All API in this class is experimental.
  */
 class BackDoor {
   /// Return the compilation units comprising [library].
   static List<Mirror> compilationUnitsOf(Dart2JsLibraryMirror library) {
     return library._element.compilationUnits.toList().map(
         (cu) => new Dart2JsCompilationUnitMirror(cu, library)).toList();
   }
 }