Move NameFilter to its own file so it can be conveniently reused.

pkg/analyzer/lib/src/summary/summarize_elements.dart

 // Copyright (c) 2015, 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.
 
 library serialization.elements;
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:analyzer/src/summary/format.dart';
+import 'package:analyzer/src/summary/name_filter.dart';
 
 /**
  * Serialize all the elements in [lib] to a summary using [ctx] as the context
  * for building the summary, and using [typeProvider] to find built-in types.
  */
 LibrarySerializationResult serializeLibrary(
     LibraryElement lib, TypeProvider typeProvider) {
   var serializer = new _LibrarySerializer(lib, typeProvider);
   PrelinkedLibraryBuilder prelinked = serializer.serializeLibrary();
   return new LibrarySerializationResult(
@@ skipping 252 matching lines @@
   /**
    * Fill in [prefixMap] using information from [libraryElement.imports].
    */
   void computePrefixMap() {
     for (ImportElement import in libraryElement.imports) {
       if (import.prefix == null) {
         continue;
       }
       import.importedLibrary.exportNamespace.definedNames
           .forEach((String name, Element e) {
-        if (import.combinators.any((NamespaceCombinator combinator) =>
-            doesCombinatorReject(combinator, name))) {
-          return;
+        if (new NameFilter.forNamespaceCombinators(import.combinators)
+            .accepts(name)) {
+          prefixMap[e] = import.prefix;
         }
-        prefixMap[e] = import.prefix;
       });
     }
   }
 
   /**
-   * Determine if the given [combinator] would reject an element having the
-   * given [name].
-   */
-  bool doesCombinatorReject(NamespaceCombinator combinator, String name) {
-    if (combinator is ShowElementCombinator) {
-      return !combinator.shownNames.contains(name);
-    } else if (combinator is HideElementCombinator) {
-      return combinator.hiddenNames.contains(name);
-    } else {
-      throw new StateError(
-          'Unexpected combinator type ${combinator.runtimeType}');
-    }
-  }
-
-  /**
    * Compute the appropriate De Bruijn index to represent the given type
    * parameter [type].
    */
   int findTypeParameterIndex(TypeParameterType type, Element context) {
     int index = 0;
     while (context != null) {
       List<TypeParameterElement> typeParameters;
       if (context is ClassElement) {
         typeParameters = context.typeParameters;
       } else if (context is FunctionTypeAliasElement) {
@@ skipping 400 matching lines @@
    * satisfy the request.
    */
   int serializeUnresolvedReference() {
     // TODO(paulberry): in order for relinking to work, we need to record the
     // name and prefix of the unresolved symbol.  This is not (yet) encoded in
     // the element model.  For the moment we use a name that can't possibly
     // ever exist.
     if (unresolvedReferenceIndex == null) {
       assert(unlinkedReferences.length == prelinkedReferences.length);
       unresolvedReferenceIndex = unlinkedReferences.length;
-      unlinkedReferences
-          .add(encodeUnlinkedReference(name: '*unresolved*'));
+      unlinkedReferences.add(encodeUnlinkedReference(name: '*unresolved*'));
       prelinkedReferences.add(
           encodePrelinkedReference(kind: PrelinkedReferenceKind.unresolved));
     }
     return unresolvedReferenceIndex;
   }
 
   /**
    * Serialize the given [variable], creating an [UnlinkedVariable].
    */
   UnlinkedVariableBuilder serializeVariable(PropertyInducingElement variable) {
     UnlinkedVariableBuilder b = new UnlinkedVariableBuilder();
     b.name = variable.name;
     b.nameOffset = variable.nameOffset;
     b.type = serializeTypeRef(variable.type, variable);
     b.isStatic = variable.isStatic && variable.enclosingElement is ClassElement;
     b.isFinal = variable.isFinal;
     b.isConst = variable.isConst;
     b.hasImplicitType = variable.hasImplicitType;
     b.documentationComment = serializeDocumentation(variable);
     return b;
   }
 }