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 

[Alan Knight, 2013/07/29 20:29:01]

Nit. While contemporary dictionaries seem to consider "outputted" a word, I
think just "output" is better.

[janicejl, 2013/07/30 00:41:31]

Done.

+/// 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);
     }
   });
+  // Output libraries to file after all information is generated.
+  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) {

[Alan Knight, 2013/07/29 20:29:01]

This method is getting very long, and it looks like there's some commonality
that could be factored out, e.g. creating the class here, the superclass, and
the interfaces below below seem like something could be factored out into a
method that took just a mirror and maybe a bit more..

[janicejl, 2013/07/30 00:41:31]

Done.

+        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') {

[Alan Knight, 2013/07/29 20:29:01]

This seems like it's crying out for an accessor like "instanceMethods" on Class,
or even "allNonConstructors", just to avoid this kind of manual filtering by
string.

[janicejl, 2013/07/30 00:41:31]

Done.

+            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;
+  
+  /// Names of classes that extends or implements this class. 
+  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.

[Alan Knight, 2013/07/29 20:29:01]

I'm not clear why methods in the class itself seem to be indexed just by name,
but there's an additional level of categorization on inherited methods.

+  Map<String, Map<String, Method>> inheritedMethods = {
+         'setters': {},

[Alan Knight, 2013/07/29 20:29:01]

It seems like it might be nicer if this an object, especially given the usage in
_getClasses. (Aside: I may have mentioned that I'm not fond of "get" in method
names :-)

[janicejl, 2013/07/30 00:41:31]

Done.

+         '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,

[Alan Knight, 2013/07/29 20:29:01]

I think literal maps can be indented just two.

[janicejl, 2013/07/30 00:41:31]

Done.

       '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()))
     };
 }