Created an index of qualified names for libraries, classes, 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 32 matching lines @@
 
 /// Current class being documented to be used for comment links.
 ClassMirror _currentClass;
 
 /// 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>();
+
 /**
  * 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 147 matching lines @@
     if (includeSdk || !lib.uri.toString().startsWith('dart:')) {
       var library = generateLibrary(lib, includePrivate: includePrivate);
       _writeLibraryToFile(library, 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}');
@@ skipping 65 matching lines @@
 Map<String, Variable> _getVariables(Map<String, VariableMirror> mirrorMap,
     bool includePrivate) {
   var data = {};
   // TODO(janicejl): When map to map feature is created, replace the below with
   // a filter. Issue(#9590).
   mirrorMap.forEach((String mirrorName, VariableMirror mirror) {
     if (includePrivate || !mirror.isPrivate) {
       _currentMember = mirror;
       data[mirrorName] = new Variable(mirrorName, mirror.isFinal, 
           mirror.isStatic, mirror.type.qualifiedName, _getComment(mirror), 
-          _getAnnotations(mirror));
+          _getAnnotations(mirror), mirror.qualifiedName);
     }
   });
   return data;
 }
 
 /**
  * Returns a map of [Method] objects constructed from inputted mirrors.
  */
 Map<String, Map<String, Method>> _getMethods
     (Map<String, MethodMirror> mirrorMap, bool includePrivate) {
 
   var setters = {};
   var getters = {};
   var constructors = {};
   var operators = {};
   var methods = {};
   
   mirrorMap.forEach((String mirrorName, MethodMirror mirror) {
     if (includePrivate || !mirror.isPrivate) {
       var method = new Method(mirrorName, mirror.isStatic, 
           mirror.returnType.qualifiedName, _getComment(mirror), 
-          _getParameters(mirror.parameters), _getAnnotations(mirror));
+          _getParameters(mirror.parameters), _getAnnotations(mirror),
+          mirror.qualifiedName);
       _currentMember = mirror;
       if (mirror.isSetter) {
         setters[mirrorName] = method;
       } else if (mirror.isGetter) {
         getters[mirrorName] = method;
       } else if (mirror.isConstructor) {
         constructors[mirrorName] = method;
       } else if (mirror.isOperator) {
         operators[mirrorName] = method;
       } else if (mirror.isRegularMethod) {
@@ skipping 20 matching lines @@
     if (includePrivate || !mirror.isPrivate) {
       _currentClass = mirror;
       var superclass = (mirror.superclass != null) ?
           mirror.superclass.qualifiedName : '';
       var interfaces =
           mirror.superinterfaces.map((interface) => interface.qualifiedName);
       data[mirrorName] = new Class(mirrorName, superclass, mirror.isAbstract, 
           mirror.isTypedef, _getComment(mirror), interfaces.toList(),
           _getVariables(mirror.variables, includePrivate),
           _getMethods(mirror.methods, includePrivate),
-          _getAnnotations(mirror));
+          _getAnnotations(mirror), mirror.qualifiedName);
     }
   });
   return data;
 }
 
 /**
  * Returns a map of [Parameter] objects constructed from inputted mirrors.
  */
 Map<String, Parameter> _getParameters(List<ParameterMirror> mirrorList) {
   var data = {};
@@ skipping 32 matching lines @@
     if (value is Map) {
       outputMap[key] = recurseMap(value);
     } else {
       outputMap[key] = value.toMap();
     }
   });
   return outputMap;
 }
 
 /**
+ * A class representing all programming constructs, like library or class. 
+ */
+class IndexableItem {

[Bob Nystrom, 2013/07/18 17:04:13]

"Item" doesn't add much here. How about just "Indexable" or "Indexed"?

+  IndexableItem(String qualifiedName) {
+    qualifiedNameIndex.add(qualifiedName);
+  }
+}
+
+/**
  * A class containing contents of a Dart library.
  */
