Added to the index to return better search results.

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 212 matching lines @@
   // 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 a text file with a list of libraries available after creating all
   // the libraries. This will help the viewer know what libraries are available
   // to read in.
   _writeToFile(filteredEntities.where((e) => e is Library)
       .map((e) => e.qualifiedName).join('\n'), 'library_list.txt',
       append: append);
-  // Outputs all the qualified names documented. This will help generate search
-  // results.
-  _writeToFile(filteredEntities.map((e) => e.qualifiedName).join('\n'),
+  // 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'),
       'index.txt', append: append);
 }
 
 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));
   logger.fine('Generated library for ${result.name}');
@@ skipping 265 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 => '';
 }
 
 /**
  * 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;
 
   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()
   };
+  
+  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 19 matching lines @@
   bool isAbstract;
 
   /// 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, bool isPrivate, String owner, this.isAbstract) 
       : super(name, comment, qualifiedName, isPrivate, owner);
 
+  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 184 matching lines @@
 
   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;
   bool isConst;
@@ skipping 10 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<String> annotations;
 
   Method(String name, this.isStatic, this.isAbstract, this.isConst,
       this.returnType, String comment, this.parameters, this.annotations,
-      String qualifiedName, bool isPrivate, String owner) : super(name, comment,
-          qualifiedName, isPrivate, owner);
+      String qualifiedName, bool isPrivate, String owner, this.isConstructor,
+      this.isGetter, this.isSetter, this.isOperator) 
+        : super(name, comment, qualifiedName, isPrivate, owner);
 
   /**
    * 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 {
   Map<String, Method> setters = {};
   Map<String, Method> getters = {};
   Map<String, Method> constructors = {};
   Map<String, Method> operators = {};
   Map<String, Method> regularMethods = {};
 
   void addMethod(MethodMirror mirror) {
     var method = new Method(mirror.simpleName, mirror.isStatic,
         mirror.isAbstract, mirror.isConstConstructor, _type(mirror.returnType),
         _commentToHtml(mirror), _parameters(mirror.parameters),
         _annotations(mirror), mirror.qualifiedName, _isHidden(mirror),
-        mirror.owner.qualifiedName);
+        mirror.owner.qualifiedName, mirror.isConstructor, mirror.isGetter,
+        mirror.isSetter, mirror.isOperator);
     entityMap[mirror.qualifiedName] = method;
     _currentMember = mirror;
     if (mirror.isSetter) {
       setters[mirror.simpleName] = method;
     } else if (mirror.isGetter) {
       getters[mirror.simpleName] = method;
     } else if (mirror.isConstructor) {
       constructors[mirror.simpleName] = method;
     } else if (mirror.isOperator) {
       operators[mirror.simpleName] = method;
@@ skipping 137 matching lines @@
   String qualifiedName;
   List<String> parameters;
 
   Annotation(this.qualifiedName, this.parameters);
 
   Map toMap() => {
     'name': qualifiedName,
     'parameters': parameters
   };
 }