added inherited methods and variables

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.
  *
@@ skipping 35 matching lines @@
 
 /// Current member being documented to be used for comment links.
 MemberMirror _currentMember;
 
 /// Resolves reference links in doc comments.
 markdown.Resolver linkResolver;
 
 /// Index of all the qualified names documented. 
 Set<String> qualifiedNameIndex = new Set<String>();
 
+/// Index of all the classes created. This is to ensure that no class is 
+/// created more than once. 
+Map<String, Class> classMap = new Map<String, Class>();
+
+/// Index of all the libraries that needs to be outputted after all objects are 
+/// created and updated. 
+Set<Library> libraries = new Set<Library>();
+
 /**
  * Docgen constructor initializes the link resolver for markdown parsing.
  * Also initializes the command line arguments.
  *
  * [packageRoot] is the packages directory of the directory being analyzed.
  * If [includeSdk] is `true`, then any SDK libraries explicitly imported will
  * also be documented.
  * If [parseSdk] is `true`, then all Dart SDK libraries will be documented.
  * This option is useful when only the SDK libraries are needed.
  *
@@ skipping 122 matching lines @@
         // Currently, a string is thrown when it fails to create a mirror
         // system, and it is not possible to use the stack trace. BUG(#11622)
         // To avoid printing the stack trace.
         exit(1);
       });
 }
 
 /**
  * Creates documentation for filtered libraries.
  */
