Constructors are handled correct in dartdoc.

pkg/dartdoc/lib/dartdoc.dart

 // Copyright (c) 2012, 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.
 
 /**
  * To generate docs for a library, run this script with the path to an
  * entrypoint .dart file, like:
  *
  *     $ dart dartdoc.dart foo.dart
  *
@@ skipping 177 matching lines @@
 
   /** Set by Dartdoc user to print extra information during generation. */
   bool verbose = false;
 
   /** Set this to include API libraries in the documentation. */
   bool includeApi = false;
 
   /** Set this to generate links to the online API. */
   bool linkToApi = false;
 
+  /** Set this to generate docs for private types and members. */
+  bool showPrivate = false;
+
+  /** Set this to inherit from Object. */
+  bool inheritFromObject = false;
+
   /** Set this to select the libraries to include in the documentation. */
   List<String> includedLibraries = const <String>[];
 
   /** Set this to select the libraries to exclude from the documentation. */
   List<String> excludedLibraries = const <String>[];
 
   /**
    * This list contains the libraries sorted in by the library name.
    */
   List<LibraryMirror> _sortedLibraries;
@@ skipping 357 matching lines @@
   void docLibraryNavigationJson(LibraryMirror library, List libraryList) {
     var libraryInfo = {};
     libraryInfo[NAME] = library.simpleName;
     final List members = docMembersJson(library.declaredMembers);
     if (!members.isEmpty()) {
       libraryInfo[MEMBERS] = members;
     }
 
     final types = [];
     for (InterfaceMirror type in orderByName(library.types.getValues())) {
-      if (type.isPrivate) continue;
+      if (!showPrivate && type.isPrivate) continue;
 
       var typeInfo = {};
       typeInfo[NAME] = type.displayName;
       if (type.isClass) {
         typeInfo[KIND] = CLASS;
       } else if (type.isInterface) {
         typeInfo[KIND] = INTERFACE;
       } else {
         assert(type.isTypedef);
         typeInfo[KIND] = TYPEDEF;
@@ skipping 15 matching lines @@
     if (!types.isEmpty()) {
       libraryInfo[TYPES] = types;
     }
 
     libraryList.add(libraryInfo);
   }
 
   List docMembersJson(Map<Object,MemberMirror> memberMap) {
     final members = [];
     for (MemberMirror member in orderByName(memberMap.getValues())) {
-      if (member.isPrivate) continue;
+      if (!showPrivate && member.isPrivate) continue;
 
       var memberInfo = {};
       if (member.isField) {
         memberInfo[KIND] = FIELD;
       } else {
         MethodMirror method = member;
         if (method.isConstructor) {
           memberInfo[KIND] = CONSTRUCTOR;
         } else if (method.isSetter) {
           memberInfo[KIND] = SETTER;
@@ skipping 41 matching lines @@
     writeln('</div>');
   }
 
   /** Writes the navigation for the types contained by the given library. */
   void docLibraryNavigation(LibraryMirror library) {
     // Show the exception types separately.
     final types = <InterfaceMirror>[];
     final exceptions = <InterfaceMirror>[];
 
     for (InterfaceMirror type in orderByName(library.types.getValues())) {
-      if (type.isPrivate) continue;
+      if (!showPrivate && type.isPrivate) continue;
 
       if (isException(type)) {
         exceptions.add(type);
       } else {
         types.add(type);
       }
     }
 
     if ((types.length == 0) && (exceptions.length == 0)) return;
 
@@ skipping 45 matching lines @@
     // Document the top-level members.
     docMembers(library);
 
     // Document the types.
     final classes = <InterfaceMirror>[];
     final interfaces = <InterfaceMirror>[];
     final typedefs = <TypedefMirror>[];
     final exceptions = <InterfaceMirror>[];
 
     for (InterfaceMirror type in orderByName(library.types.getValues())) {
-      if (type.isPrivate) continue;
+      if (!showPrivate && type.isPrivate) continue;
 
       if (isException(type)) {
         exceptions.add(type);
       } else if (type.isClass) {
         classes.add(type);
       } else if (type.isInterface){
         interfaces.add(type);
       } else if (type is TypedefMirror) {
         typedefs.add(type);
       } else {
         throw new InternalError("internal error: unknown type $type.");
       }
     }
 
     docTypes(classes, 'Classes');
     docTypes(interfaces, 'Interfaces');
     docTypes(typedefs, 'Typedefs');
     docTypes(exceptions, 'Exceptions');
 
     writeFooter();
     endFile();
 
     for (final type in library.types.getValues()) {
-      if (type.isPrivate) continue;
+      if (!showPrivate && type.isPrivate) continue;
 
       docType(type);
     }
   }
 
   void docTypes(List types, String header) {
     if (types.length == 0) return;
 
     writeln('<div>');
     writeln('<h3>$header</h3>');
@@ skipping 46 matching lines @@
             'Hide inherited</button>');
 
     writeln('<div class="doc">');
     docComment(type, getTypeComment(type));
     docCode(type.location);
     writeln('</div>');
 
     docInheritance(type);
     docTypedef(type);
 
-    docConstructors(type);
     docMembers(type);
 
     writeTypeFooter();
     writeFooter();
     endFile();
   }
 
   /** Override this to write additional content at the end of a type's page. */
   void writeTypeFooter() {
     // Do nothing.
@@ skipping 28 matching lines @@
    */
   void docInheritance(InterfaceMirror type) {
     // Don't show the inheritance details for Object. It doesn't have any base
     // class (obviously) and it has too many subclasses to be useful.
     if (type.isObject) return;
 
     // Writes an unordered list of references to types with an optional header.
     listTypes(types, header) {
       if (types == null) return;
 
-      // Skip private types.
-      final publicTypes = new List.from(types.filter((t) => !t.isPrivate));
+      var publicTypes;
+      if (showPrivate) {
+        publicTypes = types;
+      } else {
+        // Skip private types.
+        publicTypes = new List.from(types.filter((t) => !t.isPrivate));
+      }
       if (publicTypes.length == 0) return;
 
       writeln('<h3>$header</h3>');
       writeln('<p>');
       bool first = true;
       for (final t in publicTypes) {
         if (!first) write(', ');
         typeSpan(t);
         first = false;
       }
@@ skipping 77 matching lines @@
               title="Permalink to ${type.simpleName}">#</a>''');
     writeln('</h4>');
 
     writeln('<div class="doc">');
     docCode(type.location);
     writeln('</div>');
 
     writeln('</div>');
   }
 
-  /** Document the constructors for [Type], if any. */
-  void docConstructors(InterfaceMirror type) {
-    final constructors = <MethodMirror>[];
-    for (var constructor in type.constructors.getValues()) {
-       if (!constructor.isPrivate) {
-         constructors.add(constructor);
-       }
-    }
-
-    if (constructors.length > 0) {
-      writeln('<div>');
-      writeln('<h3>Constructors</h3>');
-      constructors.sort((x, y) => x.constructorName.toUpperCase().compareTo(
-                                  y.constructorName.toUpperCase()));
-
-      for (final constructor in constructors) {
-        docMethod(type, constructor);
-      }
-      writeln('</div>');
-    }
-  }
-
   static const operatorOrder = const <String>[
       '[]', '[]=', // Indexing.
       '+', Mirror.UNARY_MINUS, '-', '*', '/', '~/', '%', // Arithmetic.
       '&', '|', '^', '~', // Bitwise.
       '<<', '>>', // Shift.
       '<', '<=', '>', '>=', // Relational.
       '==', // Equality.
   ];
 
   static final Map<String, int> operatorOrderMap = (){
     var map = new Map<String, int>();
     var index = 0;
     for (String operator in operatorOrder) {
       map[operator] = index++;
     }
     return map;
   }();
 
   void docMembers(ObjectMirror host) {
     // Collect the different kinds of members.
     final staticMethods = [];
     final staticGetters = new Map<String,MemberMirror>();
     final staticSetters = new Map<String,MemberMirror>();
     final memberMap = new Map<String,MemberMirror>();
     final instanceMethods = [];
     final instanceOperators = [];
     final instanceGetters = new Map<String,MemberMirror>();
     final instanceSetters = new Map<String,MemberMirror>();
+    final constructors = [];
 
     host.declaredMembers.forEach((_, MemberMirror member) {
-      if (member.isPrivate) return;
+      if (!showPrivate && member.isPrivate) return;
       if (host is LibraryMirror || member.isStatic) {
         if (member is MethodMirror) {
           if (member.isGetter) {
             staticGetters[member.displayName] = member;
           } else if (member.isSetter) {
             staticSetters[member.displayName] = member;
           } else {
             staticMethods.add(member);
           }
         } else if (member is FieldMirror) {
           staticGetters[member.displayName] = member;
         }
       }
     });
 
     if (host is InterfaceMirror) {
       var iterable = new HierarchyIterable(host, includeType: true);
       for (InterfaceMirror type in iterable) {
+        if (!host.isObject && !inheritFromObject && type.isObject) continue;
+
         type.declaredMembers.forEach((_, MemberMirror member) {
-          if (member.isPrivate) return;
-          if (!member.isStatic) {
-            if (member.isField) {
-              // Fields override both getters and setters.
-              memberMap.putIfAbsent(member.simpleName, () => member);
-              memberMap.putIfAbsent('${member.simpleName}=', () => member);
-            } else {
-              memberMap.putIfAbsent(member.simpleName, () => member);
+          if (member.isStatic) return;
+          if (!showPrivate && member.isPrivate) return;
+
+          bool inherit = true;
+          if (type !== host) {
+            if (member.isPrivate) {
+              // Don't inherit private members.
+              inherit = false;
             }
+            if (member.isConstructor) {
+              // Don't inherit constructors.
+              inherit = false;
+            }
+          }
+          if (!inherit) return;
+
+          if (member.isField) {
+            // Fields override both getters and setters.
+            memberMap.putIfAbsent(member.simpleName, () => member);
+            memberMap.putIfAbsent('${member.simpleName}=', () => member);
+          } else if (member.isConstructor) {
+            constructors.add(member);
+          } else {
+            memberMap.putIfAbsent(member.simpleName, () => member);
           }
         });
       }
     }
 
+    bool allMethodsInherited = true;
+    bool allPropertiesInherited = true;
+    bool allOperatorsInherited = true;
     memberMap.forEach((_, MemberMirror member) {
       if (member is MethodMirror) {
         if (member.isGetter) {
           instanceGetters[member.displayName] = member;
+          if (member.surroundingDeclaration == host) {
+            allPropertiesInherited = false;
+          }
         } else if (member.isSetter) {
           instanceSetters[member.displayName] = member;
+          if (member.surroundingDeclaration == host) {
+            allPropertiesInherited = false;
+          }
         } else if (member.isOperator) {
           instanceOperators.add(member);
+          if (member.surroundingDeclaration == host) {
+            allOperatorsInherited = false;
+          }
         } else {
           instanceMethods.add(member);
+          if (member.surroundingDeclaration == host) {
+            allMethodsInherited = false;
+          }
         }
       } else if (member is FieldMirror) {
         instanceGetters[member.displayName] = member;
+        if (member.surroundingDeclaration == host) {
+          allPropertiesInherited = false;
+        }
       }
     });
 
     instanceOperators.sort((MethodMirror a, MethodMirror b) {
       return operatorOrderMap[a.simpleName].compareTo(
           operatorOrderMap[b.simpleName]);
     });
 
     docProperties(host,
                   host is LibraryMirror ? 'Properties' : 'Static Properties',
-                  staticGetters, staticSetters);
+                  staticGetters, staticSetters, allInherited: false);
     docMethods(host,
                host is LibraryMirror ? 'Functions' : 'Static Methods',
-               staticMethods);
+               staticMethods, allInherited: false);
 
-    docProperties(host, 'Properties', instanceGetters, instanceSetters);
-    docMethods(host, 'Operators', instanceOperators);
-    docMethods(host, 'Methods', orderByName(instanceMethods));
+    docMethods(host, 'Constructors', orderByName(constructors),
+               allInherited: false);
+    docProperties(host, 'Properties', instanceGetters, instanceSetters,
+                  allInherited: allPropertiesInherited);
+    docMethods(host, 'Operators', instanceOperators,
+               allInherited: allOperatorsInherited);
+    docMethods(host, 'Methods', orderByName(instanceMethods),
+               allInherited: allMethodsInherited);
   }
 
   /**
    * Documents fields, getters, and setters as properties.
    */
   void docProperties(ObjectMirror host, String title,
                      Map<String,MemberMirror> getters,
-                     Map<String,MemberMirror> setters) {
+                     Map<String,MemberMirror> setters,
+                     {bool allInherited}) {
     if (getters.isEmpty() && setters.isEmpty()) return;
 
     var nameSet = new Set<String>.from(getters.getKeys());
     nameSet.addAll(setters.getKeys());
     var nameList = new List<String>.from(nameSet);
     nameList.sort((String a, String b) {
       return a.toLowerCase().compareTo(b.toLowerCase());
     });
 
-    writeln('<div>');
+    writeln('<div${allInherited ? ' class="inherited"' : ''}>');
     writeln('<h3>$title</h3>');
     for (String name in nameList) {
       MemberMirror getter = getters[name];
       MemberMirror setter = setters[name];
       if (setter == null) {
         if (getter is FieldMirror) {
           // We have a field.
           docField(host, getter);
         } else {
           // We only have a getter.
@@ skipping 25 matching lines @@
           }
         } else {
           // Document as field.
           docProperty(host, getter, setter);
         }
       }
     }
     writeln('</div>');
   }
 
-  void docMethods(ObjectMirror host, String title, List<MethodMirror> methods) {
+  void docMethods(ObjectMirror host, String title, List<MethodMirror> methods,
+                  {bool allInherited}) {
     if (methods.length > 0) {
-      writeln('<div>');
+      writeln('<div${allInherited ? ' class="inherited"' : ''}>');
       writeln('<h3>$title</h3>');
       for (final method in methods) {
         docMethod(host, method);
       }
       writeln('</div>');
     }
   }
 
   /**
    * Documents the [member] declared in [host]. Handles all kinds of members
@@ skipping 646 matching lines @@
   final InterfaceMirror inheritedFrom;
 
   DocComment(this.text, [this.inheritedFrom = null]) {
     assert(text != null && !text.trim().isEmpty());
   }
 
   String get html => md.markdownToHtml(text);
 
   String toString() => text;
 }