Mirrors cleanup. No semantic changes.

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";
 
 // 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;
 }
 
-Map _makeMemberMap(List mirrors) {
-  Map result = new Map<Symbol, dynamic>();
-  mirrors.forEach((mirror) => result[mirror.simpleName] = mirror);
-  return result;
-}
+Map _makeMemberMap(List mirrors) => 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;
   return _s('${_n(owner.qualifiedName)}.${_n(simpleName)}');
 }
 
-Map<Symbol, dynamic> _convertStringToSymbolMap(Map<String, dynamic> map) {
-  if (map == null) return null;
-  Map<Symbol, dynamic> result = new Map<Symbol, dynamic>();
-  map.forEach((name, value) => result[_s(name)] = value);
-  return result;
-}
-
 String _makeSignatureString(TypeMirror returnType,
                             List<ParameterMirror> parameters) {
   StringBuffer buf = new StringBuffer();
   buf.write('(');
   bool found_optional_positional = false;
   bool found_optional_named = false;
 
   for (int i = 0; i < parameters.length; i++) {
     var param = parameters[i];
     if (param.isOptional && param.isNamed && !found_optional_named) {
@@ skipping 17 matching lines @@
     buf.write('}');
   }
   if (found_optional_positional) {
     buf.write(']');
   }
   buf.write(') -> ');
   buf.write(_n(returnType.qualifiedName));
   return buf.toString();
 }
 
-Map<Uri, LibraryMirror> _createLibrariesMap(List<LibraryMirror> list) {
-  var map = new Map<Uri, LibraryMirror>();
-  list.forEach((LibraryMirror mirror) => map[mirror.uri] = mirror);
-  return map;
-}
-
 List _metadata(reflectee)
   native 'DeclarationMirror_metadata';
 
 // This will verify the argument types, unwrap them, and ensure we have a fixed
 // array.
-List _unwarpAsyncPositionals(wrappedArgs) {
+List _unwrapAsyncPositionals(wrappedArgs) {
   List unwrappedArgs = new List(wrappedArgs.length);
   for(int i = 0; i < wrappedArgs.length; i++){
     var wrappedArg = wrappedArgs[i];
     if(_isSimpleValue(wrappedArg)) {
       unwrappedArgs[i] = wrappedArg;
     } else if(wrappedArg is InstanceMirror) {
       unwrappedArgs[i] = wrappedArg._reflectee;
     } else {
       throw "positional argument $i ($wrappedArg) was "
             "not a simple value or InstanceMirror";
     }
   }
   return unwrappedArgs;
 }
-Map _unwarpAsyncNamed(wrappedArgs) {
+
+Map _unwrapAsyncNamed(wrappedArgs) {
   if (wrappedArgs==null) return null;
   Map unwrappedArgs = new Map();
   wrappedArgs.forEach((name, wrappedArg){
     if(_isSimpleValue(wrappedArg)) {
       unwrappedArgs[name] = wrappedArg;
     } else if(wrappedArg is InstanceMirror) {
       unwrappedArgs[name] = wrappedArg._reflectee;
     } else {
       throw "named argument ${_n(name)} ($wrappedArg) was "
             "not a simple value or InstanceMirror";
     }
   });
   return unwrappedArgs;
 }
 
 class _LocalMirrorSystemImpl extends MirrorSystem {
   // Change parameter back to "this.libraries" when native code is changed.
   _LocalMirrorSystemImpl(List<LibraryMirror> libraries, this.isolate)
-      : this.libraries = _createLibrariesMap(libraries);
+      : this.libraries = new Map<Uri, LibraryMirror>.fromIterable(
+            libraries, key: (e) => e.uri);
 
   final Map<Uri, LibraryMirror> libraries;
   final IsolateMirror isolate;
 
   TypeMirror _dynamicType = null;
-
   TypeMirror get dynamicType {
     if (_dynamicType == null) {
       _dynamicType = new _SpecialTypeMirrorImpl('dynamic');
     }
     return _dynamicType;
   }
 
   TypeMirror _voidType = null;
-
   TypeMirror get voidType {
     if (_voidType == null) {
       _voidType = new _SpecialTypeMirrorImpl('void');
     }
     return _voidType;
   }
 
   String toString() => "MirrorSystem for isolate '${isolate.debugName}'";
 }
 
 abstract class _LocalMirrorImpl implements Mirror {
   int get hashCode {
     throw new UnimplementedError('Mirror.hashCode is not implemented');
   }
 
   // Local mirrors always return the same MirrorSystem.  This field
   // is more interesting once we implement remote mirrors.
   MirrorSystem get mirrors => _Mirrors.currentMirrorSystem();
 }
 
 class _LocalIsolateMirrorImpl extends _LocalMirrorImpl
     implements IsolateMirror {
-  _LocalIsolateMirrorImpl(this.debugName, this.rootLibrary) {}
+  _LocalIsolateMirrorImpl(this.debugName, this.rootLibrary);
 
   final String debugName;
   final bool isCurrent = true;
   final LibraryMirror rootLibrary;
 
   String toString() => "IsolateMirror on '$debugName'";
 }
 
 abstract class _LocalObjectMirrorImpl extends _LocalMirrorImpl
     implements ObjectMirror {
@@ skipping 36 matching lines @@
                        _n(memberName),
                        value);
     return reflect(value);
   }
 
   Future<InstanceMirror> invokeAsync(Symbol memberName,
                                      List positionalArguments,
                                      [Map<Symbol, dynamic> namedArguments]) {
     return new Future(() {
       return this.invoke(memberName,
-                         _unwarpAsyncPositionals(positionalArguments),
-                         _unwarpAsyncNamed(namedArguments));
+                         _unwrapAsyncPositionals(positionalArguments),
+                         _unwrapAsyncNamed(namedArguments));
     });
   }
 
   Future<InstanceMirror> getFieldAsync(Symbol memberName) {
    try {
       var result = this._invokeGetter(_reflectee,
                                       _n(memberName));
       return new Future.value(reflect(result)); 
     } catch(e) {
       return new Future.error(e);
@@ skipping 171 matching lines @@
     }
 
     // It is tempting to implement this in terms of Function.apply, but then
     // lazy compilation errors would be fatal.
     return reflect(_apply(_reflectee, arguments, names));
   }
 
   Future<InstanceMirror> applyAsync(List positionalArguments,
                                     [Map<Symbol, dynamic> namedArguments]) {
     return new Future(() {
-      return this.apply(_unwarpAsyncPositionals(positionalArguments),
-                        _unwarpAsyncNamed(namedArguments));
+      return this.apply(_unwrapAsyncPositionals(positionalArguments),
+                        _unwrapAsyncNamed(namedArguments));
     });
   }
 
   Future<InstanceMirror> findInContext(Symbol name) {
     throw new UnimplementedError(
         'ClosureMirror.findInContext() is not implemented');
   }
 
   String toString() => "ClosureMirror on '${Error.safeToString(_reflectee)}'";
 
@@ skipping 52 matching lines @@
       _owner = _library(_reflectee);
     }
     return _owner;
   }
 
   bool get isPrivate => _n(simpleName).startsWith('_');
 
   final bool isTopLevel = true;
 
   SourceLocation get location {
-    throw new UnimplementedError(
-        'ClassMirror.location is not implemented');
+    throw new UnimplementedError('ClassMirror.location is not implemented');
   }
 
   // TODO(rmacnak): Remove these left-overs from the days of separate interfaces
   // once we send out a breaking change.
   bool get isClass => true;
   ClassMirror get defaultFactory => null;
 
   ClassMirror _trueSuperclassField;
   ClassMirror get _trueSuperclass {
     if (_trueSuperclassField == null) {
@@ skipping 44 matching lines @@
           _mixin = this;
         } else {
           _mixin = _Mirrors._reflectType(mixinType);
         }
       }
     }
     return _mixin;
   }
 
   Map<Symbol, Mirror> _members;
