Align source mirrors with runtime mirrors.

pkg/docgen/lib/docgen.dart

 // Copyright (c) 2013, 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.
 
 /// **docgen** is a tool for creating machine readable representations of Dart
 /// code metadata, including: classes, members, comments and annotations.
 ///
 /// docgen is run on a `.dart` file or a directory containing `.dart` files.
 ///
 ///      $ dart docgen.dart [OPTIONS] [FILE/DIR]
 ///
 /// This creates files called `docs/<library_name>.yaml` in your current
 /// working directory.
 library docgen;
 
 import 'dart:convert';
 import 'dart:io';
 import 'dart:async';
 
 import 'package:logging/logging.dart';
 import 'package:markdown/markdown.dart' as markdown;
 import 'package:path/path.dart' as path;
 import 'package:yaml/yaml.dart';
 
 import 'dart2yaml.dart';
 import 'src/io.dart';
 import '../../../sdk/lib/_internal/compiler/compiler.dart' as api;
 import '../../../sdk/lib/_internal/compiler/implementation/filenames.dart';
-import '../../../sdk/lib/_internal/compiler/implementation/mirrors/dart2js_mirror.dart'
+import '../../../sdk/lib/_internal/compiler/implementation/mirrors/dart2js_mirrors.dart'
     as dart2js;
