Add `.type` to the transformed InstanceMirror.

reflectable/lib/src/transformer_implementation.dart

 // (c) 2015, the Dart Team. All rights reserved. Use of this
 // source code is governed by a BSD-style license that can be found in
 // the LICENSE file.
 
 library reflectable.src.transformer_implementation;
 
 import 'dart:async';
 import 'dart:convert';
 import 'dart:io';
 import 'dart:math' show max;
@@ skipping 101 matching lines @@
       result += constants.abstractAttribute;
     }
     if (element.isStatic) {
       result += constants.staticAttribute;
     }
     return result;
   }
 
   /// Returns a String with the textual representation of the declarations-map.
   String get declarationsString {
-    Iterable<String> declarationParts = declarations
-        .map((ExecutableElement instanceMember) {
+    Iterable<String> declarationParts = declarations.map(
+        (ExecutableElement instanceMember) {
       return '"${instanceMember.name}": '
           'new MethodMirrorImpl("${instanceMember.name}", '
           '${_declarationDescriptor(instanceMember)}, this)';
     });
     return "{${declarationParts.join(", ")}}";
   }
 
   void computeNames(Namer namer) {
     staticClassMirrorName = namer.freshName("Static_${baseName}_ClassMirror");
     staticInstanceMirrorName =
@@ skipping 623 matching lines @@
   Iterable<${prefix}ClassMirror> get annotatedClasses {
     return [${annotatedClassesStrings.join(", ")}];
   }""");
   }
 
   /// Returns the source code for the reflection free subclass of
   /// [ClassMirror] which is specialized for a `reflectedType` which
   /// is the class modeled by [classElement].
   String _staticClassMirrorCode(ClassDomain classDomain) {
     String declarationsString = classDomain.declarationsString;
+    String simpleName = classDomain.classElement.name;
+    // When/if we have library-mirrors there could be a generic implementation:
+    // String get qualifiedName => "${owner.qualifiedName}.${simpleName}";
+    String qualifiedName =
+        "${classDomain.classElement.library.name}.$simpleName";
     return """
 class ${classDomain.staticClassMirrorName} extends ClassMirrorUnimpl {
-  final String simpleName = "${classDomain.classElement.name}";
+  final String simpleName = "$simpleName";
+  final String qualifiedName = "$qualifiedName";
 
   Map<String, MethodMirror> _declarationsCache;
 
   Map<String, MethodMirror> get declarations {
     if (_declarationsCache == null) {
       _declarationsCache = new UnmodifiableMapView($declarationsString);
     }
     return _declarationsCache;
   }
 }
@@ skipping 334 matching lines @@
   /// [InstanceMirror] which is specialized for a `reflectee` which
   /// is an instance of the class modeled by [classElement].  The
   /// generated code will provide support as specified by
   /// [capabilities].
   String _staticInstanceMirrorCode(ClassDomain classDomain) {
     // The `rest` of the code is the entire body of the static mirror class,
     // except for the declaration of `reflectee`, and a constructor.
     String rest = "";
     rest += instanceMethodFilter(classDomain.reflectorDomain.capabilities);
     rest += _staticInstanceMirrorInvokeCode(classDomain);
+    rest += "  ClassMirror get type => "
+        "new ${classDomain.staticClassMirrorName}();\n";
     // TODO(eernst): add code for other mirror methods than `invoke`.
     return """
 class ${classDomain.staticInstanceMirrorName} extends InstanceMirrorUnimpl {
   final ${_classElementName(classDomain)} reflectee;
   ${classDomain.staticInstanceMirrorName}(this.reflectee);
 $rest}
 """;
   }
 
   /// Returns the result of transforming the given [source] code, which is
@@ skipping 202 matching lines @@
   TransformLogger get logger => _aggregateTransform.logger;
   Future<Asset> getInput(AssetId id) => _aggregateTransform.getInput(id);
   Future<String> readInputAsString(AssetId id, {Encoding encoding}) {
     return _aggregateTransform.readInputAsString(id, encoding: encoding);
   }
   Stream<List<int>> readInput(AssetId id) => _aggregateTransform.readInput(id);
   Future<bool> hasInput(AssetId id) => _aggregateTransform.hasInput(id);
   void addOutput(Asset output) => _aggregateTransform.addOutput(output);
   void consumePrimary() => _aggregateTransform.consumePrimary(primaryInput.id);
 }