-
   Map<Symbol, Mirror> get members {
     if (_members == null) {
       var whoseMembers = _isMixinTypedef ? _trueSuperclass : this;
       _members = _makeMemberMap(mixin._computeMembers(whoseMembers._reflectee));
     }
     return _members;
   }
 
-  Map<Symbol, MethodMirror> _methods = null;
-  Map<Symbol, MethodMirror> _getters = null;
-  Map<Symbol, MethodMirror> _setters = null;
-  Map<Symbol, VariableMirror> _variables = null;
-
+  Map<Symbol, MethodMirror> _methods;
   Map<Symbol, MethodMirror> get methods {
     if (_methods == null) {
       _methods = _filterMap(
           members,
           (key, value) => (value is MethodMirror && value.isRegularMethod));
     }
     return _methods;
   }
 
+  Map<Symbol, MethodMirror> _getters;
   Map<Symbol, MethodMirror> get getters {
     if (_getters == null) {
       _getters = _filterMap(
           members,
           (key, value) => (value is MethodMirror && value.isGetter));
     }
     return _getters;
   }
 
+  Map<Symbol, MethodMirror> _setters;
   Map<Symbol, MethodMirror> get setters {
     if (_setters == null) {
       _setters = _filterMap(
           members,
           (key, value) => (value is MethodMirror && value.isSetter));
     }
     return _setters;
   }
 