-import '../../../sdk/lib/_internal/compiler/implementation/mirrors/mirrors.dart';
+import '../../../sdk/lib/_internal/compiler/implementation/mirrors/analyze.dart'
+    as dart2js;
+import '../../../sdk/lib/_internal/compiler/implementation/mirrors/source_mirrors.dart';
 import '../../../sdk/lib/_internal/compiler/implementation/mirrors/mirrors_util.dart'
     as dart2js_util;
 import '../../../sdk/lib/_internal/compiler/implementation/source_file_provider.dart';
 import '../../../sdk/lib/_internal/libraries.dart';
 
 const _DEFAULT_OUTPUT_DIRECTORY = 'docs';
 
 /// Annotations that we do not display in the viewer.
 const List<String> _SKIPPED_ANNOTATIONS = const [
     'metadata.DocsEditable', '_js_helper.JSName', '_js_helper.Creates',
@@ skipping 73 matching lines @@
 
 /// Given a Dart2jsMirror, find the corresponding Docgen [MirrorBased] object.
 ///
 /// We have this global lookup function to avoid re-implementing looking up the
 /// scoping rules for comment resolution here (it is currently done in mirrors).
 /// If no corresponding MirrorBased object is found, we return a [DummyMirror]
 /// that simply returns the original mirror's qualifiedName while behaving like
 /// a MirrorBased object.
 MirrorBased getDocgenObject(DeclarationMirror mirror, [Indexable owner]) {
   Map<String, Set<MirrorBased>> docgenObj =
-      mirrorToDocgen[mirror.qualifiedName];
+      mirrorToDocgen[dart2js_util.qualifiedNameOf(mirror)];
   if (docgenObj == null) {
     return new DummyMirror(mirror, owner);
   }
 
   Set<MirrorBased> results = new Set<MirrorBased>();
   var setToExamine = new Set();
   if (owner != null) {
     var firstSet = docgenObj[owner.docName];
     if (firstSet != null) setToExamine.addAll(firstSet);
     if (Indexable._coreLibrary != null &&
@@ skipping 34 matching lines @@
   DeclarationMirror mirror;
   /// The library that contains this element, if any. Used as a hint to help
   /// determine which object we're referring to when looking up this mirror in
   /// our map.
   Indexable owner;
   DummyMirror(this.mirror, [this.owner]);
 
   String get docName {
     if (mirror == null) return '';
     if (mirror is LibraryMirror) {
-      return mirror.qualifiedName.replaceAll('.','-');
+      return dart2js_util.qualifiedNameOf(mirror).replaceAll('.','-');
     }
     var mirrorOwner = mirror.owner;
-    if (mirrorOwner == null) return mirror.qualifiedName;
-    var simpleName = mirror.simpleName;
+    if (mirrorOwner == null) return dart2js_util.qualifiedNameOf(mirror);
+    var simpleName = dart2js_util.nameOf(mirror);
     if (mirror is MethodMirror && (mirror as MethodMirror).isConstructor) {
       // We name constructors specially -- including the class name again and a
       // "-" to separate the constructor from its name (if any).
-      simpleName = '${mirrorOwner.simpleName}-$simpleName';
+      simpleName = '${dart2js_util.nameOf(mirrorOwner)}-$simpleName';
     }
     return getDocgenObject(mirrorOwner, owner).docName + '.' + simpleName;
   }
   List<Annotation> _createAnnotations(DeclarationMirror mirror,
       Library owningLibrary) => null;
 
   bool get isPrivate => mirror == null? false : mirror.isPrivate;
 }
 
 abstract class MirrorBased {
   DeclarationMirror get mirror;
   MirrorBased owner;
 
   /// Returns this object's qualified name, but following the conventions
   /// we're using in Dartdoc, which is that library names with dots in them
   /// have them replaced with hyphens.
-  String get docName => owner.docName + '.' + mirror.simpleName;
+  String get docName => owner.docName + '.' + dart2js_util.nameOf(mirror);
 
   /// Returns a list of meta annotations assocated with a mirror.
   List<Annotation> _createAnnotations(DeclarationMirror mirror,
       Library owningLibrary) {
     var annotationMirrors = mirror.metadata.where((e) =>
         e is dart2js.Dart2JsConstructedConstantMirror);
     var annotations = [];
     annotationMirrors.forEach((annotation) {
       var docgenAnnotation = new Annotation(annotation, owningLibrary);
       if (!_SKIPPED_ANNOTATIONS.contains(
-          docgenAnnotation.mirror.qualifiedName)) {
+          dart2js_util.qualifiedNameOf(docgenAnnotation.mirror))) {
         annotations.add(docgenAnnotation);
       }
     });
     return annotations;
   }
 
   bool get isPrivate => false;
 }
 
 /// Docgen constructor initializes the link resolver for markdown parsing.
@@ skipping 90 matching lines @@
             (each) => each.uri.scheme == 'file');
         var availableLibrariesByPath = new Map.fromIterables(
             availableLibraries.map((each) => each.uri),
             availableLibraries);
         var librariesToDocument = requestedLibraries.map(
             (each) => availableLibrariesByPath.putIfAbsent(each,
                 () => throw "Missing library $each")).toList();
         librariesToDocument.addAll(
             (includeSdk || parseSdk) ? Indexable._sdkLibraries : []);
         librariesToDocument.removeWhere(
-            (x) => _excluded.contains(x.simpleName));
+            (x) => _excluded.contains(dart2js_util.nameOf(x)));
         _documentLibraries(librariesToDocument, includeSdk: includeSdk,
             outputToYaml: outputToYaml, append: append, parseSdk: parseSdk,
             introFileName: introFileName);
         return true;
       });
   }
 
   /// Writes text to a file in the output directory.
   static void _writeToFile(String text, String filename, {bool append: false}) {
     if (text == null) return;
@@ skipping 328 matching lines @@
 
   // TODO(janicejl): Make MDN content generic or pluggable. Maybe move
   // MDN-specific code to its own library that is imported into the default
   // impl?
   /// Map of all the comments for dom elements from MDN.
   static Map _mdn;
 
   Indexable(this.mirror) {
     this.isPrivate = _isHidden(mirror);
 
-    var map = mirrorToDocgen[this.mirror.qualifiedName];
+    var map = mirrorToDocgen[dart2js_util.qualifiedNameOf(this.mirror)];
     if (map == null) map = new Map<String, Set<MirrorBased>>();
 
     var set = map[owner.docName];
     if (set == null) set = new Set<MirrorBased>();
     set.add(this);
     map[owner.docName] = set;
-    mirrorToDocgen[this.mirror.qualifiedName] = map;
+    mirrorToDocgen[dart2js_util.qualifiedNameOf(this.mirror)] = map;
   }
 
   /** Walk up the owner chain to find the owning library. */
   Library _getOwningLibrary(Indexable indexable) {
     if (indexable is Library) return indexable;
     // TODO: is this needed?
-    if (indexable is DummyMirror) return getDocgenObject(indexable.mirror.library);
+    if (indexable is DummyMirror) {
+      return getDocgenObject(dart2js_util.getLibrary(indexable.mirror));
+    }
     return _getOwningLibrary(indexable.owner);
   }
 
   static initializeTopLevelLibraries(MirrorSystem mirrorSystem) {
     _sdkLibraries = mirrorSystem.libraries.values.where(
         (each) => each.uri.scheme == 'dart');
     _coreLibrary = new Library(_sdkLibraries.singleWhere((lib) =>
         lib.uri.toString().startsWith('dart:core')));
   }
 
@@ skipping 37 matching lines @@
 
     _comment = _commentToHtml();
     if (_comment.isEmpty) {
       _comment = _mdnComment();
     }
     return _comment;
   }
 
   set comment(x) => _comment = x;
 
