Make docgen able to generate pkg docs and save the package names

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'
     as dart2js;
 import '../../../sdk/lib/_internal/compiler/implementation/mirrors/mirrors.dart';
 import '../../../sdk/lib/_internal/compiler/implementation/source_file_provider.dart';
 import '../../../sdk/lib/_internal/libraries.dart';
 
 var logger = new Logger('Docgen');
 
 const String USAGE = 'Usage: dart docgen.dart [OPTIONS] [fooDir/barFile]';
 
 
-List<String> validAnnotations = const ['metadata.Experimental', 
-    'metadata.DomName', 'metadata.Deprecated', 'metadata.Unstable', 
+List<String> validAnnotations = const ['metadata.Experimental',
+    'metadata.DomName', 'metadata.Deprecated', 'metadata.Unstable',
     'meta.deprecated', 'metadata.SupportedBrowser'];
 
 /// Current library being documented to be used for comment links.
 LibraryMirror _currentLibrary;
 
 /// Current class being documented to be used for comment links.
 ClassMirror _currentClass;
 
 /// Current member being documented to be used for comment links.
 MemberMirror _currentMember;
 
 /// Support for [:foo:]-style code comments to the markdown parser.
 List<markdown.InlineSyntax> markdownSyntaxes =
   [new markdown.CodeSyntax(r'\[:\s?((?:.|\n)*?)\s?:\]')];
 
 /// Resolves reference links in doc comments.
 markdown.Resolver linkResolver;
 
 /// Index of all indexable items. This also ensures that no class is
 /// created more than once.
 Map<String, Indexable> entityMap = new Map<String, Indexable>();
 
 /// This is set from the command line arguments flag --include-private
 bool _includePrivate = false;
 
-// TODO(janicejl): Make MDN content generic or pluggable. Maybe move 
+// 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. 
+/// Map of all the comments for dom elements from MDN.
 Map _mdn;
 
 /**
  * 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.
@@ skipping 21 matching lines @@
   }
   logger.info('Package Root: ${packageRoot}');
   linkResolver = (name) =>
       fixReference(name, _currentLibrary, _currentClass, _currentMember);
 
   return getMirrorSystem(files, packageRoot: packageRoot, parseSdk: parseSdk)
     .then((MirrorSystem mirrorSystem) {
       if (mirrorSystem.libraries.isEmpty) {
         throw new StateError('No library mirrors were created.');
       }
-      _documentLibraries(mirrorSystem.libraries.values,includeSdk: includeSdk,
-          outputToYaml: outputToYaml, append: append, parseSdk: parseSdk, 
+      var librariesWeAskedFor = _listLibraries(files);
+      var librariesWeGot = mirrorSystem.libraries.values.where((each)
+          => each.uri.scheme == 'file');
+      var sdkLibraries = mirrorSystem.libraries.values.where(
+          (each) => each.uri.scheme == 'dart');
+      var librariesWeGotByPath = new Map.fromIterables(
+          librariesWeGot.map((each) => each.uri.toFilePath()),
+          librariesWeGot);
+      var librariesToDocument = librariesWeAskedFor.map((each) =>
+        librariesWeGotByPath
+            .putIfAbsent(each, () => throw "Missing library $each")).toList();
+      librariesToDocument.addAll((includeSdk || parseSdk) ? sdkLibraries : []);
+      _documentLibraries(librariesToDocument, includeSdk: includeSdk,
+          outputToYaml: outputToYaml, append: append, parseSdk: parseSdk,
           introduction: introduction);
-
       return true;
     });
 }
 
+/// For a [library] and its corresponding [mirror] that we believe come
+/// from a package (because it has a file
+/// URI) look for the package name and set it on [library].
+_findPackage(Library library, LibraryMirror mirror) {
+    if (mirror.uri.scheme != 'file') return;
+    var filePath = mirror.uri.toFilePath();
+    // We assume that we are documenting only libraries under package/lib
+    var rootdir = path.dirname((path.dirname(filePath)));
+    var pubspec = path.join(rootdir, 'pubspec.yaml');
+    library.packageName = _packageName(pubspec);
+}
+
 List<String> _listLibraries(List<String> args) {
-  if (args.length != 1) throw new UnsupportedError(USAGE);
   var libraries = new List<String>();
-  var type = FileSystemEntity.typeSync(args[0]);
+  for (var arg in args) {
+    var type = FileSystemEntity.typeSync(arg);
 
-  if (type == FileSystemEntityType.FILE) {
-    if (args[0].endsWith('.dart')) {
-      libraries.add(path.absolute(args[0]));
-      logger.info('Added to libraries: ${libraries.last}');
+    if (type == FileSystemEntityType.FILE) {
+      if (arg.endsWith('.dart')) {
+        libraries.add(path.absolute(arg));
+        logger.info('Added to libraries: ${libraries.last}');
+      }
+    } else {
+      libraries.addAll(_listDartFromDir(arg));
     }
-  } else {
-    libraries.addAll(_listDartFromDir(args[0]));
   }
   return libraries;
 }
 
 List<String> _listDartFromDir(String args) {
   var libraries = [];
   // To avoid anaylzing package files twice, only files with paths not
   // containing '/packages' will be added. The only exception is if the file to
   // analyze already has a '/package' in its path.
   var files = listDir(args, recursive: true).where((f) => f.endsWith('.dart') &&
       (!f.contains('${path.separator}packages') ||
           args.contains('${path.separator}packages'))).toList();
-  
-  files.forEach((f) {
-    // Only add the file if it does not contain 'part of' 
-    // TODO(janicejl): Remove when Issue(12406) is resolved.
-    var contents = new File(f).readAsStringSync();
-    if (!(contents.contains(new RegExp('\npart of ')) || 
-        contents.startsWith(new RegExp('part of ')))) {
-      libraries.add(f);
-      logger.info('Added to libraries: $f');
+
+  files.forEach((String f) {
+    // Only include libraries at the top level of "lib"
+    if (path.basename(path.dirname(f)) == 'lib') {
+      // Only add the file if it does not contain 'part of'
+      // TODO(janicejl): Remove when Issue(12406) is resolved.
+      var contents = new File(f).readAsStringSync();
+      if (!(contents.contains(new RegExp('\npart of ')) ||
+          contents.startsWith(new RegExp('part of ')))) {
+        libraries.add(f);
+        logger.info('Added to libraries: $f');
+      }
     }
   });
   return libraries;
 }
 
 String _findPackageRoot(String directory) {
   var files = listDir(directory, recursive: true);
   // Return '' means that there was no pubspec.yaml and therefor no packageRoot.
   String packageRoot = files.firstWhere((f) =>
       f.endsWith('${path.separator}pubspec.yaml'), orElse: () => '');
   if (packageRoot != '') {
     packageRoot = path.join(path.dirname(packageRoot), 'packages');
   }
   return packageRoot;
 }
 
+/**
+ * Read a pubspec and return the library name.
+ */
+String _packageName(String pubspecName) {
+  File pubspec = new File(pubspecName);
+  if (!pubspec.existsSync()) return '';
+  var contents = pubspec.readAsStringSync();
+  var spec = loadYaml(contents);
+  return spec["name"];
+}
+
 List<String> _listSdk() {
   var sdk = new List<String>();
   LIBRARIES.forEach((String name, LibraryInfo info) {
     if (info.documented) {
       sdk.add('dart:$name');
       logger.info('Add to SDK: ${sdk.last}');
     }
   });
   return sdk;
 }
@@ skipping 14 matching lines @@
 }
 
 /**
  * Analyzes set of libraries and provides a mirror system which can be used
  * for static inspection of the source code.
  */
 Future<MirrorSystem> _analyzeLibraries(List<String> libraries,
       String libraryRoot, {String packageRoot}) {
   SourceFileProvider provider = new CompilerSourceFileProvider();
   api.DiagnosticHandler diagnosticHandler =
-        new FormattingDiagnosticHandler(provider).diagnosticHandler;
+      (new FormattingDiagnosticHandler(provider)
+        ..showHints = false
+        ..showWarnings = false)
+          .diagnosticHandler;
   Uri libraryUri = new Uri(scheme: 'file', path: appendSlash(libraryRoot));
   Uri packageUri = null;
   if (packageRoot != null) {
     packageUri = new Uri(scheme: 'file', path: appendSlash(packageRoot));
   }
   List<Uri> librariesUri = <Uri>[];
   libraries.forEach((library) {
     librariesUri.add(currentDirectory.resolve(library));
   });
   return dart2js.analyze(librariesUri, libraryUri, packageUri,
       provider.readStringFromUri, diagnosticHandler,
       ['--preserve-comments', '--categories=Client,Server'])
       ..catchError((error) {
         logger.severe('Error: Failed to create mirror system. ');
         // TODO(janicejl): Use the stack trace package when bug is resolved.
         // 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> libs, {bool includeSdk: false,
-    bool outputToYaml: true, bool append: false, bool parseSdk: false, 
+    bool outputToYaml: true, bool append: false, bool parseSdk: false,
     String introduction: ''}) {
   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);
       entityMap[library.qualifiedName] = library;
     }
   });
   // After everything is created, do a pass through all classes to make sure no
   // intermediate classes created by mixins are included.
   entityMap.values.where((e) => e is Class).forEach((c) => c.makeValid());
   // Everything is a subclass of Object, therefore empty the list to avoid a
   // giant list of subclasses to be printed out.
   if (parseSdk) entityMap['dart.core.Object'].subclasses.clear();
 
   var filteredEntities = entityMap.values.where(_isVisible);