+  Map<Symbol, VariableMirror> _variables;
   Map<Symbol, VariableMirror> get variables {
     if (_variables == null) {
       _variables = _filterMap(
           members,
           (key, value) => (value is VariableMirror));
     }
     return _variables;
   }
 
   Map<Symbol, MethodMirror> _constructors;
-
   Map<Symbol, MethodMirror> get constructors {
     if (_constructors == null) {
       var constructorsList = _computeConstructors(_reflectee);
       var stringName = _n(simpleName);
       constructorsList.forEach((c) => c._patchConstructorName(stringName));
       _constructors = _makeMemberMap(constructorsList);
     } 
     return _constructors;  
   }
 
   Map<Symbol, TypeVariableMirror> _typeVariables = null;
-
   Map<Symbol, TypeVariableMirror> get typeVariables {
     if (_typeVariables == null) {
       List params = _ClassMirror_type_variables(_reflectee);
       _typeVariables = new LinkedHashMap<Symbol, TypeVariableMirror>();
       var mirror;
       for (var i = 0; i < params.length; i += 2) {
         mirror = new _LocalTypeVariableMirrorImpl(
             params[i + 1], params[i], this);
         _typeVariables[mirror.simpleName] = mirror;
       }
     }
     return _typeVariables;
   }
 
   Map<Symbol, TypeMirror> _typeArguments = null;
   Map<Symbol, TypeMirror> get typeArguments {
     if(_typeArguments == null) {
       if(_isGenericDeclaration) {
         _typeArguments = new LinkedHashMap<Symbol, TypeMirror>();
       } else {
         _typeArguments =
-            new LinkedHashMap<Symbol, TypeMirror>.fromIterables(typeVariables.keys,
-                                                                _computeTypeArguments(_reflectedType));
+            new LinkedHashMap<Symbol, TypeMirror>.fromIterables(
+                typeVariables.keys, _computeTypeArguments(_reflectedType));
       }
     }
     return _typeArguments;
   }
 
-  bool get isOriginalDeclaration {
-    return !_isGeneric || _isGenericDeclaration;
-  }
+  bool get isOriginalDeclaration => !_isGeneric || _isGenericDeclaration;
 
   ClassMirror get originalDeclaration {
     if (isOriginalDeclaration) {
       return this;
     } else {
       return reflectClass(_reflectedType);
     }
   }
 