-  String get name => mirror.simpleName;
+  String get name => dart2js_util.nameOf(mirror);
 
   MirrorBased get owner => new DummyMirror(mirror.owner);
 
   /// Generates MDN comments from database.json.
   String _mdnComment() {
     //Check if MDN is loaded.
     if (_mdn == null) {
       // Reading in MDN related json file.
       var root = _Generator._rootDirectory;
       var mdnPath = path.join(root, 'utils/apidoc/mdn/database.json');
       _mdn = JSON.decode(new File(mdnPath).readAsStringSync());
     }
     // TODO: refactor OOP
     if (this is Library) return '';
     var domAnnotation = this.annotations.firstWhere(
-        (e) => e.mirror.qualifiedName == 'metadata.DomName',
+        (e) => dart2js_util.qualifiedNameOf(e.mirror) == 'metadata.DomName',
         orElse: () => null);
     if (domAnnotation == null) return '';
     var domName = domAnnotation.parameters.single;
     var parts = domName.split('.');
     if (parts.length == 2) return _mdnMemberComment(parts[0], parts[1]);
     if (parts.length == 1) return _mdnTypeComment(parts[0]);
   }
 
   /// Generates the MDN Comment for variables and method DOM elements.
   String _mdnMemberComment(String type, String member) {
@@ skipping 66 matching lines @@
     commentText = commentText == null ? '' :
         markdown.markdownToHtml(commentText.trim(), linkResolver: linkResolver,
             inlineSyntaxes: _MARKDOWN_SYNTAXES);
     return commentText;
   }
 
   /// Returns a map of [Variable] objects constructed from [mirrorMap].
   /// The optional parameter [containingLibrary] is contains data for variables
   /// defined at the top level of a library (potentially for exporting
   /// purposes).
