Collections returned by mirror API should be unmodifiable.

dart/sdk/lib/_internal/lib/js_mirrors.dart

 // Copyright (c) 2013, 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 dart._js_mirrors;
 
 import 'dart:async';
+import 'dart:collection' show UnmodifiableListView;
 import 'dart:mirrors';
 
 import 'dart:_foreign_helper' show
     JS,
     JS_CURRENT_ISOLATE,
     JS_CURRENT_ISOLATE_CONTEXT,
     JS_GET_NAME;
 import 'dart:_collection-dev' as _symbol_dev;
 import 'dart:_js_helper' show
     BoundClosure,
@@ skipping 15 matching lines @@
 /// No-op method that is called to inform the compiler that metadata must be
 /// preserved at runtime.
 preserveMetadata() {}
 
 String getName(Symbol symbol) {
   preserveNames();
   return n(symbol);
 }
 
 class JsMirrorSystem implements MirrorSystem {
+  UnmodifiableMapView<Uri, LibraryMirror> _cachedLibraries;
+
   final IsolateMirror isolate = new JsIsolateMirror();
 
   TypeMirror get dynamicType => _dynamicType;
   TypeMirror get voidType => _voidType;
 
   final static TypeMirror _dynamicType =
       new JsTypeMirror(const Symbol('dynamic'));
   final static TypeMirror _voidType = new JsTypeMirror(const Symbol('void'));
 
   static final Map<String, List<LibraryMirror>> librariesByName =
       computeLibrariesByName();
 
   Map<Uri, LibraryMirror> get libraries {
-    Map<Uri, LibraryMirror> result = new Map<Uri, LibraryMirror>();
+    if (_cachedLibraries != null) return _cachedLibraries;
+    Map<Uri, LibraryMirror> result = new Map();
     for (List<LibraryMirror> list in librariesByName.values) {
       for (LibraryMirror library in list) {
         result[library.uri] = library;
       }
     }
-    return result;
+    return _cachedLibraries =
+        new UnmodifiableMapView<Uri, LibraryMirror>(result);
   }
 
   Iterable<LibraryMirror> findLibrary(Symbol libraryName) {
-    return new List<LibraryMirror>.from(librariesByName[n(libraryName)]);
+    return new UnmodifiableListView<LibraryMirror>(
+        librariesByName[n(libraryName)]);
   }
 
   static Map<String, List<LibraryMirror>> computeLibrariesByName() {
     disableTreeShaking();
     var result = new Map<String, List<LibraryMirror>>();
     var jsLibraries = JS('JSExtendableArray|Null', 'init.libraries');
     if (jsLibraries == null) return result;
     for (List data in jsLibraries) {
       String name = data[0];
       Uri uri = Uri.parse(data[1]);
@@ skipping 104 matching lines @@
 class JsLibraryMirror extends JsDeclarationMirror with JsObjectMirror
     implements LibraryMirror {
   final Uri uri;
   final List<String> _classes;
   final List<String> _functions;
   final List _metadata;
   final String _compactFieldSpecification;
   final bool _isRoot;
   List<JsMethodMirror> _cachedFunctionMirrors;
   List<JsVariableMirror> _cachedFields;
+  UnmodifiableMapView<Symbol, ClassMirror> _cachedClasses;
+  UnmodifiableMapView<Symbol, MethodMirror> _cachedFunctions;
+  UnmodifiableMapView<Symbol, MethodMirror> _cachedGetters;
+  UnmodifiableMapView<Symbol, MethodMirror> _cachedSetters;
+  UnmodifiableMapView<Symbol, VariableMirror> _cachedVariables;
+  UnmodifiableMapView<Symbol, Mirror> _cachedMembers;
+  UnmodifiableListView<InstanceMirror> _cachedMetadata;
 
   JsLibraryMirror(Symbol simpleName,
                   this.uri,
                   this._classes,
                   this._functions,
                   this._metadata,
                   this._compactFieldSpecification,
                   this._isRoot)
       : super(simpleName);
 
   String get _prettyName => 'LibraryMirror';
 
   Symbol get qualifiedName => simpleName;
 
   List<JsMethodMirror> get _methods => _functionMirrors;
 
   Map<Symbol, ClassMirror> get classes {
-    var result = new Map<Symbol, ClassMirror>();
+    if (_cachedClasses != null) return _cachedClasses;
+    var result = new Map();
     for (String className in _classes) {
       JsClassMirror cls = reflectClassByMangledName(className);
       result[cls.simpleName] = cls;
       cls._owner = this;
     }
-    return result;
+    return _cachedClasses =
+        new UnmodifiableMapView<Symbol, ClassMirror>(result);
   }
 
   InstanceMirror setField(Symbol fieldName, Object arg) {
     String name = n(fieldName);
     if (name.endsWith('=')) throw new ArgumentError('');
     var mirror = functions[s('$name=')];
     if (mirror == null) mirror = variables[fieldName];
     if (mirror == null) {
       // TODO(ahe): What receiver to use?
       throw new NoSuchMethodError(this, '${n(fieldName)}=', [arg], null);
@@ skipping 61 matching lines @@
       mirror._owner = this;
     }
     return _cachedFunctionMirrors = result;
   }
 
   List<VariableMirror> get _fields {
     if (_cachedFields != null) return _cachedFields;
     var result = <VariableMirror>[];
     parseCompactFieldSpecification(
         this, _compactFieldSpecification, true, result);
-    _cachedFields = result;
-    return _cachedFields;
+    return _cachedFields = result;
   }
 
   Map<Symbol, MethodMirror> get functions {
-    var result = new Map<Symbol, MethodMirror>();
+    if (_cachedFunctions != null) return _cachedFunctions;
+    var result = new Map();
     for (JsMethodMirror mirror in _functionMirrors) {
       if (!mirror.isConstructor) result[mirror.simpleName] = mirror;
     }
-    return result;
+    return _cachedFunctions =
+        new UnmodifiableMapView<Symbol, MethodMirror>(result);
   }
 
   Map<Symbol, MethodMirror> get getters {
-    var result = new Map<Symbol, MethodMirror>();
+    if (_cachedGetters != null) return _cachedGetters;
+    var result = new Map();
     // TODO(ahe): Implement this.
-    return result;
+    return _cachedGetters =
+        new UnmodifiableMapView<Symbol, MethodMirror>(result);
   }
 
   Map<Symbol, MethodMirror> get setters {
-    var result = new Map<Symbol, MethodMirror>();
+    if (_cachedSetters != null) return _cachedSetters;
+    var result = new Map();
     // TODO(ahe): Implement this.
-    return result;
+    return _cachedSetters =
+        new UnmodifiableMapView<Symbol, MethodMirror>(result);
   }
 
   Map<Symbol, VariableMirror> get variables {
-    var result = new Map<Symbol, VariableMirror>();
+    if (_cachedVariables != null) return _cachedVariables;
+    var result = new Map();
     for (JsVariableMirror mirror in _fields) {
       result[mirror.simpleName] = mirror;
     }
-    return result;
+    return _cachedVariables =
+        new UnmodifiableMapView<Symbol, VariableMirror>(result);
   }
 
   Map<Symbol, Mirror> get members {
-    Map<Symbol, Mirror> result = new Map<Symbol, Mirror>.from(classes);
+    if (_cachedMembers !=  null) return _cachedMembers;
+    Map<Symbol, Mirror> result = new Map.from(classes);
     addToResult(Symbol key, Mirror value) {
       result[key] = value;
     }
     functions.forEach(addToResult);
     getters.forEach(addToResult);
     setters.forEach(addToResult);
     variables.forEach(addToResult);
-    return result;
+    return _cachedMembers = new UnmodifiableMapView<Symbol, Mirror>(result);
   }
 
   List<InstanceMirror> get metadata {
+    if (_cachedMetadata != null) return _cachedMetadata;
     preserveMetadata();
-    return _metadata.map(reflect).toList();
+    return _cachedMetadata =
+        new UnmodifiableListView<InstanceMirror>(_metadata.map(reflect));
   }
 
   // TODO(ahe): Test this getter.
   DeclarationMirror get owner => null;
 }
 
 String n(Symbol symbol) => _symbol_dev.Symbol.getName(symbol);
 
 Symbol s(String name) {
   if (name == null) return null;
@@ skipping 151 matching lines @@
 class JsClassMirror extends JsTypeMirror with JsObjectMirror
     implements ClassMirror {
   final String _mangledName;
   final _jsConstructorOrInterceptor;
   final String _fieldsDescriptor;
   final List _fieldsMetadata;
   List _metadata;
   JsClassMirror _superclass;
   List<JsMethodMirror> _cachedMethods;
   List<JsVariableMirror> _cachedFields;
+  UnmodifiableMapView<Symbol, MethodMirror> _cachedConstructors;
+  UnmodifiableMapView<Symbol, MethodMirror> _cachedMethodsMap;
+  UnmodifiableMapView<Symbol, MethodMirror> _cachedGetters;
+  UnmodifiableMapView<Symbol, MethodMirror> _cachedSetters;
+  UnmodifiableMapView<Symbol, VariableMirror> _cachedVariables;
+  UnmodifiableMapView<Symbol, Mirror> _cachedMembers;
+  UnmodifiableListView<InstanceMirror> _cachedMetadata;
 
   // Set as side-effect of accessing JsLibraryMirror.classes.
   JsLibraryMirror _owner;
 
   JsClassMirror(Symbol simpleName,
                 this._mangledName,
                 this._jsConstructorOrInterceptor,
                 this._fieldsDescriptor,
                 this._fieldsMetadata)
       : super(simpleName);
 
   String get _prettyName => 'ClassMirror';
 
   get _jsConstructor {
     if (_jsConstructorOrInterceptor is Interceptor) {
       return JS('', '#.constructor', _jsConstructorOrInterceptor);
     } else {
       return _jsConstructorOrInterceptor;
     }
   }
 
   Map<Symbol, MethodMirror> get constructors {
-    var result = new Map<Symbol, MethodMirror>();
+    if (_cachedConstructors != null) return _cachedConstructors;
+    var result = new Map();
     for (JsMethodMirror method in _methods) {
       if (method.isConstructor) {
         result[method.simpleName] = method;
       }
     }
-    return result;
+    return _cachedConstructors =
+        new UnmodifiableMapView<Symbol, MethodMirror>(result);
   }
 
   List<JsMethodMirror> get _methods {
     if (_cachedMethods != null) return _cachedMethods;
     var prototype = JS('', '#.prototype', _jsConstructor);
     List<String> keys = extractKeys(prototype);
     var result = <JsMethodMirror>[];
     for (String key in keys) {
       if (key == '') continue;
       String simpleName = mangledNames[key];
@@ skipping 58 matching lines @@
     var staticDescriptor = JS('', 'init.statics[#]', _mangledName);
     if (staticDescriptor != null) {
       parseCompactFieldSpecification(
           this, JS('', '#[""]', staticDescriptor), true, result);
     }
     _cachedFields = result;
     return _cachedFields;
   }
 
   Map<Symbol, MethodMirror> get methods {
-    var result = new Map<Symbol, MethodMirror>();
+    if (_cachedMethodsMap != null) return _cachedMethodsMap;
+    var result = new Map();
     for (JsMethodMirror method in _methods) {
       if (!method.isConstructor && !method.isGetter && !method.isSetter) {
         result[method.simpleName] = method;
       }
     }
-    return result;
+    return _cachedMethodsMap =
+        new UnmodifiableMapView<Symbol, MethodMirror>(result);
   }
 
   Map<Symbol, MethodMirror> get getters {
+    if (_cachedGetters != null) return _cachedGetters;
     // TODO(ahe): This is a hack to remove getters corresponding to a field.
     var fields = variables;
 
-    var result = new Map<Symbol, MethodMirror>();
+    var result = new Map();
     for (JsMethodMirror method in _methods) {
       if (method.isGetter) {
 
         // TODO(ahe): This is a hack to remove getters corresponding to a field.
         if (fields[method.simpleName] != null) continue;
 
         result[method.simpleName] = method;
       }
     }
-    return result;
+    return _cachedGetters =
+        new UnmodifiableMapView<Symbol, MethodMirror>(result);
   }
 
   Map<Symbol, MethodMirror> get setters {
+    if (_cachedSetters != null) return _cachedSetters;
     // TODO(ahe): This is a hack to remove setters corresponding to a field.
     var fields = variables;
 
-    var result = new Map<Symbol, MethodMirror>();
+    var result = new Map();
     for (JsMethodMirror method in _methods) {
       if (method.isSetter) {
 
         // TODO(ahe): This is a hack to remove setters corresponding to a field.
         String name = n(method.simpleName);
         name = name.substring(0, name.length - 1); // Remove '='.
         if (fields[s(name)] != null) continue;
 
         result[method.simpleName] = method;
       }
     }
-    return result;
+    return _cachedSetters =
+        new UnmodifiableMapView<Symbol, MethodMirror>(result);
   }
 
   Map<Symbol, VariableMirror> get variables {
-    var result = new Map<Symbol, VariableMirror>();
+    if (_cachedVariables != null) return _cachedVariables;
+    var result = new Map();
     for (JsVariableMirror mirror in _fields) {
       result[mirror.simpleName] = mirror;
     }
-    return result;
+    return _cachedVariables =
+        new UnmodifiableMapView<Symbol, VariableMirror>(result);
   }
 
   Map<Symbol, Mirror> get members {
-    Map<Symbol, Mirror> result = new Map<Symbol, Mirror>.from(variables);
+    if (_cachedMembers != null) return _cachedMembers;
+    Map<Symbol, Mirror> result = new Map.from(variables);
     for (JsMethodMirror method in _methods) {
       if (method.isSetter) {
         String name = n(method.simpleName);
         name = name.substring(0, name.length - 1);
         // Filter-out setters corresponding to variables.
         if (result[s(name)] is VariableMirror) continue;
       }
       // Use putIfAbsent to filter-out getters corresponding to variables.
       result.putIfAbsent(method.simpleName, () => method);
     }
-    return result;
+    return _cachedMembers = new UnmodifiableMapView<Symbol, Mirror>(result);
   }
 
   InstanceMirror setField(Symbol fieldName, Object arg) {
     JsVariableMirror mirror = variables[fieldName];
     if (mirror != null && mirror.isStatic && !mirror.isFinal) {
       String jsName = mirror._jsName;
       if (!JS('bool', '# in #', jsName, JS_CURRENT_ISOLATE())) {
         throw new RuntimeError('Cannot find "$jsName" in current isolate.');
       }
       JS('void', '#[#] = #', JS_CURRENT_ISOLATE(), jsName, arg);
@@ skipping 66 matching lines @@
         }
       }
       if (_owner == null) {
         throw new StateError('Class "${n(simpleName)}" has no owner');
       }
     }
     return _owner;
   }
 
   List<InstanceMirror> get metadata {
+    if (_cachedMetadata != null) return _cachedMetadata;
     if (_metadata == null) {
       _metadata = extractMetadata(JS('', '#.prototype', _jsConstructor));
     }
-    return _metadata.map(reflect).toList();
+    return _cachedMetadata =
+        new UnmodifiableListView<InstanceMirror>(_metadata.map(reflect));
   }
 
   ClassMirror get superclass {
     if (_superclass == null) {
       var superclassName = _fieldsDescriptor.split(';')[0];
       // Use _superclass == this to represent class with no superclass (Object).
       _superclass = (superclassName == '')
           ? this : reflectClassByMangledName(superclassName);
     }
     return _superclass == this ? null : _superclass;
@@ skipping 180 matching lines @@
   final _jsFunction;
   final int _parameterCount;
   final bool isGetter;
   final bool isSetter;
   final bool isStatic;
   final bool isConstructor;
   final bool isOperator;
   DeclarationMirror _owner;
   List _metadata;
   var _returnType;
-  var _parameters;
+  UnmodifiableListView<ParameterMirror> _parameters;
 
   JsMethodMirror(Symbol simpleName,
                  this._jsFunction,
                  this._parameterCount,
                  this.isGetter,
                  this.isSetter,
                  this.isStatic,
                  this.isConstructor,
                  this.isOperator)
       : super(simpleName);
@@ skipping 21 matching lines @@
       optionalParameterCount = int.parse(info[2]);
     }
     return new JsMethodMirror(
         s(name), jsFunction, requiredParameterCount + optionalParameterCount,
         isGetter, isSetter, isStatic, isConstructor, isOperator);
   }
 
   String get _prettyName => 'MethodMirror';
 
   List<ParameterMirror> get parameters {
+    if (_parameters != null) return _parameters;
     metadata; // Compute _parameters as a side-effect of extracting metadata.
-    return new List<ParameterMirror>.from(_parameters);
+    return _parameters;
   }
 
   DeclarationMirror get owner => _owner;
 
   TypeMirror get returnType {
     metadata; // Compute _returnType as a side-effect of extracting metadata.
     return typeMirrorFromRuntimeTypeRepresentation(_returnType);
   }
 
   List<InstanceMirror> get metadata {
     if (_metadata == null) {
       var raw = extractMetadata(_jsFunction);
-      _returnType = raw[0];
-      int parameterLength = 1 + _parameterCount * 2;
-      var formals = new List<ParameterMirror>(_parameterCount);
-      int formalsCount = 0;
-      for (int i = 1; i < parameterLength; i += 2) {
-        var name = raw[i];
-        var type = raw[i + 1];
-        formals[formalsCount++] = new JsParameterMirror(name, this, type);
+      var formals = new List(_parameterCount);
+      if (!raw.isEmpty) {
+        _returnType = raw[0];
+        int parameterLength = 1 + _parameterCount * 2;
+        int formalsCount = 0;
+        for (int i = 1; i < parameterLength; i += 2) {
+          var name = raw[i];
+          var type = raw[i + 1];
+          formals[formalsCount++] = new JsParameterMirror(name, this, type);
+        }
+        raw = raw.sublist(parameterLength);
+      } else {
+        for (int i = 0; i < _parameterCount; i++) {
+          formals[i] = new JsParameterMirror('argument$i', this, null);
+        }
       }
-      _parameters = formals;
-      _metadata = raw.sublist(parameterLength);
+      _parameters = new UnmodifiableListView<ParameterMirror>(formals);
+      _metadata = new UnmodifiableListView(raw.map(reflect));
     }
-    return _metadata.map(reflect).toList();
+    return _metadata;
   }
 
   Symbol get constructorName {
     // TODO(ahe): I believe it is more appropriate to throw an exception or
     // return null.
     if (!isConstructor) return const Symbol('');
     String name = n(simpleName);
     int index = name.indexOf('.');
     if (index == -1) return const Symbol('');
     return s(name.substring(index + 1));
@@ skipping 159 matching lines @@
   case '|':
   case '-':
   case 'unary-':
   case '[]=':
   case '~':
     return true;
   default:
     return false;
   }
 }
+
+// Copied from package "unmodifiable_collection".
+// TODO(ahe): Lobby to get it added to dart:collection.
+class UnmodifiableMapView<K, V> implements Map<K, V> {
+  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(); }

[kustermann, 2013/08/12 17:07:01]

Why do you use once {} and once => ?

[ahe, 2013/08/12 17:10:21]

I don't know, this is a verbatim copy from the package
"unmodifiable_collection".

+
+  void addAll(Map<K, V> other) => _throw();
+
+  V remove(K key) { _throw(); }
+
+  void clear() => _throw();
+}