Allowed for public classes to inherit from private superclasses

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 451 matching lines @@
   });
   return data;
 }
 
 /**
  * Returns a map of [Method] objects constructed from [mirrorMap].
  */
 MethodGroup _methods(Map<String, MethodMirror> mirrorMap) {
   var group = new MethodGroup();
   mirrorMap.forEach((String mirrorName, MethodMirror mirror) {
-    if (_includePrivate || !_isHidden(mirror)) {
+    if (_includePrivate || !mirror.isPrivate) {
       group.addMethod(mirror);
     }
   });
   return group;
 }
 
 /**
  * Returns the [Class] for the given [mirror] has already been created, and if
  * it does not exist, creates it.
  */
 Class _class(ClassMirror mirror) {
   var clazz = entityMap[mirror.qualifiedName];
   if (clazz == null) {
     var superclass = mirror.superclass != null ?
         _class(mirror.superclass) : null;
     var interfaces =
         mirror.superinterfaces.map((interface) => _class(interface));
     clazz = new Class(mirror.simpleName, superclass, _commentToHtml(mirror),
         interfaces.toList(), _variables(mirror.variables),
         _methods(mirror.methods), _annotations(mirror), _generics(mirror),
         mirror.qualifiedName, _isHidden(mirror), mirror.owner.qualifiedName,
         mirror.isAbstract);
-    if (superclass != null)
-      clazz.addInherited(superclass);
-    interfaces.forEach((interface) {
-      clazz.addInherited(interface);
-    });
+    if (superclass != null) clazz.addInherited(superclass);
+    interfaces.forEach((interface) => clazz.addInherited(interface));
     entityMap[mirror.qualifiedName] = clazz;
   }
   return clazz;
 }
 
 /**
  * Returns a map of [Class] objects constructed from [mirrorMap].
  */
 ClassGroup _classes(Map<String, ClassMirror> mirrorMap) {
   var group = new ClassGroup();
@@ skipping 194 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 (_isVisible(superclass)) {
-      inheritedVariables.addAll(superclass.variables);
-    }
+    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.
    */
   void addSubclass(Class subclass) {
@@ skipping 291 matching lines @@
       operators[mirror.simpleName] = method;
     } else if (mirror.isRegularMethod) {
       regularMethods[mirror.simpleName] = method;
     } else {
       throw new ArgumentError('${mirror.simpleName} - no method type match');
     }
   }
 
   void addInherited(Class parent) {
     setters.addAll(parent.inheritedMethods.setters);
+    setters.addAll(parent.methods.setters);
     getters.addAll(parent.inheritedMethods.getters);
+    getters.addAll(parent.methods.getters);
     operators.addAll(parent.inheritedMethods.operators);
+    operators.addAll(parent.methods.operators);
     regularMethods.addAll(parent.inheritedMethods.regularMethods);
-    if (_isVisible(parent)) {
-      setters.addAll(parent.methods.setters);
-      getters.addAll(parent.methods.getters);
-      operators.addAll(parent.methods.operators);
-      regularMethods.addAll(parent.methods.regularMethods);
-    }
+    regularMethods.addAll(parent.methods.regularMethods);
   }
 
   Map toMap() => {
     'setters': recurseMap(setters),
     'getters': recurseMap(getters),
     'constructors': recurseMap(constructors),
     'operators': recurseMap(operators),
     'methods': recurseMap(regularMethods)
   };
 
@@ skipping 109 matching lines @@
   String qualifiedName;
   List<String> parameters;
 
   Annotation(this.qualifiedName, this.parameters);
 
   Map toMap() => {
     'name': qualifiedName,
     'parameters': parameters
   };
 }