Move the filterNonDocumented and filterNonPublic functions as extension getters

`filterNonPublic` becomes an extension getter, `wherePublic`, and
`filterNonDocumented` becomes an extension getter, `whereDocumented`.

Nameable now implements Privacy. Privacy is now an abstract interface class.

Changing all the call sites highlights a number of ModelElement getters that
are superfluous. For example, `Container.publicInstanceMethods`. This was a
getter that now boils down to `instanceMethods.wherePublic`, and it really is
unneccessary to keep this; there are many such methods that are removed here:

* Container: `publicInstanceMethods`, `publicInstanceOperators`, `publicInstanceFields`,
  `publicConstantFields`,
* InheritingContainer: `publicSuperChain`, `publicInheritedFields`, `publicInheritedMethods`,
* LibraryContainer: `publicLibraries`,
* Package: `documentedCategories`,
* PackageGraph: `documentedExtensions`,
* TopLevelContainer: `publicClasses`, `publicExtensions`,
  `publicExtensionTypes`, `publicConstants`, `publicEnums`,
  `_publicExceptions`, `publicFunctions`, `publicMixins`, `publicProperties`,
  `publicTypedefs`.

Additionally, this change highlights some small inefficiency in some `hasX`
methods. For example, `hasPublicInstanceMethods` used to enumerate all of the
public instance methods, then ask if the list is empty. Now we can ask if `any`
of the `instanceMethods` are `public`.

* Container: `hasPublicInstanceMethods`, `hasPublicInstanceOperators`,
  `hasPublicInstanceFields`, `hasPublicConstantFields`,
  `hasPublicVariableStaticFields`, `hasPublicStaticMethods`,
  `hasPublicEnumValues`,
* InheritingContainer: `hasPublicInheritedMethods`,
  `hasPublicSuperChainReversed`,
* MixedInTypes: `hasPublicMixedInTypes`,
* LibraryContainer: `hasPublicLibraries`,
* Package: `hasDocumentedCategories`,
* TopLevelContainer: `hasPublicClasses`, `hasPublicExtensions`,
  `hasPublicExtensionTypes`, `hasPublicConstants`, `hasPublicEnums`,
  `hasPublicExceptions`, `hasPublicFunctions`,`hasPublicMixins`,
  `hasPublicProperties`, `hasPublicTypedefs`.

Because the field `InheritingContaier.publicSuperChain` is removed, I change
`superChain` from a getter to a field, sort of the point of caching.

Author: srawlins

lib/src/generator/empty_generator.dart