-void _documentLibraries(List<LibraryMirror> libraries,
+void _documentLibraries(List<LibraryMirror> libs,
     {bool includeSdk:false, bool includePrivate:false, bool
      outputToYaml:true}) {
-  libraries.forEach((lib) {
+  libs.forEach((lib) {
     // Files belonging to the SDK have a uri that begins with 'dart:'.
     if (includeSdk || !lib.uri.toString().startsWith('dart:')) {
       var library = generateLibrary(lib, includePrivate: includePrivate);
-      _writeLibraryToFile(library, outputToYaml);
+      libraries.add(library);
     }
   });
+  libraries.forEach((lib) => _writeLibraryToFile(lib, outputToYaml));
   // Outputs a text file with a list of files available after creating all
   // the libraries. This will help the viewer know what files are available
   // to read in.
   _writeToFile(listDir('docs').join('\n').replaceAll('docs/', ''),
       'library_list.txt');
   // Outputs all the qualified names documented. This will help generate search
   // results. 
   _writeToFile(qualifiedNameIndex.join('\n'), 'index.txt');
 }
 
 Library generateLibrary(dart2js.Dart2JsLibraryMirror library,
   {bool includePrivate:false}) {
   _currentLibrary = library;
   var result = new Library(library.qualifiedName, _getComment(library),
       _getVariables(library.variables, includePrivate),
       _getMethods(library.functions, includePrivate),
       _getClasses(library.classes, includePrivate));
   logger.fine('Generated library for ${result.name}');
   return result;
 }
 
 void _writeLibraryToFile(Library result, bool outputToYaml) {
   if (outputToYaml) {
     _writeToFile(getYamlString(result.toMap()), '${result.name}.yaml');
   } else {
     _writeToFile(stringify(result.toMap()), '${result.name}.json');
   }
-
 }
 
 /**
  * Returns a list of meta annotations assocated with a mirror.
  */
 List<String> _getAnnotations(DeclarationMirror mirror) {
   var annotations = mirror.metadata.where((e) =>
       e is dart2js.Dart2JsConstructedConstantMirror);
   return annotations.map((e) => e.type.qualifiedName).toList();
 }
@@ skipping 107 matching lines @@
 Map<String, Class> _getClasses(Map<String, ClassMirror> mirrorMap,
     bool includePrivate) {
   
   var abstractClasses = {};
   var classes = {};
   var typedefs = {};
   var errors = {};
   
   mirrorMap.forEach((String mirrorName, ClassMirror mirror) {    
     if (includePrivate || !mirror.isPrivate) {
+      _currentClass = mirror;
       var superclass = (mirror.superclass != null) ?
           mirror.superclass.qualifiedName : '';
       var interfaces =
           mirror.superinterfaces.map((interface) => interface.qualifiedName);
-      var clazz = new Class(mirrorName, superclass, _getComment(mirror), 
-          interfaces.toList(), _getVariables(mirror.variables, includePrivate),
-          _getMethods(mirror.methods, includePrivate),
-          _getAnnotations(mirror), _getGenerics(mirror), mirror.qualifiedName);
-      _currentClass = mirror;
+      var clazz = classMap[mirror.qualifiedName];
+      if (clazz == null) {
+        clazz = new Class(mirrorName, superclass, _getComment(mirror), 
+            interfaces.toList(), 
+            _getVariables(mirror.variables, includePrivate),
+            _getMethods(mirror.methods, includePrivate),
+            _getAnnotations(mirror), 
+            _getGenerics(mirror), mirror.qualifiedName);
+        classMap[mirror.qualifiedName] = clazz;
+      }
+      
+      // Adding inherited superclass variables and methods. 
+      if (superclass != '') {
+        var superclazz = classMap[superclass];
+        if (superclazz == null) {
+          var supersuperclass = (mirror.superclass.superclass != null) ? 
+              mirror.superclass.superclass.qualifiedName : '';
+          var superclassInterfaces = mirror.superclass.superinterfaces
+              .map((interface) => interface.qualifiedName);
+          superclazz = new Class(mirror.superclass.simpleName, supersuperclass,
+              _getComment(mirror.superclass), superclassInterfaces.toList(),
+              _getVariables(mirror.superclass.variables, includePrivate),
+              _getMethods(mirror.superclass.methods, includePrivate),
+              _getAnnotations(mirror.superclass), 
+              _getGenerics(mirror.superclass), mirror.superclass.qualifiedName);
+          classMap[mirror.superclass.qualifiedName] = superclazz;
+        }
+        superclazz.subclasses.add(clazz.qualifiedName);
+        superclazz.methods.keys.forEach((key) {
+          if (key != 'constructors') {
+            clazz.inheritedMethods[key].addAll(superclazz.methods[key]);
+          }
+        });
+      }
+      
+      // Adding inherited interface variables and methods. 
+      mirror.superinterfaces.forEach((interface) {
+        var interfaceClass = classMap[interface.qualifiedName];
+        if (interfaceClass == null) {
+          var interfaceSuperClass = (interface.superclass != null) ? 
+              interface.superclass.qualifiedName : '';
+          var interfaceInterfaces = interface.superinterfaces
+              .map((i) => i.qualifiedName);
+          interfaceClass = new Class(interface.simpleName,
+              interfaceSuperClass, _getComment(interface), 
+              interfaceInterfaces.toList(), 
+              _getVariables(interface.variables, includePrivate), 
+              _getMethods(interface.methods, includePrivate), 
+              _getAnnotations(interface), _getGenerics(interface), 
+              interface.qualifiedName);
+          classMap[interface.qualifiedName] = interfaceClass;
+        }
+        interfaceClass.subclasses.add(clazz.qualifiedName);
+        clazz.inheritedVariables.addAll(interfaceClass.variables);
+        interfaceClass.methods.keys.forEach((key) {
+          if (key != 'constructors') {
+            clazz.inheritedMethods[key].addAll(interfaceClass.methods[key]);
+          }
+        });
+      });
       
       if (isError(mirror.qualifiedName)) {
         errors[mirrorName] = clazz;
       } else if (mirror.isTypedef) {
         typedefs[mirrorName] = new Typedef(mirrorName, 
             mirror.value.returnType.qualifiedName,  _getComment(mirror), 
             _getGenerics(mirror), _getParameters(mirror.value.parameters),
             _getAnnotations(mirror), mirror.qualifiedName);
       } else if (mirror.isAbstract) {
         abstractClasses[mirrorName] = clazz;
@@ skipping 138 matching lines @@
     };
 }
 
 /**
  * A class containing contents of a Dart class.
  */
 class Class extends Indexable {
 
   /// List of the names of interfaces that this class implements.
   List<String> interfaces;
+  
+  List<String> subclasses = [];
 
   /// Top-level variables in the class.
   Map<String, Variable> variables;
+  
+  /// Inherited variables in the class.
+  Map<String, Variable> inheritedVariables = {};
 
   /// Methods in the class.
   Map<String, Map<String, Method>> methods;
   
+  /// Inherited methods in the class.
+  Map<String, Map<String, Method>> inheritedMethods = {
+         'setters': {},
+         'getters': {},
+         'constructors': {},
+         'operators': {},
+         'methods': {}
+       };
+  
   /// Generic infomation about the class. 
   Map<String, Generic> generics;
   
   String superclass;
 
   /// List of the meta annotations on the class.
   List<String> annotations;
   
   Class(String name, this.superclass, String comment, this.interfaces, 
       this.variables, this.methods, this.annotations, this.generics,
       String qualifiedName) : super(name, comment, qualifiedName) {}
 
   /// Generates a map describing the [Class] object.
   Map toMap() => {
       'name': name,
       'qualifiedname': qualifiedName,
       'comment': comment,
       'superclass': superclass,
       'implements': new List.from(interfaces),
+      'subclass': new List.from(subclasses),
       'variables': recurseMap(variables),
+      'inheritedvariables': recurseMap(inheritedVariables),
       'methods': recurseMap(methods),
+      'inheritedmethods': recurseMap(inheritedMethods),
       'annotations': new List.from(annotations),
       'generics': recurseMap(generics)
     };
 }
 
 class Typedef extends Indexable {
   String returnType;
   
   Map<String, Parameter> parameters;
   
@@ skipping 162 matching lines @@
   String outer;
   List<Type> inner;
   
   Type(this.outer, this.inner);
   
   Map toMap() => {
       'outer': outer,
       'inner': new List.from(inner.map((e) => e.toMap()))
     };
 }