-  Map<String, Variable> _createVariables(Map<String, VariableMirror> mirrorMap,
+  Map<String, Variable> _createVariables(Iterable<VariableMirror> mirrors,
       Indexable owner) {
     var data = {};
     // TODO(janicejl): When map to map feature is created, replace the below
     // with a filter. Issue(#9590).
-    mirrorMap.forEach((String mirrorName, VariableMirror mirror) {
+    mirrors.forEach((VariableMirror mirror) {
       if (_Generator._includePrivate || !_isHidden(mirror)) {
+        var mirrorName = dart2js_util.nameOf(mirror);
         var variable = new Variable(mirrorName, mirror, owner);
         entityMap[variable.docName] = variable;
         data[mirrorName] = entityMap[variable.docName];
       }
     });
     return data;
   }
 
   /// Returns a map of [Method] objects constructed from [mirrorMap].
   /// The optional parameter [containingLibrary] is contains data for variables
   /// defined at the top level of a library (potentially for exporting
   /// purposes).
-  Map<String, Method> _createMethods(Map<String, MethodMirror> mirrorMap,
+  Map<String, Method> _createMethods(Iterable<MethodMirror> mirrors,
       Indexable owner) {
     var group = new Map<String, Method>();
-    mirrorMap.forEach((String mirrorName, MethodMirror mirror) {
+    mirrors.forEach((MethodMirror mirror) {
       if (_Generator._includePrivate || !mirror.isPrivate) {
         var method = new Method(mirror, owner);
         entityMap[method.docName] = method;
-        group[mirror.simpleName] = method;
+        group[dart2js_util.nameOf(mirror)] = method;
       }
     });
     return group;
   }
 
   /// Returns a map of [Parameter] objects constructed from [mirrorList].
   Map<String, Parameter> _createParameters(List<ParameterMirror> mirrorList,
       Indexable owner) {
     var data = {};
     mirrorList.forEach((ParameterMirror mirror) {
-      data[mirror.simpleName] = new Parameter(mirror, _getOwningLibrary(owner));
+      data[dart2js_util.nameOf(mirror)] =
+          new Parameter(mirror, _getOwningLibrary(owner));
     });
     return data;
   }
 
   /// Returns a map of [Generic] objects constructed from the class mirror.
-  Map<String, Generic> _createGenerics(ClassMirror mirror) {
+  Map<String, Generic> _createGenerics(TypeMirror mirror) {
     return new Map.fromIterable(mirror.typeVariables,
         key: (e) => e.toString(),
         value: (e) => new Generic(e));
   }
 
   /// Return an informative [Object.toString] for debugging.
   String toString() => "${super.toString()}(${name.toString()})";
 
   /// Return a map representation of this type.
   Map toMap() {}
@@ skipping 13 matching lines @@
     }
   }
 
   /// Returns true if a library name starts with an underscore, and false
   /// otherwise.
   ///
   /// An example that starts with _ is _js_helper.
   /// An example that contains ._ is dart._collection.dev
   // This is because LibraryMirror.isPrivate returns `false` all the time.
   bool _isLibraryPrivate(LibraryMirror mirror) {
-    var sdkLibrary = LIBRARIES[mirror.simpleName];
+    var sdkLibrary = LIBRARIES[dart2js_util.nameOf(mirror)];
     if (sdkLibrary != null) {
       return !sdkLibrary.documented;
-    } else if (mirror.simpleName.startsWith('_') ||
-        mirror.simpleName.contains('._')) {
+    } else if (dart2js_util.nameOf(mirror).startsWith('_') ||
+        dart2js_util.nameOf(mirror).contains('._')) {
       return true;
     }
     return false;
   }
 
   ////// Top level resolution functions
   /// Converts all [foo] references in comments to <a>libraryName.foo</a>.
   static markdown.Node globalFixReference(String name) {
     // Attempt the look up the whole name up in the scope.
     String elementName = _findElementInScope(name, '');
@@ skipping 165 matching lines @@
   factory Library(LibraryMirror mirror) {
     var library = getDocgenObject(mirror);
     if (library is DummyMirror) {
       library = new Library._(mirror);
     }
     return library;
   }
 
   Library._(LibraryMirror libraryMirror) : super(libraryMirror) {
     var exported = _calcExportedItems(libraryMirror);
-    var exportedClasses = exported['classes']..addAll(libraryMirror.classes);
+    var exportedClasses = _addAll(exported['classes'],
+        dart2js_util.typesOf(libraryMirror.declarations));
     _findPackage(mirror);
     classes = {};
     typedefs = {};
     errors = {};
-    exportedClasses.forEach((String mirrorName, ClassMirror classMirror) {
-        if (classMirror.isTypedef) {
+    exportedClasses.forEach((String mirrorName, TypeMirror mirror) {
+        if (mirror is TypedefMirror) {
           // This is actually a Dart2jsTypedefMirror, and it does define value,
           // but we don't have visibility to that type.
-          var mirror = classMirror;
           if (_Generator._includePrivate || !mirror.isPrivate) {
             entityMap[getDocgenObject(mirror).docName] =
                 new Typedef(mirror, this);
-            typedefs[mirror.simpleName] =
+            typedefs[dart2js_util.nameOf(mirror)] =
                 entityMap[getDocgenObject(mirror).docName];
           }
-        } else {
-          var clazz = new Class(classMirror, this);
+        } else if (mirror is ClassMirror) {
+          var clazz = new Class(mirror, this);
 
           if (clazz.isError()) {
-            errors[classMirror.simpleName] = clazz;
-          } else if (classMirror.isClass) {
-            classes[classMirror.simpleName] = clazz;
+            errors[dart2js_util.nameOf(mirror)] = clazz;
           } else {
-            throw new ArgumentError(
-                '${classMirror.simpleName} - no class type match. ');
+            classes[dart2js_util.nameOf(mirror)] = clazz;
           }
+        } else {
+          throw new ArgumentError(
+              '${dart2js_util.nameOf(mirror)} - no class type match. ');
         }
     });
-    this.functions =  _createMethods(exported['methods']
-      ..addAll(libraryMirror.functions), this);
-    this.variables = _createVariables(exported['variables']
-      ..addAll(libraryMirror.variables), this);
+    this.functions = _createMethods(_addAll(exported['methods'],
+        dart2js_util.methodsOf(libraryMirror.declarations)).values, this);
+    this.variables = _createVariables(_addAll(exported['variables'],
+        dart2js_util.variablesOf(libraryMirror.declarations)).values, this);
   }
 
   /// Look for the specified name starting with the current member, and
   /// progressively working outward to the current library scope.
   String findElementInScope(String name) {
     var lookupFunc = Indexable.determineLookupFunc(name);
     var libraryScope = lookupFunc(mirror, name);
     if (libraryScope != null) {
       var result = getDocgenObject(libraryScope, this);
       if (result is DummyMirror) return packagePrefix + result.docName;
       return result.packagePrefix + result.docName;
     }
     return super.findElementInScope(name);
   }
 
+  /// Helper that maps [mirrors] to their simple name in map.
+  Map _addAll(Map map, Iterable<DeclarationMirror> mirrors) {
+    for (var mirror in mirrors) {
+      map[dart2js_util.nameOf(mirror)] = mirror;
+    }
+    return map;
+  }
+
   /// For a library's [mirror], determine the name of the package (if any) we
   /// believe it came from (because of its file URI).
   ///
   /// If no package could be determined, we return an empty string.
   String _findPackage(LibraryMirror mirror) {
     if (mirror == null) return '';
     if (hasBeenCheckedForPackage) return packageName;
     hasBeenCheckedForPackage = true;
     if (mirror.uri.scheme != 'file') return '';
     var filePath = mirror.uri.toFilePath();
@@ skipping 43 matching lines @@
     var basic = super.previewMap;
     basic['packageName'] = packageName;
     if (packageIntro != null) {
       basic['packageIntro'] = packageIntro;
     }
     return basic;
   }
 
   String get name => docName;
 
-  String get docName => mirror.qualifiedName.replaceAll('.','-');
+  String get docName {
+    return dart2js_util.qualifiedNameOf(mirror).replaceAll('.','-');
+  }
 
   /// For the given library determine what items (if any) are exported.
   ///
   /// Returns a Map with three keys: "classes", "methods", and "variables" the
   /// values of which point to a map of exported name identifiers with values
   /// corresponding to the actual DeclarationMirror.
   Map<String, Map<String, DeclarationMirror>> _calcExportedItems(
       LibraryMirror library) {
     var exports = {};
     exports['classes'] = {};
     exports['methods'] = {};
     exports['variables'] = {};
 
     // Determine the classes, variables and methods that are exported for a
     // specific dependency.
     _populateExports(LibraryDependencyMirror export, bool showExport) {
       if (!showExport) {
         // Add all items, and then remove the hidden ones.
         // Ex: "export foo hide bar"
-        exports['classes'].addAll(export.targetLibrary.classes);
-        exports['methods'].addAll(export.targetLibrary.functions);
-        exports['variables'].addAll(export.targetLibrary.variables);
+        _addAll(exports['classes'],
+            dart2js_util.typesOf(export.targetLibrary.declarations));
+        _addAll(exports['methods'],
+            dart2js_util.methodsOf(export.targetLibrary.declarations));
+        _addAll(exports['variables'],
+            dart2js_util.variablesOf(export.targetLibrary.declarations));
       }
       for (CombinatorMirror combinator in export.combinators) {
         for (String identifier in combinator.identifiers) {
           DeclarationMirror declaration =
               export.targetLibrary.lookupInScope(identifier);
           if (declaration == null) {
             // Technically this should be a bug, but some of our packages
             // (such as the polymer package) are curently broken in this
             // way, so we just produce a warning.
             print('Warning identifier $identifier not found in library '
-                '${export.targetLibrary.qualifiedName}');
+                '${dart2js_util.qualifiedNameOf(export.targetLibrary)}');
           } else {
             var subMap = exports['classes'];
             if (declaration is MethodMirror) {
               subMap = exports['methods'];
             } else if (declaration is VariableMirror) {
               subMap = exports['variables'];
             }
             if (showExport) {
               subMap[identifier] = declaration;
             } else {
@@ skipping 110 matching lines @@
     inheritedVariables = {};
 
     // The reason we do this madness is the superclass and interface owners may
     // not be this class's owner!! Example: BaseClient in http pkg.
     var superinterfaces = classMirror.superinterfaces.map(
         (interface) => new Class._possiblyDifferentOwner(interface, owner));
     this.superclass = classMirror.superclass == null? null :
         new Class._possiblyDifferentOwner(classMirror.superclass, owner);
 
     interfaces = superinterfaces.toList();
-    variables = _createVariables(classMirror.variables, this);
-    methods = _createMethods(classMirror.methods, this);
+    variables = _createVariables(
+        dart2js_util.variablesOf(classMirror.declarations), this);
+    methods = _createMethods(
+        dart2js_util.methodsOf(classMirror.declarations), this);
     annotations = _createAnnotations(classMirror, _getOwningLibrary(owner));
     generics = _createGenerics(classMirror);
     isAbstract = classMirror.isAbstract;
     inheritedMethods = new Map<String, Method>();
 
     // Tell all superclasses that you are a subclass, unless you are not
     // visible or an intermediary mixin class.
     if (!classMirror.isNameSynthetic && _isVisible) {
       parentChain().forEach((parentClass) {
           parentClass.addSubclass(this);
@@ skipping 125 matching lines @@
     // can get for their inherited versions the comments.
     methods.forEach((qualifiedName, method) {
       if (!method.mirror.isConstructor) method.ensureCommentFor(method);
     });
   }
 
   /// If a class extends a private superclass, find the closest public
   /// superclass of the private superclass.
   String validSuperclass() {
     if (superclass == null) return 'dart.core.Object';
-    if (superclass._isVisible) return superclass.qualifiedName;
+    if (superclass._isVisible) return dart2js_util.qualifiedNameOf(superclass);
     return superclass.validSuperclass();
   }
 
   /// Generates a map describing the [Class] object.
   Map toMap() => {
     'name': name,
     'qualifiedName': qualifiedName,
     'comment': comment,
     'isAbstract' : isAbstract,
     'superclass': validSuperclass(),
@@ skipping 28 matching lines @@
   factory Typedef(TypedefMirror mirror, Library owningLibrary) {
     var aTypedef = getDocgenObject(mirror, owningLibrary);
     if (aTypedef is DummyMirror) {
       aTypedef = new Typedef._(mirror, owningLibrary);
     }
     return aTypedef;
   }
 
   Typedef._(TypedefMirror mirror, Library owningLibrary) : super(mirror) {
     owner = owningLibrary;
-    returnType = getDocgenObject(mirror.value.returnType).docName;
+    returnType = getDocgenObject(mirror.referent.returnType).docName;
     generics = _createGenerics(mirror);
-    parameters = _createParameters(mirror.value.parameters, owningLibrary);
+    parameters = _createParameters(mirror.referent.parameters, owningLibrary);
     annotations = _createAnnotations(mirror, owningLibrary);
   }
 
   Map toMap() => {
     'name': name,
     'qualifiedName': qualifiedName,
     'comment': comment,
     'return': returnType,
     'parameters': recurseMap(parameters),
     'annotations': annotations.map((a) => a.toMap()).toList(),
@@ skipping 159 matching lines @@
       var result = owner.findElementInScope(name);
       if (result != null) return result;
     }
     return super.findElementInScope(name);
   }
 
   String get docName {
     if ((mirror as MethodMirror).isConstructor) {
       // We name constructors specially -- including the class name again and a
       // "-" to separate the constructor from its name (if any).
-      return '${owner.docName}.${mirror.owner.simpleName}-${mirror.simpleName}';
+      return '${owner.docName}.${dart2js_util.nameOf(mirror.owner)}-'
+             '${dart2js_util.nameOf(mirror)}';
     }
     return super.docName;
   }
 
   String get fileName => packagePrefix + docName;
 
   /// Makes sure that the method with an inherited equivalent have comments.
   void ensureCommentFor(Method inheritedMethod) {
     if (comment.isNotEmpty) return;
 
@@ skipping 54 matching lines @@
   String name;
   bool isOptional;
   bool isNamed;
   bool hasDefaultValue;
   Type type;
   String defaultValue;
   /// List of the meta annotations on the parameter.
   List<Annotation> annotations;
 
   Parameter(this.mirror, Library owningLibrary) {
-    name = mirror.simpleName;
+    name = dart2js_util.nameOf(mirror);
     isOptional = mirror.isOptional;
     isNamed = mirror.isNamed;
     hasDefaultValue = mirror.hasDefaultValue;
-    defaultValue = mirror.defaultValue;
+    defaultValue = '${mirror.defaultValue}';
     type = new Type(mirror.type, owningLibrary);
     annotations = _createAnnotations(mirror, owningLibrary);
   }
 
   /// Generates a map describing the [Parameter] object.
   Map toMap() => {
     'name': name,
     'optional': isOptional.toString(),
     'named': isNamed.toString(),
     'default': hasDefaultValue.toString(),
     'type': new List.filled(1, type.toMap()),
     'value': defaultValue,
     'annotations': annotations.map((a) => a.toMap()).toList()
   };
 }
 
 /// A Docgen wrapper around the dart2js mirror for a generic type.
 class Generic extends MirrorBased {
   TypeVariableMirror mirror;
   Generic(this.mirror);
   Map toMap() => {
     'name': mirror.toString(),
-    'type': mirror.upperBound.qualifiedName
+    'type': dart2js_util.qualifiedNameOf(mirror.upperBound)
   };
 }
 
 /// Docgen wrapper around the mirror for a return type, and/or its generic
 /// type parameters.
 ///
 /// Return types are of a form [outer]<[inner]>.
 /// If there is no [inner] part, [inner] will be an empty list.
 ///
 /// For example:
@@ skipping 20 matching lines @@
 ///                    - "outer" : "dart-core.int"
 ///                      "inner" :
 class Type extends MirrorBased {
   TypeMirror mirror;
   MirrorBased owningLibrary;
 
   Type(this.mirror, this.owningLibrary);
 
   /// Returns a list of [Type] objects constructed from TypeMirrors.
   List<Type> _createTypeGenerics(TypeMirror mirror) {
-    if (mirror is ClassMirror && !mirror.isTypedef) {
+    if (mirror is ClassMirror) {
       var innerList = [];
       mirror.typeArguments.forEach((e) {
         innerList.add(new Type(e, owningLibrary));
       });
       return innerList;
     }
     return [];
   }
 
   Map toMap() => {
     // We may encounter types whose corresponding library has not been
     // processed yet, so look up with the owningLibrary at the last moment.
     'outer': getDocgenObject(mirror, owningLibrary).docName,
     'inner': _createTypeGenerics(mirror).map((e) => e.toMap()).toList(),
   };
 }
 
 /// Holds the name of the annotation, and its parameters.
 class Annotation extends MirrorBased {
   List<String> parameters;
   /// The class of this annotation.
   ClassMirror mirror;
   Library owningLibrary;
 
   Annotation(InstanceMirror originalMirror, this.owningLibrary) {
     mirror = originalMirror.type;
-    parameters = originalMirror.type.variables.values
+    parameters = dart2js_util.variablesOf(originalMirror.type.declarations)
         .where((e) => e.isFinal)
         .map((e) => originalMirror.getField(e.simpleName).reflectee)
         .where((e) => e != null)
         .toList();
   }
 
   Map toMap() => {
     'name': getDocgenObject(mirror, owningLibrary).docName,
     'parameters': parameters
   };
 }