Add a MirrorReference reflectee for ClassMirrors. Rewrite the name accessor in terms of it, at leas…

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.
 
 // 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);
 }
@@ skipping 65 matching lines @@
 
 class _LocalMirrorSystemImpl extends MirrorSystem {
   // Change parameter back to "this.libraries" when native code is changed.
   _LocalMirrorSystemImpl(Map<String, LibraryMirror> libraries, this.isolate)
       : this.libraries = _createLibrariesMap(libraries),
         _functionTypes = new Map<String, FunctionTypeMirror>();
 
   final Map<Uri, LibraryMirror> libraries;
   final IsolateMirror isolate;
 
+  // TODO(rmacnak): dynamicType and voidType should not respond to the 
+  // ClassMirror protocol, so they should not inherit from the ClassMirror
+  // implementation.

[siva, 2013/07/08 21:29:23]

Ditto here regarding a new issue.

[rmacnak, 2013/07/08 22:01:11]

Issue 11743

+
   TypeMirror _dynamicType = null;
 
   TypeMirror get dynamicType {
     if (_dynamicType == null) {
       _dynamicType =
           new _LocalClassMirrorImpl(
-              null, 'dynamic', false, null, null, [], null,
+              null, null, 'dynamic', false, null, null, [], null,
               const {}, const {}, const {});
     }
     return _dynamicType;
   }
 
   TypeMirror _voidType = null;
 
   TypeMirror get voidType {
     if (_voidType == null) {
       _voidType =
           new _LocalClassMirrorImpl(
-              null, 'void', false, null, null, [], null,
+              null, null, 'void', false, null, null, [], null,
               const {}, const {}, const {});
     }
     return _voidType;
   }
 
   final Map<String, FunctionTypeMirror> _functionTypes;
   FunctionTypeMirror _lookupFunctionTypeMirror(
       TypeMirror returnType,
       List<ParameterMirror> parameters) {
     var sigString = _makeSignatureString(returnType, parameters);
@@ skipping 254 matching lines @@
     }
     return resolved;
   }
 
   final String libraryUrl;
   final Symbol typeName;
 }
 
 class _LocalClassMirrorImpl extends _LocalObjectMirrorImpl
     implements ClassMirror {
-  _LocalClassMirrorImpl(ref,
+  _LocalClassMirrorImpl(this._reflectee,
+                        ref,
                         String simpleName,
                         this.isClass,
                         this._owner,
                         this._superclass,
                         this._superinterfaces,
                         this._defaultFactory,
                         Map<String, Mirror> members,
                         Map<String, Mirror> constructors,
                         Map<String, Mirror> typeVariables)
-      : this.simpleName = _s(simpleName),
+      : this._simpleName = _s(simpleName),
         this.members = _convertStringToSymbolMap(members),
         this.constructors = _convertStringToSymbolMap(constructors),
         this.typeVariables = _convertStringToSymbolMap(typeVariables),
         super(ref);
 
-  final Symbol simpleName;
+  final _MirrorReference _reflectee;
+
+  Symbol _simpleName;
+  Symbol get simpleName {
+    // dynamic, void and the function types have their names set eagerly in the
+    // constructor.
+    if(_simpleName == null) {
+      _simpleName = _s(_ClassMirror_name(_reflectee));
+    }
+    return _simpleName;
+  }
 
   Symbol _qualifiedName = null;
   Symbol get qualifiedName {
     if (_qualifiedName == null) {
       _qualifiedName = _computeQualifiedName(owner, simpleName);
     }
     return _qualifiedName;
   }
 
   var _owner;
@@ skipping 145 matching lines @@
       return new Future<InstanceMirror>.error(exception);
     }
   }
 
   // get the metadata objects, convert them into InstanceMirrors using
   // reflect() and then make them into a Dart list
   List<InstanceMirror> get metadata => _metadata(this).map(reflect).toList();
 
   static _invokeConstructor(ref, constructorName, positionalArguments, async)
       native 'LocalClassMirrorImpl_invokeConstructor';
+
+  static String _ClassMirror_name(reflectee)
+      native "ClassMirror_name";
 }
 
 class _LazyFunctionTypeMirror {
   _LazyFunctionTypeMirror(this.returnType, this.parameters) {}
 
   ClassMirror resolve(MirrorSystem mirrors) {
     return mirrors._lookupFunctionTypeMirror(returnType.resolve(mirrors),
                                              parameters);
   }
 
   final returnType;
   final List<ParameterMirror> parameters;
 }
 
 class _LocalFunctionTypeMirrorImpl extends _LocalClassMirrorImpl
     implements FunctionTypeMirror {
   _LocalFunctionTypeMirrorImpl(ref,
                                simpleName,
                                this._returnType,
                                this.parameters)
-      : super(ref,
+      : super(null,
+              ref,
               simpleName,
               true,
               null,
               new _LazyTypeMirror('dart:core', 'Object'),
               [ new _LazyTypeMirror('dart:core', 'Function') ],
               null,
               const {},
               const {},
               const {});
 
@@ skipping 445 matching lines @@
   }
 
   // Creates a new local ClassMirror.
   static ClassMirror makeLocalClassMirror(Type key)
       native "Mirrors_makeLocalClassMirror";
 
   static ClassMirror reflectClass(Type key) {
     return makeLocalClassMirror(key);
   }
 }