Drop "Impl" suffix from local mirror class names.

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({});
@@ skipping 104 matching lines @@
     buf.write(']');
   }
   buf.write(') -> ');
   buf.write(_n(returnType.qualifiedName));
   return buf.toString();
 }
 
 List _metadata(reflectee)
   native 'DeclarationMirror_metadata';
 
-class _LocalMirrorSystemImpl extends MirrorSystem {
+class _LocalMirrorSystem extends MirrorSystem {
   // Change parameter back to "this.libraries" when native code is changed.
-  _LocalMirrorSystemImpl(List<LibraryMirror> libraries, this.isolate)
+  _LocalMirrorSystem(List<LibraryMirror> libraries, this.isolate)
       : 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');
+      _dynamicType = new _SpecialTypeMirror('dynamic');
     }
     return _dynamicType;
   }
 
   TypeMirror _voidType = null;
   TypeMirror get voidType {
     if (_voidType == null) {
-      _voidType = new _SpecialTypeMirrorImpl('void');
+      _voidType = new _SpecialTypeMirror('void');
     }
     return _voidType;
   }
 
   String toString() => "MirrorSystem for isolate '${isolate.debugName}'";
 }
 
-abstract class _LocalMirrorImpl implements Mirror {}
+abstract class _LocalMirror implements Mirror {}
 
