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

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

 // Copyright (c) 2016, 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.
 
 import 'package:analyzer/src/summary/format.dart';
+import 'package:analyzer/src/summary/name_filter.dart';
 
 /**
  * Create a [PrelinkedLibraryBuilder] corresponding to the given
  * [definingUnit], which should be the defining compilation unit for a library.
  * Compilation units referenced by the defining compilation unit via `part`
  * declarations will be retrieved using [getPart].  Public namespaces for
  * libraries referenced by the defining compilation unit via `import`
  * declarations (and files reachable from them via `part` and `export`
  * declarations) will be retrieved using [getImport].
  */
@@ skipping 17 matching lines @@
  * Type of the callback used by the prelinker to obtain unlinked summaries of
  * part files of the library to be prelinked.  [relaviteUri] should be
  * interpreted relative to the defining compilation unit of the library being
  * prelinked.
  *
  * If no file exists at the given uri, `null` should be returned.
  */
 typedef UnlinkedUnit GetPartCallback(String relativeUri);
 
 /**
- * A [NameFilter] represents the set of filtering rules implied by zero or more
- * combinators in an `export` or `import` statement.
- */
-class NameFilter {
-  /**
-   * A [NameFilter] representing no filtering at all (i.e. no combinators).
-   */
-  static final NameFilter identity =
-      new NameFilter._(hiddenNames: new Set<String>());
-
-  /**
-   * If this [NameFilter] accepts a finite number of names and hides all
-   * others, the (possibly empty) set of names it accepts.  Otherwise `null`.
-   */
-  final Set<String> shownNames;
-
-  /**
-   * If [shownNames] is `null`, the (possibly empty) set of names not accepted
-   * by this filter (all other names are accepted).  If [shownNames] is not
-   * `null`, then [hiddenNames] will be `null`.
-   */
-  final Set<String> hiddenNames;
-
-  /**
-   * Create a [NameFilter] based on the given [combinator].
-   */
-  factory NameFilter.forCombinator(UnlinkedCombinator combinator) {
-    if (combinator.shows.isNotEmpty) {
-      return new NameFilter._(shownNames: combinator.shows.toSet());
-    } else {
-      return new NameFilter._(hiddenNames: combinator.hides.toSet());
-    }
-  }
-
-  /**
-   * Create a [NameFilter] based on the given (possibly empty) sequence of
-   * [combinators].
-   */
-  factory NameFilter.forCombinators(List<UnlinkedCombinator> combinators) {
-    NameFilter result = identity;
-    for (UnlinkedCombinator combinator in combinators) {
-      result = result.merge(new NameFilter.forCombinator(combinator));
-    }
-    return result;
-  }
-
-  const NameFilter._({this.shownNames, this.hiddenNames});
-
-  /**
-   * Determine if the given [name] is accepted by this [NameFilter].
-   */
-  bool accepts(String name) {
-    if (name.endsWith('=')) {
-      name = name.substring(0, name.length - 1);
-    }
-    if (shownNames != null) {
-      return shownNames.contains(name);
-    } else {
-      return !hiddenNames.contains(name);
-    }
-  }
-
-  /**
-   * Produce a new [NameFilter] by combining this [NameFilter] with another
-   * one.  The new [NameFilter] will only accept names that would be accepted
-   * by both input filters.
-   */
-  NameFilter merge(NameFilter other) {
-    if (shownNames != null) {
-      if (other.shownNames != null) {
-        return new NameFilter._(
-            shownNames: shownNames.intersection(other.shownNames));
-      } else {
-        return new NameFilter._(
-            shownNames: shownNames.difference(other.hiddenNames));
-      }
-    } else {
-      if (other.shownNames != null) {
-        return new NameFilter._(
-            shownNames: other.shownNames.difference(hiddenNames));
-      } else {
-        return new NameFilter._(
-            hiddenNames: hiddenNames.union(other.hiddenNames));
-      }
-    }
-  }
-}
-
-/**
  * A [_Meaning] stores all the information necessary to find the declaration
  * referred to by a name in a namespace.
  */
 class _Meaning {
   /**
    * Which unit in the dependent library contains the declared entity.
    */
   final int unit;
 
   /**
@@ skipping 141 matching lines @@
         if (exportedNamespace != null) {
           for (UnlinkedExportPublic export in exportedNamespace.exports) {
             String exportUri = resolveUri(relativeUri, export.uri);
             aggregatePublicNamespace(exportUri)
                 .forEach((String name, _Meaning meaning) {
               if (filter.accepts(name) && !exportNamespace.containsKey(name)) {
                 exportNamespace[name] = meaning;
               }
             });
             chaseExports(
-                filter.merge(new NameFilter.forCombinators(export.combinators)),
+                filter.merge(
+                    new NameFilter.forUnlinkedCombinators(export.combinators)),
                 exportUri,
                 seenUris);
           }
         }
         seenUris.remove(relativeUri);
       }
     }
     chaseExports(NameFilter.identity, relativeUri, new Set<String>());
     return exportNamespace;
   }
@@ skipping 36 matching lines @@
 
   /**
    * Filter the export namespace for the library whose URI is reachable from
    * [definingUnit] via [relativeUri], retaining only those names accepted by
    * [combinators], and store the resulting names in [result].  Names that
    * already exist in [result] are not overwritten.
    */
   void filterExportNamespace(String relativeUri,
       List<UnlinkedCombinator> combinators, Map<String, _Meaning> result) {
     Map<String, _Meaning> exportNamespace = computeExportNamespace(relativeUri);
-    NameFilter filter = new NameFilter.forCombinators(combinators);
+    NameFilter filter = new NameFilter.forUnlinkedCombinators(combinators);
     exportNamespace.forEach((String name, _Meaning meaning) {
       if (filter.accepts(name) && !result.containsKey(name)) {
         result[name] = meaning;
       }
     });
   }
 
   /**
    * Wrapper around [getImport] that caches the return value in [importCache].
    */
@@ skipping 133 matching lines @@
    * [sourceUri] is also relative.
    */
   String resolveUri(String sourceUri, String relativeUri) {
     if (sourceUri == null) {
       return relativeUri;
     } else {
       return Uri.parse(sourceUri).resolve(relativeUri).toString();
     }
   }
 }