Fixed up some inheritance chains and improved constructor output (to be fully qualified).

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 1424 matching lines @@
     result = owner.findElementInScope(name);
     return result == null ? super.findElementInScope(name) : result;
   }
 
   markdown.Node fixReferenceWithScope(String name) => fixReference(name);
 
   String get typeName => 'class';
 
   /// Returns a list of all the parent classes.
   List<Class> parentChain() {
+    // TODO(efortuna): Seems like we can get rid of this method.
     var parent = superclass == null ? [] : [superclass];
-    parent.addAll(interfaces);
     return parent;
   }
 
   /// Add all inherited variables and methods from the provided superclass.
   /// If [_includePrivate] is true, it also adds the variables and methods from
   /// the superclass.
   void addInherited(Class superclass) {
     inheritedVariables.addAll(superclass.inheritedVariables);
     inheritedVariables.addAll(_allButStatics(superclass.variables));
     addInheritedMethod(superclass, this);
@@ skipping 268 matching lines @@
     this.parameters = _createParameters(mirror.parameters, owner);
     this.annotations = _createAnnotations(mirror, _getOwningLibrary(owner));
     this.isConstructor = mirror.isConstructor;
     this.isGetter = mirror.isGetter;
     this.isSetter = mirror.isSetter;
     this.isOperator = mirror.isOperator;
   }
 
   String get packagePrefix => owner.packagePrefix;
 
+  Method get originallyInheritedFrom => methodInheritedFrom == null ?
+      this : methodInheritedFrom.originallyInheritedFrom;
+
   markdown.Node fixReferenceWithScope(String name) => fixReference(name);
 
   /// 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 memberScope = lookupFunc(this.mirror, name);
     if (memberScope != null) {
       // do we check for a dummy mirror returned here and look up with an owner
@@ skipping 13 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 '${mirror.owner.simpleName.replaceAll(".", "_")}.'
-          '${mirror.owner.simpleName}-${mirror.simpleName}';
+      return '${owner.docName}.${mirror.owner.simpleName}-${mirror.simpleName}';
     }
     return super.docName;
   }
 
   /// Makes sure that the method with an inherited equivalent have comments.
   void ensureCommentFor(Method inheritedMethod) {
     if (comment.isNotEmpty) return;
 
     comment = inheritedMethod._commentToHtml(this);
     _unresolvedComment = inheritedMethod._unresolvedComment;
     commentInheritedFrom = inheritedMethod.commentInheritedFrom == '' ?
-        inheritedMethod.mirror.qualifiedName :
+        new DummyMirror(inheritedMethod.mirror).docName :
         inheritedMethod.commentInheritedFrom;
   }
 
   /// Generates a map describing the [Method] object.
   Map toMap() => {
     'name': name,
     'qualifiedName': qualifiedName,
     'comment': comment,
     'commentFrom': (methodInheritedFrom != null &&
         commentInheritedFrom == methodInheritedFrom.docName ? ''
         : commentInheritedFrom),
     'inheritedFrom': (methodInheritedFrom == null? '' :
-        methodInheritedFrom.docName),
+        originallyInheritedFrom.docName),
     'static': isStatic.toString(),
     'abstract': isAbstract.toString(),
     'constant': isConst.toString(),
     'return': new List.filled(1, returnType.toMap()),
     'parameters': recurseMap(parameters),
     'annotations': annotations.map((a) => a.toMap()).toList()
   };
 
   String get typeName => isConstructor ? 'constructor' :
     isGetter ? 'getter' : isSetter ? 'setter' :
@@ skipping 137 matching lines @@
         .map((e) => originalMirror.getField(e.simpleName).reflectee)
         .where((e) => e != null)
         .toList();
   }
 
   Map toMap() => {
     'name': getDocgenObject(mirror, owningLibrary).docName,
     'parameters': parameters
   };
 }