VM: Always return immutable collections from the mirrors.

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({});
+
+// Copied from js_mirrors, in turn copied from the package
+// "unmodifiable_collection".
+// TODO(14314): Move 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(); }
+
+  void addAll(Map<K, V> other) => _throw();
+
+  V remove(K key) { _throw(); }
+
+  void clear() => _throw();
+}
+
 // These values are allowed to be passed directly over the wire.
 bool _isSimpleValue(var value) {
   return (value == null || value is num || value is String || value is bool);
 }
 
 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_map;
+  return new _UnmodifiableMapView(new_map);
 }
 
-Map _makeMemberMap(List mirrors) => new Map<Symbol, dynamic>.fromIterable(
-    mirrors, key: (e) => e.simpleName);
+Map _makeMemberMap(List mirrors) {
+  return new _UnmodifiableMapView(
+      new Map<Symbol, dynamic>.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);
 }
 
 Symbol _computeQualifiedName(DeclarationMirror owner, Symbol simpleName) {
   if (owner == null) return simpleName;
@@ skipping 467 matching lines @@
   ClassMirror get superclass {
     return _isMixinTypedef ? _trueSuperclass._trueSuperclass : _trueSuperclass;
   }
 
   var _superinterfaces;
   List<ClassMirror> get superinterfaces {
     if (_superinterfaces == null) {
       _superinterfaces = isOriginalDeclaration
           ? _nativeInterfaces(_reflectedType)
           : _nativeInterfacesInstantiated(_reflectedType);
-      _superinterfaces = _superinterfaces
-          .map((i) => reflectType(i)).toList(growable:false);
+      _superinterfaces =
+          new UnmodifiableListView(_superinterfaces.map(reflectType));
     }
     return _superinterfaces;
   }
 
   get _mixinApplicationName {
     var mixins = new List<ClassMirror>();
     var klass = this;
     while (_nativeMixin(klass._reflectedType) != null) {
       mixins.add(klass.mixin);
       klass = klass.superclass;
@@ skipping 89 matching lines @@
 
   bool get _isAnonymousMixinApplication {
     if (_isMixinTypedef) return false;  // Named mixin application.
     if (mixin == this) return false;  // Not a mixin application.
     return true;
   }
 
   List<TypeVariableMirror> _typeVariables = null;
   List<TypeVariableMirror> get typeVariables {
     if (_typeVariables == null) {
+      if (_isAnonymousMixinApplication) return _typeVariables = emptyList;
       _typeVariables = new List<TypeVariableMirror>();
-      if (_isAnonymousMixinApplication) return _typeVariables;
 
       List params = _ClassMirror_type_variables(_reflectee);
       var mirror;
       for (var i = 0; i < params.length; i += 2) {
         mirror = new _LocalTypeVariableMirrorImpl(
             params[i + 1], params[i], this);
         _typeVariables.add(mirror);
       }
+      _typeVariables = new UnmodifiableListView(_typeVariables);
     }
     return _typeVariables;
   }
 
   List<TypeMirror> _typeArguments = null;
   List<TypeMirror> get typeArguments {
     if(_typeArguments == null) {
       if(_isGenericDeclaration || _isAnonymousMixinApplication) {
-        _typeArguments = new List<TypeMirror>();
+        _typeArguments = emptyList;
       } else {
         _typeArguments =
-            new List<TypeMirror>.from(_computeTypeArguments(_reflectedType));
+            new UnmodifiableListView(_computeTypeArguments(_reflectedType));
       }
     }
     return _typeArguments;
   }
 
   bool get isOriginalDeclaration => !_isGeneric || _isGenericDeclaration;
 
   ClassMirror get originalDeclaration {
     if (isOriginalDeclaration) {
       return this;
@@ skipping 37 matching lines @@
     return new Future(() {
       return this.newInstance(constructorName,
                               _unwrapAsyncPositionals(positionalArguments),
                               _unwrapAsyncNamed(namedArguments));
     });
   }
 
   List<InstanceMirror> get metadata {
     // Get the metadata objects, convert them into InstanceMirrors using
     // reflect() and then make them into a Dart list.
-    return _metadata(_reflectee).map(reflect).toList(growable:false);
+    return new UnmodifiableListView(_metadata(_reflectee).map(reflect));
   }
 
   bool operator ==(other) {
     return this.runtimeType == other.runtimeType &&
            this._reflectee == other._reflectee &&
            this._reflectedType == other._reflectedType &&
            this._isGenericDeclaration == other._isGenericDeclaration;
   }
 
   int get hashCode => simpleName.hashCode;
@@ skipping 77 matching lines @@
     return _returnType;
   }
 
   List<ParameterMirror> _parameters = null;
   List<ParameterMirror> get parameters {
     if (_parameters == null) {
       _parameters = _FunctionTypeMirror_parameters(_reflectee);
       _parameters.forEach((p) {
         p._type = p.type._instantiateInContextOf(reflectType(_instantiator));
       });
+      _parameters = new UnmodifiableListView(_parameters);
     }
     return _parameters;
   }
 
   bool get isOriginalDeclaration => true;
   get originalDeclaration => this;
-  get typeVariables => [];
-  get typeArguments => [];
-  get metadata => [];
-
-  Map<Symbol, Mirror> get members => new Map<Symbol,Mirror>();
-  Map<Symbol, MethodMirror> get constructors => new Map<Symbol,MethodMirror>();
+  get typeVariables => emptyList;
+  get typeArguments => emptyList;
+  get metadata => emptyList;
+  Map<Symbol, Mirror> get members => emptyMap;
+  Map<Symbol, MethodMirror> get constructors => emptyMap;
 
   String toString() => "FunctionTypeMirror on '${_n(simpleName)}'";
 
   MethodMirror _FunctionTypeMirror_call_method(reflectee)
       native "FunctionTypeMirror_call_method";
 
   static Type _FunctionTypeMirror_return_type(reflectee)
       native "FunctionTypeMirror_return_type";
 
   List<ParameterMirror> _FunctionTypeMirror_parameters(reflectee)
@@ skipping 13 matching lines @@
   Symbol get qualifiedName {
     if (_qualifiedName == null) {
       _qualifiedName = _computeQualifiedName(owner, simpleName);
     }
     return _qualifiedName;
   }
 
   List<InstanceMirror> get metadata {
     // Get the metadata objects, convert them into InstanceMirrors using
     // reflect() and then make them into a Dart list.
-    return _metadata(_reflectee).map(reflect).toList(growable:false);
+    return new UnmodifiableListView(_metadata(_reflectee).map(reflect));
   }
 
   bool operator ==(other) {
     return this.runtimeType == other.runtimeType &&
            this._reflectee == other._reflectee;
   }
 
   int get hashCode => simpleName.hashCode;
 }
 
@@ skipping 25 matching lines @@
   TypeMirror get upperBound {
     if (_upperBound == null) {
       _upperBound = reflectType(_TypeVariableMirror_upper_bound(_reflectee));
     }
     return _upperBound;
   }
 
   bool get hasReflectedType => false;
   Type get reflectedType => throw new UnsupportedError() ;
 
-  List<TypeVariableMirror> get typeVariables => new UnmodifiableListView<TypeVariableMirror>();
-  List<TypeMirror> get typeArguments => new UnmodifiableListView<TypeMirror>();
+  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 
         && simpleName == other.simpleName
         && owner == other.owner;
@@ skipping 84 matching lines @@
         _typeVariables.add(mirror);
       }
     }
     return _typeVariables;
   }
 
   List<TypeMirror> _typeArguments = null;
   List<TypeMirror> get typeArguments {
     if(_typeArguments == null) {
       if(_isGenericDeclaration) {
-        _typeArguments = new List<TypeMirror>();
+        _typeArguments = emptyList;
       } else {
-        _typeArguments =
-            new List<TypeMirror>.from(_LocalClassMirrorImpl._computeTypeArguments(_reflectedType));
+        _typeArguments = new UnmodifiableListView(
+            _LocalClassMirrorImpl._computeTypeArguments(_reflectedType));
       }
     }
     return _typeArguments;
   }
 
   TypeMirror _instantiateInContextOf(declaration) {
     var instantiator = declaration;
     while (instantiator is MethodMirror) instantiator = instantiator.owner;
     if (instantiator is LibraryMirror) return this;
     if (!(instantiator is ClassMirror || instantiator is TypedefMirror))
@@ skipping 56 matching lines @@
   Map<Symbol, TypeMirror> get types {
     if (_types == null) {
       _types = _filterMap(members, (key, value) => (value is TypeMirror));
     }
     return _types;
   }
 
   Map<Symbol, ClassMirror> _classes;
   Map<Symbol, ClassMirror> get classes {
     if (_classes == null) {
-      _classes = _filterMap(members,
-                            (key, value) => (value is ClassMirror));
+      _classes = _filterMap(members, (key, value) => (value is ClassMirror));
     }
     return _classes;
   }
 
   Map<Symbol, MethodMirror> _functions;
   Map<Symbol, MethodMirror> get functions {
     if (_functions == null) {
       _functions = _filterMap(members, (key, value) => (value is MethodMirror));
     }
     return _functions;
@@ skipping 20 matching lines @@
     if (_variables == null) {
       _variables = _filterMap(members,
                               (key, value) => (value is VariableMirror));
     }
     return _variables;
   }
 
   List<InstanceMirror> get metadata {
     // Get the metadata objects, convert them into InstanceMirrors using
     // reflect() and then make them into a Dart list.
-    return _metadata(_reflectee).map(reflect).toList(growable:false);
+    return new UnmodifiableListView(_metadata(_reflectee).map(reflect));
   }
 
   bool operator ==(other) {
     return this.runtimeType == other.runtimeType &&
            this._reflectee == other._reflectee;
   }
 
   int get hashCode => simpleName.hashCode;
 
   String toString() => "LibraryMirror on '${_n(simpleName)}'";
@@ skipping 71 matching lines @@
       }
       _returnType = _returnType._instantiateInContextOf(owner);
     }
     return _returnType;
   }
 
   List<ParameterMirror> _parameters = null;
   List<ParameterMirror> get parameters {
     if (_parameters == null) {
       _parameters = _MethodMirror_parameters(_reflectee);
+      _parameters = new UnmodifiableListView(_parameters);
     }
     return _parameters;
   }
 
   bool get isRegularMethod => !isGetter && !isSetter && !isConstructor;
 
   Symbol _constructorName = null;
   Symbol get constructorName {
     if (_constructorName == null) {
       if (!isConstructor) {
@@ skipping 115 matching lines @@
     }
     if (_defaultValue == null) {
       _defaultValue = reflect(_defaultValueReflectee);
     }
     return _defaultValue;
   }
 
   bool get hasDefaultValue => _defaultValueReflectee != null;
 
   List<InstanceMirror> get metadata {
-    if ( _unmirroredMetadata == null) return const [];
-    return _unmirroredMetadata.map(reflect).toList(growable:false);
+    if ( _unmirroredMetadata == null) return emptyList;
+    return new UnmodifiableListView(_unmirroredMetadata.map(reflect));
   }
 
   TypeMirror _type = null;
   TypeMirror get type {
     if (_type == null) {
       _type = reflectType(_ParameterMirror_type(_reflectee, _position));
       _type = _type._instantiateInContextOf(owner);
     }
     return _type;
   }
 
   String toString() => "ParameterMirror on '${_n(simpleName)}'";
 
   static Type _ParameterMirror_type(_reflectee, _position)
       native "ParameterMirror_type";
 }
 
 class _SpecialTypeMirrorImpl extends _LocalMirrorImpl
     implements TypeMirror, DeclarationMirror {
   _SpecialTypeMirrorImpl(String name) : simpleName = _s(name);
 
   final bool isPrivate = false;
   final DeclarationMirror owner = null;
   final Symbol simpleName;
   final bool isTopLevel = true;
   // Fixed length 0, therefore immutable.
-  final List<InstanceMirror> metadata = new List(0);
+  final List<InstanceMirror> metadata = emptyList;
 
   SourceLocation get location {
     throw new UnimplementedError('TypeMirror.location is not implemented');
   }
 
   Symbol get qualifiedName => simpleName;
 
   // TODO(11955): Remove once dynamicType and voidType are canonical objects in
   // the object store.
   bool operator ==(other) {
@@ skipping 75 matching lines @@
     if (typeMirror == null) {
       typeMirror = makeLocalTypeMirror(key);
       _instanitationCache[key] = typeMirror;
       if (typeMirror is ClassMirror && !typeMirror._isGeneric) {
         _declarationCache[key] = typeMirror;
       }
     }
     return typeMirror;
   }
 }