-  String toString() {
-    return "ClassMirror on '${_n(simpleName)}'";
-  }
+  String toString() => "ClassMirror on '${_n(simpleName)}'";
 
   InstanceMirror newInstance(Symbol constructorName,
                              List positionalArguments,
                              [Map<Symbol, dynamic> namedArguments]) {
     // Native code will add the 1 or 2 implicit arguments depending on whether
     // we end up invoking a factory or constructor respectively.
     int numPositionalArguments = positionalArguments.length;
     int numNamedArguments = namedArguments != null ? namedArguments.length : 0;
     int numArguments = numPositionalArguments + numNamedArguments;
     List arguments = new List(numArguments);
@@ skipping 13 matching lines @@
                                       _n(constructorName),
                                       arguments,
                                       names));
   }
 
   Future<InstanceMirror> newInstanceAsync(Symbol constructorName,
                                           List positionalArguments,
                                           [Map<Symbol, dynamic> namedArguments]) {
     return new Future(() {
       return this.newInstance(constructorName,
-                              _unwarpAsyncPositionals(positionalArguments),
-                              _unwarpAsyncNamed(namedArguments));
+                              _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);
   }
 
   bool operator ==(other) {
@@ skipping 179 matching lines @@
 }
 
 
 class _LocalTypedefMirrorImpl extends _LocalDeclarationMirrorImpl
     implements TypedefMirror {
   _LocalTypedefMirrorImpl(reflectee,
                           String simpleName,
                           this._owner)
       : super(reflectee, _s(simpleName));
 
+  final bool isTopLevel = true;
+
   // TODO(12282): Deal with generic typedefs.
   bool get _isGeneric => false;
 
+  bool get isPrivate => false;
+
   DeclarationMirror _owner;
   DeclarationMirror get owner {
     if (_owner == null) {
       _owner = _LocalClassMirrorImpl._library(_reflectee);
     }
     return _owner;
   }
 
-  bool get isPrivate => false;
-
-  final bool isTopLevel = true;
-
   SourceLocation get location {
-    throw new UnimplementedError(
-        'TypedefMirror.location is not implemented');
+    throw new UnimplementedError('TypedefMirror.location is not implemented');
   }
 
   TypeMirror _referent = null;
   TypeMirror get referent {
     if (_referent == null) {
       // TODO(12282): Deal with generic typedef.
       return new _LocalFunctionTypeMirrorImpl(
           _TypedefMirror_referent(_reflectee), null);
     }
     return _referent;
@@ skipping 22 matching lines @@
   // Always null for libraries.
   final DeclarationMirror owner = null;
 
   // Always false for libraries.
   final bool isPrivate = false;
 
   // Always false for libraries.
   final bool isTopLevel = false;
 
   SourceLocation get location {
-    throw new UnimplementedError(
-        'LibraryMirror.location is not implemented');
+    throw new UnimplementedError('LibraryMirror.location is not implemented');
   }
 
   final Uri uri;
 
   Map<Symbol, Mirror> _members;
-
   Map<Symbol, Mirror> get members {
     if (_members == null) {
       _members = _makeMemberMap(_computeMembers(_reflectee));
     }
     return _members;
   }
 
-  Map<Symbol, ClassMirror> _classes = null;
-  Map<Symbol, MethodMirror> _functions = null;
-  Map<Symbol, MethodMirror> _getters = null;
-  Map<Symbol, MethodMirror> _setters = null;
-  Map<Symbol, VariableMirror> _variables = null;
-
+  Map<Symbol, ClassMirror> _classes;
   Map<Symbol, ClassMirror> get classes {
     if (_classes == null) {
       _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));
+      _functions = _filterMap(members, (key, value) => (value is MethodMirror));
     }
     return _functions;
   }
 
+  Map<Symbol, MethodMirror> _getters;
   Map<Symbol, MethodMirror> get getters {
     if (_getters == null) {
-      _getters = _filterMap(functions,
-                            (key, value) => (value.isGetter));
+      _getters = _filterMap(functions, (key, value) => (value.isGetter));
     }
     return _getters;
   }
 
+  Map<Symbol, MethodMirror> _setters;
   Map<Symbol, MethodMirror> get setters {
     if (_setters == null) {
-      _setters = _filterMap(functions,
-                            (key, value) => (value.isSetter));
+      _setters = _filterMap(functions, (key, value) => (value.isSetter));
     }
     return _setters;
   }
 
+  Map<Symbol, VariableMirror> _variables;
   Map<Symbol, VariableMirror> get variables {
     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);
   }
 
-  String toString() => "LibraryMirror on '${_n(simpleName)}'";
-
   bool operator ==(other) {
     return this.runtimeType == other.runtimeType &&
            this._reflectee == other._reflectee; 
   }
 
   int get hashCode => simpleName.hashCode;
 
+  String toString() => "LibraryMirror on '${_n(simpleName)}'";
+
   _invoke(reflectee, memberName, arguments, argumentNames)
       native 'LibraryMirror_invoke';
 
   _invokeGetter(reflectee, getterName)
       native 'LibraryMirror_invokeGetter';
 
   _invokeSetter(reflectee, setterName, value)
       native 'LibraryMirror_invokeSetter';
 
   _computeMembers(reflectee)