-  
-  // Outputs a JSON file with all libraries and their preview comments. 
+
+  // Outputs a JSON file with all libraries and their preview comments.
   // This will help the viewer know what libraries are available to read in.
   var libraryMap;
   if (append) {
     var docsDir = listDir('docs');
     if (!docsDir.contains('docs/library_list.json')) {
       throw new StateError('No library_list.json');
     }
     libraryMap =
         JSON.decode(new File('docs/library_list.json').readAsStringSync());
     libraryMap['libraries'].addAll(filteredEntities
         .where((e) => e is Library)
         .map((e) => e.previewMap));
     if (introduction.isNotEmpty) {
       var intro = libraryMap['introduction'];
       if (intro.isNotEmpty) intro += '<br/><br/>';
       intro += markdown.markdownToHtml(
-          new File(introduction).readAsStringSync(), 
+          new File(introduction).readAsStringSync(),
               linkResolver: linkResolver, inlineSyntaxes: markdownSyntaxes);
       libraryMap['introduction'] = intro;
     }
     outputToYaml = libraryMap['filetype'] == 'yaml';
   } else {
     libraryMap = {
-      'libraries' : filteredEntities.where((e) => 
+      'libraries' : filteredEntities.where((e) =>
           e is Library).map((e) => e.previewMap).toList(),
-      'introduction' : introduction == '' ? 
+      'introduction' : introduction == '' ?
           '' : markdown.markdownToHtml(new File(introduction)
-              .readAsStringSync(), linkResolver: linkResolver, 
-                  inlineSyntaxes: markdownSyntaxes), 
+              .readAsStringSync(), linkResolver: linkResolver,
+                  inlineSyntaxes: markdownSyntaxes),
       'filetype' : outputToYaml ? 'yaml' : 'json'
     };
   }
   _writeToFile(JSON.encode(libraryMap), 'library_list.json');
   // Output libraries and classes to file after all information is generated.
   filteredEntities.where((e) => e is Class || e is Library).forEach((output) {
     _writeIndexableToFile(output, outputToYaml);
   });
   // Outputs all the qualified names documented with their type.
   // This will help generate search results.