@@ -18,13 +18,14 @@ class EmptyGenerator implements Generator {
       packageGraph.defaultPackage,
       ...packageGraph.localPackages
     }) {
-      for (var category in filterNonDocumented(package.categories)) {
+      for (var category in package.categories.whereDocumented) {
         logProgress(category.documentationAsHtml);
       }
 
-      for (var lib in filterNonDocumented(package.libraries)) {
-        filterNonDocumented(lib.allModelElements)
-            .forEach((m) => logProgress(m.documentationAsHtml));
+      for (var lib in package.libraries.whereDocumented) {
+        for (var e in lib.allModelElements.whereDocumented) {
+          logProgress(e.documentationAsHtml);
+        }
       }
     }
     return Future.value();

lib/src/generator/generator_frontend.dart

@@ -74,14 +74,14 @@ class GeneratorFrontEnd implements Generator {
       if (multiplePackages) {
         logInfo('Generating docs for package ${package.name}...');
       }
-      for (var category in filterNonDocumented(package.categories)) {
+      for (var category in package.categories.whereDocumented) {
         logInfo('Generating docs for category ${category.name} from '
             '${category.package.fullyQualifiedName}...');
         indexAccumulator.add(category);
         _generatorBackend.generateCategory(packageGraph, category);
       }
 
-      for (var lib in filterNonDocumented(package.libraries)) {
+      for (var lib in package.libraries.whereDocumented) {
         if (!multiplePackages) {
           logInfo('Generating docs for library ${lib.breadcrumbName} from '
               '${lib.element.source.uri}...');
@@ -92,104 +92,101 @@ class GeneratorFrontEnd implements Generator {
         indexAccumulator.add(lib);
         _generatorBackend.generateLibrary(packageGraph, lib);
 
-        for (var clazz in filterNonDocumented(lib.allClasses)) {
+        for (var clazz in lib.allClasses.whereDocumented) {
           indexAccumulator.add(clazz);
           _generatorBackend.generateClass(packageGraph, lib, clazz);
 
-          for (var constructor in filterNonDocumented(clazz.constructors)) {
+          for (var constructor in clazz.constructors.whereDocumented) {
             if (!constructor.isCanonical) continue;
 
             indexAccumulator.add(constructor);
             _generatorBackend.generateConstructor(
                 packageGraph, lib, clazz, constructor);
           }
 
-          for (var constant in filterNonDocumented(clazz.constantFields)) {
+          for (var constant in clazz.constantFields.whereDocumented) {
             if (!constant.isCanonical) continue;
 
             indexAccumulator.add(constant);
             _generatorBackend.generateProperty(
                 packageGraph, lib, clazz, constant);
           }
 
-          for (var property
-              in filterNonDocumented(clazz.variableStaticFields)) {
+          for (var property in clazz.variableStaticFields.whereDocumented) {
             if (!property.isCanonical) continue;
 
             indexAccumulator.add(property);
             _generatorBackend.generateProperty(
                 packageGraph, lib, clazz, property);
           }
 
-          for (var property in filterNonDocumented(clazz.instanceFields)) {
+          for (var property in clazz.instanceFields.whereDocumented) {
             if (!property.isCanonical) continue;
 
             indexAccumulator.add(property);
             _generatorBackend.generateProperty(
                 packageGraph, lib, clazz, property);
           }
 
-          for (var method in filterNonDocumented(clazz.instanceMethods)) {
+          for (var method in clazz.instanceMethods.whereDocumented) {
             if (!method.isCanonical) continue;
 
             indexAccumulator.add(method);
             _generatorBackend.generateMethod(packageGraph, lib, clazz, method);
           }
 
-          for (var operator in filterNonDocumented(clazz.instanceOperators)) {
+          for (var operator in clazz.instanceOperators.whereDocumented) {
             if (!operator.isCanonical) continue;
 
             indexAccumulator.add(operator);
             _generatorBackend.generateMethod(
                 packageGraph, lib, clazz, operator);
           }
 
-          for (var method in filterNonDocumented(clazz.staticMethods)) {
+          for (var method in clazz.staticMethods.whereDocumented) {
             if (!method.isCanonical) continue;
 
             indexAccumulator.add(method);
             _generatorBackend.generateMethod(packageGraph, lib, clazz, method);
           }
         }
 
-        for (var extension in filterNonDocumented(lib.extensions)) {
+        for (var extension in lib.extensions.whereDocumented) {
           indexAccumulator.add(extension);
           _generatorBackend.generateExtension(packageGraph, lib, extension);
 
-          for (var constant in filterNonDocumented(extension.constantFields)) {
+          for (var constant in extension.constantFields.whereDocumented) {
             indexAccumulator.add(constant);
             _generatorBackend.generateProperty(
                 packageGraph, lib, extension, constant);
           }
 
-          for (var method
-              in filterNonDocumented(extension.publicInstanceMethods)) {
+          for (var method in extension.instanceMethods.whereDocumented) {
             indexAccumulator.add(method);
             _generatorBackend.generateMethod(
                 packageGraph, lib, extension, method);
           }
 
-          for (var operator
-              in filterNonDocumented(extension.instanceOperators)) {
+          for (var operator in extension.instanceOperators.whereDocumented) {
             indexAccumulator.add(operator);
             _generatorBackend.generateMethod(
                 packageGraph, lib, extension, operator);
           }
 
-          for (var property in filterNonDocumented(extension.instanceFields)) {
+          for (var property in extension.instanceFields.whereDocumented) {
             indexAccumulator.add(property);
             _generatorBackend.generateProperty(
                 packageGraph, lib, extension, property);
           }
 
           for (var staticField
-              in filterNonDocumented(extension.variableStaticFields)) {
+              in extension.variableStaticFields.whereDocumented) {
             indexAccumulator.add(staticField);
             _generatorBackend.generateProperty(
                 packageGraph, lib, extension, staticField);
           }
 
-          for (var method in filterNonDocumented(extension.staticMethods)) {
+          for (var method in extension.staticMethods.whereDocumented) {
             if (!method.isCanonical) continue;
 
             indexAccumulator.add(method);
@@ -198,56 +195,52 @@ class GeneratorFrontEnd implements Generator {
           }
         }
 
-        for (var extensionType in filterNonDocumented(lib.extensionTypes)) {
+        for (var extensionType in lib.extensionTypes.whereDocumented) {
           indexAccumulator.add(extensionType);
           _generatorBackend.generateExtensionType(
               packageGraph, lib, extensionType);
 
-          for (var constructor
-              in filterNonDocumented(extensionType.constructors)) {
+          for (var constructor in extensionType.constructors.whereDocumented) {
             if (!constructor.isCanonical) continue;
 
             indexAccumulator.add(constructor);
             _generatorBackend.generateConstructor(
                 packageGraph, lib, extensionType, constructor);
           }
 
-          for (var constant
-              in filterNonDocumented(extensionType.constantFields)) {
+          for (var constant in extensionType.constantFields.whereDocumented) {
             indexAccumulator.add(constant);
             _generatorBackend.generateProperty(
                 packageGraph, lib, extensionType, constant);
           }
 
-          for (var method
-              in filterNonDocumented(extensionType.publicInstanceMethods)) {
+          for (var method in extensionType.instanceMethods.whereDocumented) {
             indexAccumulator.add(method);
             _generatorBackend.generateMethod(
                 packageGraph, lib, extensionType, method);
           }
 
           for (var operator
-              in filterNonDocumented(extensionType.instanceOperators)) {
+              in extensionType.instanceOperators.whereDocumented) {
             indexAccumulator.add(operator);
             _generatorBackend.generateMethod(
                 packageGraph, lib, extensionType, operator);
           }
 
-          for (var property
-              in filterNonDocumented(extensionType.instanceFields)) {
+          for (var property in extensionType.instanceFields.whereDocumented) {
             indexAccumulator.add(property);
             _generatorBackend.generateProperty(
                 packageGraph, lib, extensionType, property);
           }
 
           for (var staticField
-              in filterNonDocumented(extensionType.variableStaticFields)) {
+              in extensionType.variableStaticFields.whereDocumented) {
             indexAccumulator.add(staticField);
             _generatorBackend.generateProperty(
                 packageGraph, lib, extensionType, staticField);
           }
 
-          for (var method in filterNonDocumented(extensionType.staticMethods)) {
+          for (var method in extensionType.staticMethods.whereDocumented) {
             if (!method.isCanonical) continue;
 
             indexAccumulator.add(method);
@@ -256,62 +249,61 @@ class GeneratorFrontEnd implements Generator {
           }
         }
 
-        for (var mixin in filterNonDocumented(lib.mixins)) {
+        for (var mixin in lib.mixins.whereDocumented) {
           indexAccumulator.add(mixin);
           _generatorBackend.generateMixin(packageGraph, lib, mixin);
 
-          for (var constant in filterNonDocumented(mixin.constantFields)) {
+          for (var constant in mixin.constantFields.whereDocumented) {
             if (!constant.isCanonical) continue;
             indexAccumulator.add(constant);
             _generatorBackend.generateProperty(
                 packageGraph, lib, mixin, constant);
           }
 
-          for (var property
-              in filterNonDocumented(mixin.variableStaticFields)) {
+          for (var property in mixin.variableStaticFields.whereDocumented) {
             if (!property.isCanonical) continue;
 
             indexAccumulator.add(property);
             _generatorBackend.generateProperty(
                 packageGraph, lib, mixin, property);
           }
 
-          for (var property in filterNonDocumented(mixin.instanceFields)) {
+          for (var property in mixin.instanceFields.whereDocumented) {
             if (!property.isCanonical) continue;
 
             indexAccumulator.add(property);
             _generatorBackend.generateProperty(
                 packageGraph, lib, mixin, property);
           }
 
-          for (var method in filterNonDocumented(mixin.instanceMethods)) {
+          for (var method in mixin.instanceMethods.whereDocumented) {
             if (!method.isCanonical) continue;
 
             indexAccumulator.add(method);
             _generatorBackend.generateMethod(packageGraph, lib, mixin, method);
           }
 
-          for (var operator in filterNonDocumented(mixin.instanceOperators)) {
+          for (var operator in mixin.instanceOperators.whereDocumented) {
             if (!operator.isCanonical) continue;
 
             indexAccumulator.add(operator);
             _generatorBackend.generateMethod(
                 packageGraph, lib, mixin, operator);
           }
 
-          for (var method in filterNonDocumented(mixin.staticMethods)) {
+          for (var method in mixin.staticMethods.whereDocumented) {
             if (!method.isCanonical) continue;
 
             indexAccumulator.add(method);
             _generatorBackend.generateMethod(packageGraph, lib, mixin, method);
           }
         }
 
-        for (var enum_ in filterNonDocumented(lib.enums)) {
+        for (var enum_ in lib.enums.whereDocumented) {
           indexAccumulator.add(enum_);
           _generatorBackend.generateEnum(packageGraph, lib, enum_);
 
-          for (var constant in filterNonDocumented(enum_.constantFields)) {
+          for (var constant in enum_.constantFields.whereDocumented) {
             if (constant is EnumField) {
               // Enum values don't get their own page; just any additional
               // constants.
@@ -324,48 +316,48 @@ class GeneratorFrontEnd implements Generator {
                 packageGraph, lib, enum_, constant);
           }
 
-          for (var constructor in filterNonDocumented(enum_.constructors)) {
+          for (var constructor in enum_.constructors.whereDocumented) {
             if (!constructor.isCanonical) continue;
 
             indexAccumulator.add(constructor);
             _generatorBackend.generateConstructor(
                 packageGraph, lib, enum_, constructor);
           }
 
-          for (var property in filterNonDocumented(enum_.instanceFields)) {
+          for (var property in enum_.instanceFields.whereDocumented) {
             indexAccumulator.add(property);
             _generatorBackend.generateProperty(
                 packageGraph, lib, enum_, property);
           }
-          for (var operator in filterNonDocumented(enum_.instanceOperators)) {
+          for (var operator in enum_.instanceOperators.whereDocumented) {
             indexAccumulator.add(operator);
             _generatorBackend.generateMethod(
                 packageGraph, lib, enum_, operator);
           }
-          for (var method in filterNonDocumented(enum_.instanceMethods)) {
+          for (var method in enum_.instanceMethods.whereDocumented) {
             indexAccumulator.add(method);
             _generatorBackend.generateMethod(packageGraph, lib, enum_, method);
           }
         }
 
-        for (var constant in filterNonDocumented(lib.constants)) {
+        for (var constant in lib.constants.whereDocumented) {
           indexAccumulator.add(constant);
           _generatorBackend.generateTopLevelProperty(
               packageGraph, lib, constant);
         }
 
-        for (var property in filterNonDocumented(lib.properties)) {
+        for (var property in lib.properties.whereDocumented) {
           indexAccumulator.add(property);
           _generatorBackend.generateTopLevelProperty(
               packageGraph, lib, property);
         }
 
-        for (var function in filterNonDocumented(lib.functions)) {
+        for (var function in lib.functions.whereDocumented) {
           indexAccumulator.add(function);
           _generatorBackend.generateFunction(packageGraph, lib, function);
         }
 
-        for (var typeDef in filterNonDocumented(lib.typedefs)) {
+        for (var typeDef in lib.typedefs.whereDocumented) {
           indexAccumulator.add(typeDef);
           _generatorBackend.generateTypeDef(packageGraph, lib, typeDef);
         }

lib/src/generator/templates.aot_renderers_for_html.dart

@@ -1584,7 +1584,7 @@ String renderMixin(MixinTemplateData context0) {
       <h2>Properties</h2>
 
       <dl class="properties">''');
-    var context7 = context2.publicInstanceFields;
+    var context7 = context2.publicInstanceFieldsSorted;
     for (var context8 in context7) {
       buffer.write('\n          ');
       buffer.write(_renderMixin_partial_property_8(context8));