@@ skipping 34 matching lines @@
   DeclarationMirror _owner;
   DeclarationMirror get owner {
     // For nested closures it is possible, that the mirror for the owner has not
     // been created yet.
     if (_owner == null) {
       _owner = _MethodMirror_owner(_reflectee);
     }
     return _owner;
   }
 
-  bool get isPrivate {
-    return _n(simpleName).startsWith('_') ||
-        _n(constructorName).startsWith('_');
-  }
+  bool get isPrivate => _n(simpleName).startsWith('_') ||
+                        _n(constructorName).startsWith('_');
 
   bool get isTopLevel =>  owner is LibraryMirror;
 
   SourceLocation get location {
-    throw new UnimplementedError(
-        'MethodMirror.location is not implemented');
+    throw new UnimplementedError('MethodMirror.location is not implemented');
   }
 
   TypeMirror _returnType = null;
   TypeMirror get returnType {
     if (_returnType == null) {
       if (isConstructor) {
         _returnType = owner;
       } else {
         _returnType =
             _Mirrors._reflectType(_MethodMirror_return_type(_reflectee));
@@ skipping 70 matching lines @@
     implements VariableMirror {
   _LocalVariableMirrorImpl(reflectee,
                            String simpleName,
                            this.owner,
                            this._type,
                            this.isStatic,
                            this.isFinal)
       : super(reflectee, _s(simpleName));
 
   final DeclarationMirror owner;
+  final bool isStatic;
+  final bool isFinal;
 
-  bool get isPrivate {
-    return _n(simpleName).startsWith('_');
-  }
+  bool get isPrivate => _n(simpleName).startsWith('_');
 
-  bool get isTopLevel {
-    return owner is LibraryMirror;
-  }
+  bool get isTopLevel => owner is LibraryMirror;
 
   SourceLocation get location {
-    throw new UnimplementedError(
-        'VariableMirror.location is not implemented');
+    throw new UnimplementedError('VariableMirror.location is not implemented');
   }
 
   TypeMirror _type;
   TypeMirror get type {
     if (_type == null) {
        _type = _Mirrors._reflectType(_VariableMirror_type(_reflectee));
     }
     return _type;
   }
 
-  final bool isStatic;
-  final bool isFinal;
-
   String toString() => "VariableMirror on '${_n(simpleName)}'";
 
   static _VariableMirror_type(reflectee)
       native "VariableMirror_type";
 }
 
 class _LocalParameterMirrorImpl extends _LocalVariableMirrorImpl
     implements ParameterMirror {
   _LocalParameterMirrorImpl(reflectee,
                             String simpleName,
@@ skipping 48 matching lines @@
 
   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 DeclarationMirror owner = null;
-  final Symbol simpleName;
-
   SourceLocation get location {
-    throw new UnimplementedError(
-        'TypeMirror.location is not implemented');
+    throw new UnimplementedError('TypeMirror.location is not implemented');
   }
 
-  Symbol get qualifiedName {
-    return simpleName;
-  }
-
-  String toString() => "TypeMirror on '${_n(simpleName)}'";
+  Symbol get qualifiedName => simpleName;
 
   // TODO(11955): Remove once dynamicType and voidType are canonical objects in
   // the object store.
   bool operator ==(other) {
     if (other is! _SpecialTypeMirrorImpl) {
       return false;
     }
     return this.simpleName == other.simpleName;
   }
 
   int get hashCode => simpleName.hashCode;
+
+  String toString() => "TypeMirror on '${_n(simpleName)}'";
 }
 
 class _Mirrors {
   // Does a port refer to our local isolate?
   static bool isLocalPort(SendPort port) native 'Mirrors_isLocalPort';
 
   static MirrorSystem _currentMirrorSystem = null;
 
   // Creates a new local MirrorSystem.
   static MirrorSystem makeLocalMirrorSystem()
@@ skipping 54 matching lines @@
     if (typeMirror == null) {
       typeMirror = makeLocalTypeMirror(key);
       _instanitationCache[key] = typeMirror;
       if (typeMirror is ClassMirror && !typeMirror._isGeneric) {
         _declarationCache[key] = typeMirror;
       }
     }
     return typeMirror;
   }
 }