-  _writeToFile(filteredEntities.map((e) => 
-      '${e.qualifiedName} ${e.typeName}').join('\n'),
+  _writeToFile(filteredEntities.map((e) =>
+      '${e.qualifiedName} ${e.typeName}').join('\n') + '\n',
       'index.txt', append: append);
+  var index = new Map.fromIterables(
+      filteredEntities.map((e) => e.qualifiedName),
+      filteredEntities.map((e) => e.typeName));

[terry, 2013/10/24 14:17:30]

Minor point, I'm sure it's not a perf issue now, but one visit thru the map is
probably more efficient then iterating twice once for keys and once for values.

var index = {}'
filteredEntities.map((e) => index[e.qualifiedName] = e.typeName;)

+  if (append) {
+    var previousIndex =
+        JSON.decode(new File('docs/index.json').readAsStringSync());
+    index.addAll(previousIndex);
+  }
+  _writeToFile(JSON.encode(index), 'index.json');
 }
 
 Library generateLibrary(dart2js.Dart2JsLibraryMirror library) {
   _currentLibrary = library;
   var result = new Library(library.qualifiedName, _commentToHtml(library),
       _variables(library.variables),
       _methods(library.functions),
       _classes(library.classes), _isHidden(library));
+  _findPackage(result, library);
   logger.fine('Generated library for ${result.name}');
   return result;
 }
 
 void _writeIndexableToFile(Indexable result, bool outputToYaml) {
   if (outputToYaml) {
     _writeToFile(getYamlString(result.toMap()), '${result.qualifiedName}.yaml');
   } else {
     _writeToFile(JSON.encode(result.toMap()), '${result.qualifiedName}.json');
   }
 }
 
 /**
  * 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];
   if (sdkLibrary != null) {
     return !sdkLibrary.documented;
-  } else if (mirror.simpleName.startsWith('_') || 
+  } else if (mirror.simpleName.startsWith('_') ||
       mirror.simpleName.contains('._')) {
     return true;
   }
   return false;
 }
 
 /**
  * A declaration is private if itself is private, or the owner is private.
  */
 // Issue(12202) - A declaration is public even if it's owner is private.
