Make subclasses in packages have the right link. Sort by name.

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]
@@ skipping 886 matching lines @@
     'functions': functions.toMap(),
     'classes': classes.toMap(),
     'packageName': packageName,
     'packageIntro' : packageIntro
   };
 
   String get typeName => 'library';
 }
 
 /// A class containing contents of a Dart class.
-class Class extends Indexable {
+class Class extends Indexable implements Comparable {
 
   /// List of the names of interfaces that this class implements.
   List<Class> interfaces = [];
 
   /// Names of classes that extends or implements this class.
-  Set<String> subclasses = new Set<String>();
+  Set<Class> subclasses = new Set<Class>();
 
   /// Top-level variables in the class.
   Map<String, Variable> variables;
 
   /// Inherited variables in the class.
   Map<String, Variable> inheritedVariables = {};
 
   /// Methods in the class.
   MethodGroup methods;
 
@@ skipping 38 matching lines @@
   ///
   /// If [this] is private, it will add the subclass to the list of subclasses in
   /// the superclasses.
   void addSubclass(Class subclass) {
     if (!_includePrivate && isPrivate) {
       if (superclass != null) superclass.addSubclass(subclass);
       interfaces.forEach((interface) {
         interface.addSubclass(subclass);
       });
     } else {
-      subclasses.add(subclass.qualifiedName);
+      subclasses.add(subclass);
     }
   }
 
   /// Check if this [Class] is an error or exception.
   bool isError() {
     if (qualifiedName == 'dart-core.Error' ||
         qualifiedName == 'dart-core.Exception')
       return true;
     for (var interface in interfaces) {
       if (interface.isError()) return true;
     }
     if (superclass == null) return false;
     return superclass.isError();
   }
 
   /// Check that the class exists in the owner library.
   ///
   /// If it does not exist in the owner library, it is a mixin applciation and
   /// should be removed.
   void makeValid() {
     var library = entityMap[owner];
     if (library != null && !library.classes.containsKey(name)) {
       this.isPrivate = true;
       // Since we are now making the mixin a private class, make all elements
       // with the mixin as an owner private too.
       entityMap.values.where((e) => e.owner == qualifiedName)
         .forEach((element) => element.isPrivate = true);
       // Move the subclass up to the next public superclass
-      subclasses.forEach((subclass) => addSubclass(entityMap[subclass]));
+      subclasses.forEach((subclass) => addSubclass(subclass));
     }
   }
 
   /// Makes sure that all methods with inherited equivalents have comments.
   void ensureComments() {
     inheritedMethods.forEach((qualifiedName, inheritedMethod) {
       var method = methods[qualifiedName];
       if (method != null) method.ensureCommentFor(inheritedMethod);
     });
   }
 
   /// 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 (_isVisible(superclass)) return superclass.qualifiedName;
     return superclass.validSuperclass();
   }
 
   /// Generates a map describing the [Class] object.
   Map toMap() => {
     'name': name,
     'qualifiedName': qualifiedName,
     'comment': comment,
     'isAbstract' : isAbstract,
     'superclass': validSuperclass(),
     'implements': interfaces.where(_isVisible)
         .map((e) => e.qualifiedName).toList(),
-    'subclass': subclasses.toList(),
+    'subclass': (subclasses.toList()..sort())
+        .map((x) => x.qualifiedName).toList(),
     'variables': recurseMap(variables),
     'inheritedVariables': recurseMap(inheritedVariables),
     'methods': methods.toMap(),
     'inheritedMethods': inheritedMethods.toMap(),
     'annotations': annotations.map((a) => a.toMap()).toList(),
     'generics': recurseMap(generics)
   };
+
+  int compareTo(aClass) => name.compareTo(aClass.name);
 }
 
 /// A container to categorize classes into the following groups: abstract
 /// classes, regular classes, typedefs, and errors.
 class ClassGroup {
   Map<String, Class> classes = {};
   Map<String, Typedef> typedefs = {};
   Map<String, Class> errors = {};
 
   void addClass(ClassMirror mirror) {
@@ skipping 345 matching lines @@
 /// Remove statics from the map of inherited items before adding them.
 Map _filterStatics(Map items) {
   var result = {};
   items.forEach((name, item) {
     if (!item.isStatic) {
       result[name] = item;
     }
   });
   return result;
 }