-class _LocalIsolateMirrorImpl extends _LocalMirrorImpl
-    implements IsolateMirror {
-  _LocalIsolateMirrorImpl(this.debugName, this.rootLibrary);
+class _LocalIsolateMirror extends _LocalMirror implements IsolateMirror {
+  _LocalIsolateMirror (this.debugName, this.rootLibrary);
 
   final String debugName;
   final bool isCurrent = true;
   final LibraryMirror rootLibrary;
 
   String toString() => "IsolateMirror on '$debugName'";
 }
 
 class _InvocationTrampoline implements Function {
   ObjectMirror _receiver;
   Symbol _selector;
   _InvocationTrampoline(this._receiver, this._selector);
   noSuchMethod(Invocation msg) {
     if (msg.memberName != #call) return super.noSuchMethod(msg);
     return _receiver.invoke(_selector,
                             msg.positionalArguments,
                             msg.namedArguments);
   }
 }
 
-abstract class _LocalObjectMirrorImpl extends _LocalMirrorImpl
-    implements ObjectMirror {
-  _LocalObjectMirrorImpl(this._reflectee);
+abstract class _LocalObjectMirror extends _LocalMirror implements ObjectMirror {
+  _LocalObjectMirror(this._reflectee);
 
   final _reflectee; // May be a MirrorReference or an ordinary object.
 
   InstanceMirror invoke(Symbol memberName,
                         List positionalArguments,
                         [Map<Symbol, dynamic> namedArguments]) {
 
     int numPositionalArguments = positionalArguments.length;
     int numNamedArguments = namedArguments != null ? namedArguments.length : 0;
     int numArguments = numPositionalArguments + numNamedArguments;
@@ skipping 21 matching lines @@
   }
 
   InstanceMirror setField(Symbol memberName, Object value) {
     this._invokeSetter(_reflectee,
                        _n(memberName),
                        value);
     return reflect(value);
   }
 }
 
-class _LocalInstanceMirrorImpl extends _LocalObjectMirrorImpl
+class _LocalInstanceMirror extends _LocalObjectMirror
     implements InstanceMirror {
   // TODO(ahe): This is a hack, see delegate below.
   static Function _invokeOnClosure;
 
-  _LocalInstanceMirrorImpl(reflectee) : super(reflectee);
+  _LocalInstanceMirror(reflectee) : super(reflectee);
 
   ClassMirror _type;
   ClassMirror get type {
     if (_type == null) {
       // Note it not safe to use reflectee.runtimeType because runtimeType may
       // be overridden.
       _type = reflectType(_computeType(reflectee));
     }
     return _type;
   }
 
   // LocalInstanceMirrors always reflect local instances
   bool hasReflectee = true;
 
   get reflectee => _reflectee;
 
   delegate(Invocation invocation) {
     if (_invokeOnClosure == null) {
       // TODO(ahe): This is a total hack.  We're using the mirror
       // system to access a private field in a different library.  For
       // some reason, that works.  On the other hand, calling a
       // private method does not work.
-
-      _LocalInstanceMirrorImpl mirror =
-          reflect(invocation);
-      _invokeOnClosure = reflectClass(invocation.runtimeType)
-          .getField(MirrorSystem.getSymbol('_invokeOnClosure', mirror.type.owner)).reflectee;
+      ClassMirror invocationImplClass = reflect(invocation).type;
+      Symbol fieldName = MirrorSystem.getSymbol('_invokeOnClosure',
+                                                invocationImplClass.owner);
+      _invokeOnClosure = invocationImplClass.getField(fieldName).reflectee;
     }
     return _invokeOnClosure(reflectee, invocation);
   }
 
   String toString() => 'InstanceMirror on ${Error.safeToString(_reflectee)}';
 
   bool operator ==(other) {
-    return other is _LocalInstanceMirrorImpl &&
+    return other is _LocalInstanceMirror &&
            identical(_reflectee, other._reflectee);
   }
 
   int get hashCode {
     // Avoid hash collisions with the reflectee. This constant is in Smi range
     // and happens to be the inner padding from RFC 2104.
     return identityHashCode(_reflectee) ^ 0x36363636;
   }
 
   Function operator [](Symbol selector) {
@@ skipping 45 matching lines @@
   _invokeGetter(reflectee, getterName)
       native 'InstanceMirror_invokeGetter';
 
   _invokeSetter(reflectee, setterName, value)
       native 'InstanceMirror_invokeSetter';
 
   static _computeType(reflectee)
       native 'InstanceMirror_computeType';
 }
 
-class _LocalClosureMirrorImpl extends _LocalInstanceMirrorImpl
+class _LocalClosureMirror extends _LocalInstanceMirror
     implements ClosureMirror {
-  _LocalClosureMirrorImpl(reflectee) : super(reflectee);
+  _LocalClosureMirror(reflectee) : super(reflectee);
 
   MethodMirror _function;
   MethodMirror get function {
     if (_function == null) {
       _function = _computeFunction(reflectee);
     }
     return _function;
   }
 
   InstanceMirror apply(List<Object> positionalArguments,
@@ skipping 52 matching lines @@
   static _apply(arguments, argumentNames)
       native 'ClosureMirror_apply';
 
   static _computeFunction(reflectee)
       native 'ClosureMirror_function';
 
   static _computeFindInContext(reflectee, name)
       native 'ClosureMirror_find_in_context';
 }
 
-class _LocalClassMirrorImpl extends _LocalObjectMirrorImpl
+class _LocalClassMirror extends _LocalObjectMirror
     implements ClassMirror {
-  _LocalClassMirrorImpl(reflectee,
-                        reflectedType,
-                        String simpleName,
-                        this._owner,
-                        this._isGeneric,
-                        this._isMixinAlias,
-                        this._isGenericDeclaration)
+  _LocalClassMirror(reflectee,
+                    reflectedType,
+                    String simpleName,
+                    this._owner,
+                    this._isGeneric,
+                    this._isMixinAlias,
+                    this._isGenericDeclaration)
       : this._simpleName = _s(simpleName),
         this._reflectedType = reflectedType,
         this._instantiator = reflectedType,
         super(reflectee);
 
   final Type _reflectedType;
   final bool _isGeneric;
   final bool _isMixinAlias;
   final bool _isGenericDeclaration;
   Type _instantiator;
@@ skipping 184 matching lines @@
   List<TypeVariableMirror> _typeVariables = null;
   List<TypeVariableMirror> get typeVariables {
     if (_typeVariables == null) {
       if (_isAnonymousMixinApplication) return _typeVariables = emptyList;
       _typeVariables = new List<TypeVariableMirror>();
 
       List params = _ClassMirror_type_variables(_reflectee);
       ClassMirror owner = originalDeclaration;
       var mirror;
       for (var i = 0; i < params.length; i += 2) {
-        mirror = new _LocalTypeVariableMirrorImpl(
+        mirror = new _LocalTypeVariableMirror(
             params[i + 1], params[i], owner);
         _typeVariables.add(mirror);
       }
       _typeVariables = new UnmodifiableListView(_typeVariables);
     }
     return _typeVariables;
   }
 
   List<TypeMirror> _typeArguments = null;
   List<TypeMirror> get typeArguments {
@@ skipping 121 matching lines @@
   static _invokeConstructor(reflectee, type, constructorName, arguments, argumentNames)
       native 'ClassMirror_invokeConstructor';
 
   static _ClassMirror_type_variables(reflectee)
       native "ClassMirror_type_variables";
 
   static _computeTypeArguments(reflectee)
       native "ClassMirror_type_arguments";
 }
 
-class _LocalFunctionTypeMirrorImpl extends _LocalClassMirrorImpl
+class _LocalFunctionTypeMirror extends _LocalClassMirror
     implements FunctionTypeMirror {
-  _LocalFunctionTypeMirrorImpl(reflectee, reflectedType)
+  _LocalFunctionTypeMirror(reflectee, reflectedType)
       : super(reflectee, reflectedType, null, null, false, false, false);
 
   bool get _isAnonymousMixinApplication => false;
 
   // FunctionTypeMirrors have a simpleName generated from their signature.
   Symbol _simpleName = null;
   Symbol get simpleName {
     if (_simpleName == null) {
       _simpleName = _s(_makeSignatureString(returnType, parameters));
     }
@@ skipping 39 matching lines @@
   MethodMirror _FunctionTypeMirror_call_method(reflectee)
       native "FunctionTypeMirror_call_method";
 
   static Type _FunctionTypeMirror_return_type(reflectee, instantiator)
       native "FunctionTypeMirror_return_type";
 
   List<ParameterMirror> _FunctionTypeMirror_parameters(reflectee)
       native "FunctionTypeMirror_parameters";
 }
 
-abstract class _LocalDeclarationMirrorImpl extends _LocalMirrorImpl
+abstract class _LocalDeclarationMirror extends _LocalMirror
     implements DeclarationMirror {
-  _LocalDeclarationMirrorImpl(this._reflectee, this._simpleName);
+  _LocalDeclarationMirror(this._reflectee, this._simpleName);
 
   final _reflectee;
 
   Symbol _simpleName;
   Symbol get simpleName => _simpleName;
 
   Symbol _qualifiedName = null;
   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 new UnmodifiableListView(_metadata(_reflectee).map(reflect));
   }
 
   bool operator ==(other) {
     return this.runtimeType == other.runtimeType &&
            this._reflectee == other._reflectee;
   }
 
   int get hashCode => simpleName.hashCode;
 }
 
-class _LocalTypeVariableMirrorImpl extends _LocalDeclarationMirrorImpl
+class _LocalTypeVariableMirror extends _LocalDeclarationMirror
     implements TypeVariableMirror {
-  _LocalTypeVariableMirrorImpl(reflectee,
-                               String simpleName,
-                               this._owner)
+  _LocalTypeVariableMirror(reflectee,
+                           String simpleName,
+                           this._owner)
       : super(reflectee, _s(simpleName));
 
   DeclarationMirror _owner;
   DeclarationMirror get owner {
     if (_owner == null) {
       _owner = _TypeVariableMirror_owner(_reflectee).originalDeclaration;
     }
     return _owner;
   }
 
@@ skipping 34 matching lines @@
   int get hashCode => simpleName.hashCode;
 
   static DeclarationMirror _TypeVariableMirror_owner(reflectee)
       native "TypeVariableMirror_owner";
 
   static Type _TypeVariableMirror_upper_bound(reflectee)
       native "TypeVariableMirror_upper_bound";
 }
 
 
-class _LocalTypedefMirrorImpl extends _LocalDeclarationMirrorImpl
+class _LocalTypedefMirror extends _LocalDeclarationMirror
     implements TypedefMirror {
-  _LocalTypedefMirrorImpl(reflectee,
-                          this._reflectedType,
-                          String simpleName,
-                          this._isGeneric,
-                          this._isGenericDeclaration,
-                          this._owner)
+  _LocalTypedefMirror(reflectee,
+                      this._reflectedType,
+                      String simpleName,
+                      this._isGeneric,
+                      this._isGenericDeclaration,
+                      this._owner)
       : super(reflectee, _s(simpleName));
 
   final Type _reflectedType;
   final bool _isGeneric;
   final bool _isGenericDeclaration;
 
   bool get isTopLevel => true;
   bool get isPrivate => false;
 
   DeclarationMirror _owner;
   DeclarationMirror get owner {
     if (_owner == null) {
-      _owner = _LocalClassMirrorImpl._library(_reflectee);
+      _owner = _LocalClassMirror._library(_reflectee);
     }
     return _owner;
   }
 
   SourceLocation get location {
     throw new UnimplementedError('TypedefMirror.location is not implemented');
   }
 
   TypeMirror _referent = null;
   TypeMirror get referent {
@@ skipping 11 matching lines @@
       return this;
     } else {
       return _nativeDeclaration(_reflectedType);
     }
   }
 
   List<TypeVariableMirror> _typeVariables = null;
   List<TypeVariableMirror> get typeVariables {
     if (_typeVariables == null) {
       _typeVariables = new List<TypeVariableMirror>();
-      List params = _LocalClassMirrorImpl._ClassMirror_type_variables(_reflectee);
+      List params = _LocalClassMirror._ClassMirror_type_variables(_reflectee);
       TypedefMirror owner = originalDeclaration;
       var mirror;
       for (var i = 0; i < params.length; i += 2) {
-        mirror = new _LocalTypeVariableMirrorImpl(
+        mirror = new _LocalTypeVariableMirror(
             params[i + 1], params[i], owner);
         _typeVariables.add(mirror);
       }
     }
     return _typeVariables;
   }
 
   List<TypeMirror> _typeArguments = null;
   List<TypeMirror> get typeArguments {
     if(_typeArguments == null) {
       if(_isGenericDeclaration) {
         _typeArguments = emptyList;
       } else {
         _typeArguments = new UnmodifiableListView(
-            _LocalClassMirrorImpl._computeTypeArguments(_reflectedType));
+            _LocalClassMirror._computeTypeArguments(_reflectedType));
       }
     }
     return _typeArguments;
   }
 
   String toString() => "TypedefMirror on '${_n(simpleName)}'";
 
   static _nativeReferent(reflectedType)
       native "TypedefMirror_referent";
 
   static _nativeDeclaration(reflectedType)
       native "TypedefMirror_declaration";
 }
 
-class _LocalLibraryMirrorImpl extends _LocalObjectMirrorImpl
+class _LocalLibraryMirror extends _LocalObjectMirror
     implements LibraryMirror {
-  _LocalLibraryMirrorImpl(reflectee,
-                          String simpleName,
-                          String url)
+  _LocalLibraryMirror(reflectee,
+                      String simpleName,
+                      String url)
       : this.simpleName = _s(simpleName),
         this.uri = Uri.parse(url),
         super(reflectee);
 
   final Symbol simpleName;
 
   // The simple name and the qualified name are the same for a library.
   Symbol get qualifiedName => simpleName;
 
   // Always null for libraries.
@@ skipping 108 matching lines @@
   _invokeGetter(reflectee, getterName)
       native 'LibraryMirror_invokeGetter';
 
   _invokeSetter(reflectee, setterName, value)
       native 'LibraryMirror_invokeSetter';
 
   _computeMembers(reflectee)
       native "LibraryMirror_members";
 }
 
-class _LocalMethodMirrorImpl extends _LocalDeclarationMirrorImpl
+class _LocalMethodMirror extends _LocalDeclarationMirror
     implements MethodMirror {
-  _LocalMethodMirrorImpl(reflectee,
-                         String simpleName,
-                         this._owner,
-                         this.isStatic,
-                         this.isAbstract,
-                         this.isGetter,
-                         this.isSetter,
-                         this.isConstructor,
-                         this.isConstConstructor,
-                         this.isGenerativeConstructor,
-                         this.isRedirectingConstructor,
-                         this.isFactoryConstructor)
+  _LocalMethodMirror(reflectee,
+                     String simpleName,
+                     this._owner,
+                     this.isStatic,
+                     this.isAbstract,
+                     this.isGetter,
+                     this.isSetter,
+                     this.isConstructor,
+                     this.isConstConstructor,
+                     this.isGenerativeConstructor,
+                     this.isRedirectingConstructor,
+                     this.isFactoryConstructor)
       : this.isOperator = _operators.contains(simpleName),
         super(reflectee, _s(simpleName));
 
   static const _operators = const ["%", "&", "*", "+", "-", "/", "<", "<<",
       "<=", "==", ">", ">=", ">>", "[]", "[]=", "^", "|", "~", "unary-", "~/"];
 
   final bool isStatic;
   final bool isAbstract;
   final bool isGetter;
   final bool isSetter;
@@ skipping 101 matching lines @@
   static dynamic _MethodMirror_return_type(reflectee, instantiator)
       native "MethodMirror_return_type";
 
   List<ParameterMirror> _MethodMirror_parameters(reflectee)
       native "MethodMirror_parameters";
 
   static String _MethodMirror_source(reflectee)
       native "MethodMirror_source";
 }
 
-class _LocalVariableMirrorImpl extends _LocalDeclarationMirrorImpl
+class _LocalVariableMirror extends _LocalDeclarationMirror
     implements VariableMirror {
-  _LocalVariableMirrorImpl(reflectee,
-                           String simpleName,
-                           this.owner,
-                           this._type,
-                           this.isStatic,
-                           this.isFinal,
-                           this.isConst)
+  _LocalVariableMirror(reflectee,
+                       String simpleName,
+                       this.owner,
+                       this._type,
+                       this.isStatic,
+                       this.isFinal,
+                       this.isConst)
       : super(reflectee, _s(simpleName));
 
   final DeclarationMirror owner;
   final bool isStatic;
   final bool isFinal;
   final bool isConst;
 
   bool get isPrivate => _n(simpleName).startsWith('_');
 
   bool get isTopLevel => owner is LibraryMirror;
@@ skipping 13 matching lines @@
     }
     return _type;
   }
 
   String toString() => "VariableMirror on '${MirrorSystem.getName(simpleName)}'";
 
   static _VariableMirror_type(reflectee, instantiator)
       native "VariableMirror_type";
 }
 
-class _LocalParameterMirrorImpl extends _LocalVariableMirrorImpl
+class _LocalParameterMirror extends _LocalVariableMirror
     implements ParameterMirror {
-  _LocalParameterMirrorImpl(reflectee,
-                            String simpleName,
-                            DeclarationMirror owner,
-                            this._position,
-                            this.isOptional,
-                            this.isNamed,
-                            bool isFinal,
-                            this._defaultValueReflectee,
-                            this._unmirroredMetadata)
+  _LocalParameterMirror(reflectee,
+                        String simpleName,
+                        DeclarationMirror owner,
+                        this._position,
+                        this.isOptional,
+                        this.isNamed,
+                        bool isFinal,
+                        this._defaultValueReflectee,
+                        this._unmirroredMetadata)
       : super(reflectee,
               simpleName,
               owner,
               null,  // We override the type.
               false, // isStatic does not apply.
               isFinal,
               false  // Not const.
               );
 
   final int _position;
@@ skipping 34 matching lines @@
     }
     return _type;
   }
 
   String toString() => "ParameterMirror on '${_n(simpleName)}'";
 
   static Type _ParameterMirror_type(_reflectee, _position, instantiator)
       native "ParameterMirror_type";
 }
 
-class _SpecialTypeMirrorImpl extends _LocalMirrorImpl
+class _SpecialTypeMirror extends _LocalMirror
     implements TypeMirror, DeclarationMirror {
-  _SpecialTypeMirrorImpl(String name) : simpleName = _s(name);
+  _SpecialTypeMirror(String name) : simpleName = _s(name);
 
   final bool isPrivate = false;
   final DeclarationMirror owner = null;
   final Symbol simpleName;
   final bool isTopLevel = true;
   final List<InstanceMirror> metadata = emptyList;
 
   List<TypeVariableMirror> get typeVariables => emptyList;
   List<TypeMirror> get typeArguments => emptyList;
 
   bool get isOriginalDeclaration => true;
   TypeMirror get originalDeclaration => this;
 
   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) {
-    if (other is! _SpecialTypeMirrorImpl) {
+    if (other is! _SpecialTypeMirror) {
       return false;
     }
     return this.simpleName == other.simpleName;
   }
 
   int get hashCode => simpleName.hashCode;
 
   String toString() => "TypeMirror on '${_n(simpleName)}'";
 }
 
@@ skipping 11 matching lines @@
   static MirrorSystem currentMirrorSystem() {
     if (_currentMirrorSystem == null) {
       _currentMirrorSystem = makeLocalMirrorSystem();
     }
     return _currentMirrorSystem;
   }
 
   // Creates a new local mirror for some Object.
   static InstanceMirror reflect(Object reflectee) {
     return reflectee is Function
-        ? new _LocalClosureMirrorImpl(reflectee)
-        : new _LocalInstanceMirrorImpl(reflectee);
+        ? new _LocalClosureMirror(reflectee)
+        : new _LocalInstanceMirror(reflectee);
   }
 
   static ClassMirror makeLocalClassMirror(Type key)
       native "Mirrors_makeLocalClassMirror";
   static TypeMirror makeLocalTypeMirror(Type key)
       native "Mirrors_makeLocalTypeMirror";
 
   static Expando<ClassMirror> _declarationCache = new Expando("ClassMirror");
   static Expando<TypeMirror> _instanitationCache = new Expando("TypeMirror");
 
@@ skipping 14 matching lines @@
     if (typeMirror == null) {
       typeMirror = makeLocalTypeMirror(key);
       _instanitationCache[key] = typeMirror;
       if (typeMirror is ClassMirror && !typeMirror._isGeneric) {
         _declarationCache[key] = typeMirror;
       }
     }
     return typeMirror;
   }
 }