@@ skipping 51 matching lines @@
     }
   });
 
   commentText = commentText == null ? '' :
       markdown.markdownToHtml(commentText.trim(), linkResolver: linkResolver,
           inlineSyntaxes: markdownSyntaxes);
   return commentText;
 }
 
 /**
- * Generates MDN comments from database.json. 
+ * Generates MDN comments from database.json.
  */
 void _mdnComment(Indexable item) {
-  //Check if MDN is loaded. 
+  //Check if MDN is loaded.
   if (_mdn == null) {
-    // Reading in MDN related json file. 
+    // Reading in MDN related json file.
     var mdnDir = path.join(path.dirname(path.dirname(path.dirname(path.dirname(
         path.absolute(new Options().script))))), 'utils', 'apidoc', 'mdn');
     _mdn = JSON.decode(new File(path.join(mdnDir, 'database.json'))
         .readAsStringSync());
   }
   if (item.comment.isNotEmpty) return;
   var domAnnotation = item.annotations.firstWhere(
       (e) => e.qualifiedName == 'metadata.DomName', orElse: () => null);
   if (domAnnotation == null) return;
   var domName = domAnnotation.parameters.single;
   var parts = domName.split('.');
   if (parts.length == 2) item.comment = _mdnMemberComment(parts[0], parts[1]);
   if (parts.length == 1) item.comment = _mdnTypeComment(parts[0]);
 }
 
 /**
- * Generates the MDN Comment for variables and method DOM elements. 
+ * Generates the MDN Comment for variables and method DOM elements.
  */
 String _mdnMemberComment(String type, String member) {
   var mdnType = _mdn[type];
   if (mdnType == null) return '';
-  var mdnMember = mdnType['members'].firstWhere((e) => e['name'] == member, 
+  var mdnMember = mdnType['members'].firstWhere((e) => e['name'] == member,
       orElse: () => null);
   if (mdnMember == null) return '';
   if (mdnMember['help'] == null || mdnMember['help'] == '') return '';
   if (mdnMember['url'] == null) return '';
   return _htmlMdn(mdnMember['help'], mdnMember['url']);
 }
 
 /**
- * Generates the MDN Comment for class DOM elements. 
+ * Generates the MDN Comment for class DOM elements.
  */
 String _mdnTypeComment(String type) {
   var mdnType = _mdn[type];
   if (mdnType == null) return '';
   if (mdnType['summary'] == null || mdnType['summary'] == "") return '';
   if (mdnType['srcUrl'] == null) return '';
   return _htmlMdn(mdnType['summary'], mdnType['srcUrl']);
 }
 
 String _htmlMdn(String content, String url) {
@@ skipping 178 matching lines @@
 
   /// Documentation comment with converted markdown.
   String comment;
 
   /// Qualified Name of the owner of this Indexable Item.
   /// For Library, owner will be "";
   String owner;
 
   Indexable(this.name, this.comment, this.qualifiedName, this.isPrivate,
       this.owner);
-  
+
   /// The type of this member to be used in index.txt.
   String get typeName => '';
-  
+
   /**
    * Creates a [Map] with this [Indexable]'s name and a preview comment.
    */
   Map get previewMap {
     var finalMap = { 'name' : qualifiedName };
     if (comment != '') {
       var index = comment.indexOf('</p>');
       finalMap['preview'] = '${comment.substring(0, index)}</p>';
     }
     return finalMap;
   }
 }
 
 /**
  * A class containing contents of a Dart library.
  */
 class Library extends Indexable {
 
   /// Top-level variables in the library.
   Map<String, Variable> variables;
 
   /// Top-level functions in the library.
   MethodGroup functions;
 
   /// Classes defined within the library
   ClassGroup classes;
 
+  String packageName = '';
+
+  Map get previewMap => super.previewMap..['packageName'] = packageName;
+
   Library(String name, String comment, this.variables,
       this.functions, this.classes, bool isPrivate) : super(name, comment,
           name, isPrivate, "") {}
 
   /// Generates a map describing the [Library] object.
   Map toMap() => {
     'name': name,
     'qualifiedName': qualifiedName,
     'comment': comment,
     'variables': recurseMap(variables),
     'functions': functions.toMap(),
-    'classes': classes.toMap()
+    'classes': classes.toMap(),
+    'packageName': packageName,
   };
-  
+
   String get typeName => 'library';
 }
 
 /**
  * A class containing contents of a Dart class.
  */
 class Class extends Indexable {
 
   /// List of the names of interfaces that this class implements.
   List<Class> interfaces = [];
@@ skipping 17 matching lines @@
   Map<String, Generic> generics;
 
   Class superclass;
   bool isAbstract;
 
   /// List of the meta annotations on the class.
   List<Annotation> annotations;
 
   Class(String name, this.superclass, String comment, this.interfaces,
       this.variables, this.methods, this.annotations, this.generics,
-      String qualifiedName, bool isPrivate, String owner, this.isAbstract) 
+      String qualifiedName, bool isPrivate, String owner, this.isAbstract)
       : super(name, comment, qualifiedName, isPrivate, owner) {
     _mdnComment(this);
   }
 
   String get typeName => 'class';
-  
+
   /**
    * Returns a list of all the parent classes.
    */
   List<Class> parent() {
     var parent = superclass == null ? [] : [superclass];
     parent.addAll(interfaces);
     return parent;
   }
 
   /**
@@ skipping 16 matching lines @@
   void addSubclass(Class subclass) {
     if (!_includePrivate && isPrivate) {
       if (superclass != null) superclass.addSubclass(subclass);
       interfaces.forEach((interface) {
         interface.addSubclass(subclass);
       });
     } else {
       subclasses.add(subclass.qualifiedName);
     }
   }
-  
+
   /**
    * Check if this [Class] is an error or exception.
    */
   bool isError() {
-    if (qualifiedName == 'dart.core.Error' || 
+    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();
   }
 
   /**
@@ skipping 69 matching lines @@
       if (_includePrivate || !mirror.isPrivate) {
         entityMap[mirror.qualifiedName] = new Typedef(mirror.simpleName,
             mirror.value.returnType.qualifiedName, _commentToHtml(mirror),
             _generics(mirror), _parameters(mirror.value.parameters),
             _annotations(mirror), mirror.qualifiedName,  _isHidden(mirror),
             mirror.owner.qualifiedName);
         typedefs[mirror.simpleName] = entityMap[mirror.qualifiedName];
       }
     } else {
       var clazz = _class(mirror);
-  
+
       // Adding inherited parent variables and methods.
       clazz.parent().forEach((parent) {
         if (_isVisible(clazz)) {
           parent.addSubclass(clazz);
         }
       });
-  
+
       clazz.ensureComments();
-  
+
       if (clazz.isError()) {
         errors[mirror.simpleName] = clazz;
       } else if (mirror.isClass) {
         classes[mirror.simpleName] = clazz;
       } else {
         throw new ArgumentError('${mirror.simpleName} - no class type match. ');
       }
     }
   }
 
   /**
    * Checks if the given name is a key for any of the Class Maps.
    */
   bool containsKey(String name) {
     return classes.containsKey(name) || errors.containsKey(name);
   }
-  
+
   Map toMap() => {
     'class': classes.values.where(_isVisible)
       .map((e) => e.previewMap).toList(),
     'typedef': recurseMap(typedefs),
     'error': errors.values.where(_isVisible)
       .map((e) => e.previewMap).toList()
   };
 }
 
 class Typedef extends Indexable {
   String returnType;
 
   Map<String, Parameter> parameters;
 
   /// Generic information about the typedef.
   Map<String, Generic> generics;
 
   /// List of the meta annotations on the typedef.
   List<Annotation> annotations;
 
   Typedef(String name, this.returnType, String comment, this.generics,
       this.parameters, this.annotations,
-      String qualifiedName, bool isPrivate, String owner) 
+      String qualifiedName, bool isPrivate, String owner)
         : super(name, comment, qualifiedName, isPrivate, owner);
 
   Map toMap() => {
     'name': name,
     'qualifiedName': qualifiedName,
     'comment': comment,
     'return': returnType,
     'parameters': recurseMap(parameters),
     'annotations': annotations.map((a) => a.toMap()).toList(),
     'generics': recurseMap(generics)
   };
-  
+
   String get typeName => 'typedef';
 }
 
 /**
  * A class containing properties of a Dart variable.
  */
 class Variable extends Indexable {
 
   bool isFinal;
   bool isStatic;
@@ skipping 13 matching lines @@
   Map toMap() => {
     'name': name,
     'qualifiedName': qualifiedName,
     'comment': comment,
     'final': isFinal.toString(),
     'static': isStatic.toString(),
     'constant': isConst.toString(),
     'type': new List.filled(1, type.toMap()),
     'annotations': annotations.map((a) => a.toMap()).toList()
   };
-  
+
   String get typeName => 'property';
 }
 
 /**
  * A class containing properties of a Dart method.
  */
 class Method extends Indexable {
 
   /// Parameters for this method.
   Map<String, Parameter> parameters;
 
   bool isStatic;
   bool isAbstract;
   bool isConst;
   bool isConstructor;
   bool isGetter;
   bool isSetter;
   bool isOperator;
   Type returnType;
 
   /// Qualified name to state where the comment is inherited from.
   String commentInheritedFrom = "";
 
   /// List of the meta annotations on the method.
   List<Annotation> annotations;
 
   Method(String name, this.isStatic, this.isAbstract, this.isConst,
       this.returnType, String comment, this.parameters, this.annotations,
       String qualifiedName, bool isPrivate, String owner, this.isConstructor,
-      this.isGetter, this.isSetter, this.isOperator) 
+      this.isGetter, this.isSetter, this.isOperator)
         : super(name, comment, qualifiedName, isPrivate, owner) {
     _mdnComment(this);
   }
 
   /**
    * Makes sure that the method with an inherited equivalent have comments.
    */
   void ensureCommentFor(Method inheritedMethod) {
     if (comment.isNotEmpty) return;
     entityMap[inheritedMethod.owner].ensureComments();
     comment = inheritedMethod.comment;
     commentInheritedFrom = inheritedMethod.commentInheritedFrom == '' ?
         inheritedMethod.qualifiedName : inheritedMethod.commentInheritedFrom;
   }
 
   /// Generates a map describing the [Method] object.
   Map toMap() => {
     'name': name,
     'qualifiedName': qualifiedName,
     'comment': comment,
     'commentFrom': commentInheritedFrom,
     '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' :
     isOperator ? 'operator' : 'method';
 }
 
 /**
  * A container to categorize methods into the following groups: setters,
  * getters, constructors, operators, regular methods.
  */
 class MethodGroup {
@@ skipping 158 matching lines @@
   String qualifiedName;
   List<String> parameters;
 
   Annotation(this.qualifiedName, this.parameters);
 
   Map toMap() => {
     'name': qualifiedName,
     'parameters': parameters
   };
 }