-class Library {
+class Library extends IndexableItem {
 
   /// Documentation comment with converted markdown.
   String comment;
 
   /// Top-level variables in the library.
   Map<String, Variable> variables;
 
   /// Top-level functions in the library.
   Map<String, Map<String, Method>> functions;
   
   /// Classes defined within the library
   Map<String, Class> classes;
 
   String name;
 
-  Library(this.name, this.comment, this.variables,
-      this.functions, this.classes);
+  Library(name, this.comment, this.variables,
+      this.functions, this.classes) : super(name) {
+    this.name = name; 
+  }
 
   /// Generates a map describing the [Library] object.
   Map toMap() {
     var libraryMap = {};
     libraryMap['name'] = name;
     libraryMap['comment'] = comment;
     libraryMap['variables'] = recurseMap(variables);
     libraryMap['functions'] = recurseMap(functions);
     libraryMap['classes'] = recurseMap(classes);
     return libraryMap;
   }
 }
 
 /**
  * A class containing contents of a Dart class.
  */
 // TODO(tmandel): Figure out how to do typedefs (what is needed)
-class Class {
+class Class extends IndexableItem {
 
   /// Documentation comment with converted markdown.
   String comment;
 
   /// List of the names of interfaces that this class implements.
   List<String> interfaces;
 
   /// Top-level variables in the class.
   Map<String, Variable> variables;
 
   /// Methods in the class.
   Map<String, Map<String, Method>> methods;
   
   String name;
   String superclass;
   bool isAbstract;
   bool isTypedef;
 
   /// List of the meta annotations on the class.
   List<String> annotations;
   
   Class(this.name, this.superclass, this.isAbstract, this.isTypedef, 
       this.comment, this.interfaces, this.variables, this.methods, 
-      this.annotations);
+      this.annotations, String qualifiedName) : super(qualifiedName) {}
 
   /// Generates a map describing the [Class] object.
   Map toMap() {
     var classMap = {};
     classMap['name'] = name;
     classMap['comment'] = comment;
     classMap['superclass'] = superclass;
     classMap['abstract'] = isAbstract.toString();
     classMap['typedef'] = isTypedef.toString();
     classMap['implements'] = new List.from(interfaces);
     classMap['variables'] = recurseMap(variables);
     classMap['methods'] = recurseMap(methods);
     classMap['annotations'] = new List.from(annotations);
     return classMap;
   }
 }
 
 /**
  * A class containing properties of a Dart variable.
  */
-class Variable {
+class Variable extends IndexableItem {
 
   /// Documentation comment with converted markdown.
   String comment;
 
   String name;
   bool isFinal;
   bool isStatic;
   String type;
 
   /// List of the meta annotations on the variable.
   List<String> annotations;
   
   Variable(this.name, this.isFinal, this.isStatic, this.type, this.comment, 
-      this.annotations);
+      this.annotations, String qualifiedName) : super(qualifiedName);
   
   /// Generates a map describing the [Variable] object.
   Map toMap() {
     var variableMap = {};
     variableMap['name'] = name;
     variableMap['comment'] = comment;
     variableMap['final'] = isFinal.toString();
     variableMap['static'] = isStatic.toString();
     variableMap['type'] = type;
     variableMap['annotations'] = new List.from(annotations);
     return variableMap;
   }
 }
 
 /**
  * A class containing properties of a Dart method.
  */
-class Method {
+class Method extends IndexableItem {
 
   /// Documentation comment with converted markdown.
   String comment;
 
   /// Parameters for this method.
   Map<String, Parameter> parameters;
 
   String name;
   bool isStatic;
   String returnType;
 
   /// List of the meta annotations on the method.
   List<String> annotations;
   
   Method(this.name, this.isStatic, this.returnType, this.comment, 
-      this.parameters, this.annotations);
+      this.parameters, this.annotations, String qualifiedName) 
+      : super(qualifiedName);
   
   /// Generates a map describing the [Method] object.
   Map toMap() {
     var methodMap = {};
     methodMap['name'] = name;
     methodMap['comment'] = comment;
     methodMap['static'] = isStatic.toString();
     methodMap['return'] = returnType;
     methodMap['parameters'] = recurseMap(parameters);
     methodMap['annotations'] = new List.from(annotations);
@@ skipping 25 matching lines @@
     parameterMap['name'] = name;
     parameterMap['optional'] = isOptional.toString();
     parameterMap['named'] = isNamed.toString();
     parameterMap['default'] = hasDefaultValue.toString();
     parameterMap['type'] = type;
     parameterMap['value'] = defaultValue;
     parameterMap['annotations'] = new List.from(annotations);
     return parameterMap;
   }
 }