Returning the closest public superclass rather than returning ""

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 198 matching lines @@
       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. 
   entityMap['dart.core.Object'].subclasses.clear();
   
-  var filteredEntities = entityMap.values.where((e) => _filterPrivate(e));
+  var filteredEntities = entityMap.values.where((e) => _isHidden(e));
   // 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);
@@ skipping 42 matching lines @@
 bool _isPrivate(DeclarationMirror mirror) {
   if (mirror is LibraryMirror) {
     return _isLibraryPrivate(mirror);
   } else if (mirror.owner is LibraryMirror) {
     return (mirror.isPrivate || _isLibraryPrivate(mirror.owner));
   } else { 
     return (mirror.isPrivate || _isPrivate(mirror.owner));
   }
 }
 
-bool _filterPrivate(Indexable item) {
+bool _isHidden(Indexable item) {

[Bob Nystrom, 2013/08/02 02:25:03]

Hmm, I think I told you to name this backwards. It returns true if the item
should be shown, right? Maybe _isVisible().

   return _includePrivate || !item.isPrivate;
 }
 
 /**
  * Returns a list of meta annotations assocated with a mirror.
  */
 List<String> _annotations(DeclarationMirror mirror) {
   var annotations = mirror.metadata.where((e) =>
       e is dart2js.Dart2JsConstructedConstantMirror);
   return annotations.map((e) => e.type.qualifiedName).toList();
@@ skipping 278 matching lines @@
     return parent;
   }
   
   /**
    * Add all inherited variables and methods from the provided superclass.
    * If [_includePrivate] is true, it also adds the variables and methods from 
    * the superclass. 
    */
   void addInherited(Class superclass) {
     inheritedVariables.addAll(superclass.inheritedVariables);
-    if (_filterPrivate(superclass)) {
+    if (_isHidden(superclass)) {
       inheritedVariables.addAll(superclass.variables);
     }
     inheritedMethods.addInherited(superclass);
   }
   
   /**
    * Add the subclass to the class. 
    * 
    * If [this] is private, it will add the subclass to the list of subclasses in
    * the superclasses. 
@@ skipping 21 matching lines @@
       this.isPrivate = true;
       // Since we are now making the mixin a private class, make all elements 
       // with the mixin as an owner private too. 
       entityMap.values.where((e) => e.owner == qualifiedName)
         .forEach((element) => element.isPrivate = true);
       // Move the subclass up to the next public superclass
       subclasses.forEach((subclass) => addSubclass(entityMap[subclass]));
     }
   }
   
+  /** 
+   * If a class extends a private superclass, find the closest public superclass
+   * of the private superclass. 
+   */
+  String validSuperclass() {
+    if (superclass == null) return 'dart.core.Object';
+    if (_isHidden(superclass)) return superclass.qualifiedName;
+    return superclass.validSuperclass();
+  }
+  
   /// Generates a map describing the [Class] object.
   Map toMap() => {
     'name': name,
     'qualifiedname': qualifiedName,
     'comment': comment,
-    'superclass': superclass == null ? "" : (_filterPrivate(superclass)) ? 
-        superclass.qualifiedName : "",
-    'implements': new List.from(interfaces.where((e) => _filterPrivate(e))
+    'superclass': validSuperclass(),
+    'implements': new List.from(interfaces.where((e) => _isHidden(e))

[Bob Nystrom, 2013/08/02 02:25:03]

Instead of where((e) => _isHidden(e)), you can just do: where(_isHidden)

         .map((e) => e.qualifiedName)),
     'subclass': new List.from(subclasses),
     'variables': recurseMap(variables),
     'inheritedvariables': recurseMap(inheritedVariables),
     'methods': methods.toMap(),
     'inheritedmethods': inheritedMethods.toMap(),
     'annotations': new List.from(annotations),
     'generics': recurseMap(generics)
   };
 }
 
 /**
  * A container to categorize classes into the following groups: abstract 
  * classes, regular classes, typedefs, and errors. 
  */
 class ClassGroup {
   Map<String, Class> abstractClasses = {};
   Map<String, Class> regularClasses = {};
   Map<String, Typedef> typedefs = {};
   Map<String, Class> errors = {};
   
   void addClass(ClassMirror mirror) {
     _currentClass = mirror;
     var clazz = _class(mirror);
    
     // Adding inherited parent variables and methods. 
     clazz.parent().forEach((parent) {
-      if (_filterPrivate(clazz)) {
+      if (_isHidden(clazz)) {
         parent.addSubclass(clazz);
       }
       clazz.addInherited(parent);
     });
     
     if (isError(mirror.qualifiedName)) {
       errors[mirror.simpleName] = clazz;
     } else if (mirror.isTypedef) {
       if (_includePrivate || !mirror.isPrivate) {
         entityMap[mirror.qualifiedName] = new Typedef(mirror.simpleName, 
@@ skipping 16 matching lines @@
    * Checks if the given name is a key for any of the Class Maps. 
    */
   bool containsKey(String name) {
     return abstractClasses.containsKey(name) ||
         regularClasses.containsKey(name) ||
         errors.containsKey(name);
   }
   
   Map toMap() => {
     'abstract': new List.from(abstractClasses.values
-        .where((e) => _filterPrivate(e)).map((e) => e.qualifiedName)),
+        .where((e) => _isHidden(e)).map((e) => e.qualifiedName)),

[Bob Nystrom, 2013/08/02 02:25:03]

And here too:

where(_isHidden)

     'class': new List.from(regularClasses.values
-        .where((e) => _filterPrivate(e)).map((e) => e.qualifiedName)),
+        .where((e) => _isHidden(e)).map((e) => e.qualifiedName)),
     'typedef': recurseMap(typedefs),
     'error': new List.from(errors.values
-        .where((e) => _filterPrivate(e)).map((e) => e.qualifiedName))
+        .where((e) => _isHidden(e)).map((e) => e.qualifiedName))
   };
 }
 
 class Typedef extends Indexable {
   String returnType;
   
   Map<String, Parameter> parameters;
   
   /// Generic information about the typedef. 
   Map<String, Generic> generics;
@@ skipping 114 matching lines @@
     } else {
       throw new ArgumentError('${mirror.simpleName} - no method type match');
     }
   }
   
   void addInherited(Class parent) {
     setters.addAll(parent.inheritedMethods.setters);
     getters.addAll(parent.inheritedMethods.getters);
     operators.addAll(parent.inheritedMethods.operators);
     regularMethods.addAll(parent.inheritedMethods.regularMethods);
-    if (_filterPrivate(parent)) {
+    if (_isHidden(parent)) {
       setters.addAll(parent.methods.setters);
       getters.addAll(parent.methods.getters);
       operators.addAll(parent.methods.operators);
       regularMethods.addAll(parent.methods.regularMethods);
     }
   }
   
   Map toMap() => {
     'setters': recurseMap(setters),
     'getters': recurseMap(getters),
@@ skipping 82 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()))
   };
 }