Filter out statics when adding inherited members

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.
 ///
 ///      $ dart docgen.dart [OPTIONS] [FILE/DIR]
@@ skipping 879 matching lines @@
     var parent = superclass == null ? [] : [superclass];
     parent.addAll(interfaces);
     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);
-    inheritedVariables.addAll(superclass.variables);
+    inheritedVariables.addAll(_filterStatics(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) {
     if (!_includePrivate && isPrivate) {
       if (superclass != null) superclass.addSubclass(subclass);
@@ skipping 272 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);
+    setters.addAll(_filterStatics(parent.methods.setters));
     getters.addAll(parent.inheritedMethods.getters);
-    getters.addAll(parent.methods.getters);
+    getters.addAll(_filterStatics(parent.methods.getters));
     operators.addAll(parent.inheritedMethods.operators);
-    operators.addAll(parent.methods.operators);
+    operators.addAll(_filterStatics(parent.methods.operators));
     regularMethods.addAll(parent.inheritedMethods.regularMethods);
-    regularMethods.addAll(parent.methods.regularMethods);
+    regularMethods.addAll(_filterStatics(parent.methods.regularMethods));
   }
 
   Map toMap() => {
     'setters': recurseMap(setters),
     'getters': recurseMap(getters),
     'constructors': recurseMap(constructors),
     'operators': recurseMap(operators),
     'methods': recurseMap(regularMethods)
   };
 
@@ skipping 115 matching lines @@
 String docName(DeclarationMirror m) {
   if (m is LibraryMirror) {
     return (m as LibraryMirror).qualifiedName.replaceAll('.','-');
   }
   var owner = m.owner;
   if (owner == null) return m.qualifiedName;
   // For the unnamed constructor we just return the class name.
   if (m.simpleName == '') return docName(owner);
   return docName(owner) + '.' + m.simpleName;
 }
+
+/// Remove statics from the map of inherited items before adding them.
+Map _filterStatics(Map items) {
+  var result = {};
+  items.forEach((name, item) {
+    if (!item.isStatic) {
+      result[name] = item;
+    }
+  });
+  return result;
+}