Fix for computing IS_CLIENT.

pkg/analyzer/lib/src/task/dart.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 analyzer.src.task.dart;
 
 import 'dart:collection';
 import 'dart:math' as math;
 
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 1418 matching lines @@
 }
 
 /**
  * A task that builds [IMPORT_SOURCE_CLOSURE] and [EXPORT_SOURCE_CLOSURE] of
  * a library.
  */
 class BuildSourceClosuresTask extends SourceBasedAnalysisTask {
   /**
    * The name of the import closure.
    */
-  static const String IMPORT_CLOSURE_INPUT = 'IMPORT_CLOSURE_INPUT';
+  static const String IMPORT_INPUT = 'IMPORT_INPUT';
 
   /**
    * The name of the export closure.
    */
-  static const String EXPORT_CLOSURE_INPUT = 'EXPORT_CLOSURE_INPUT';
+  static const String EXPORT_INPUT = 'EXPORT_INPUT';
+
+  /**
+   * The name of the import/export closure.
+   */
+  static const String IMPORT_EXPORT_INPUT = 'IMPORT_EXPORT_INPUT';
 
   /**
    * The task descriptor describing this kind of task.
    */
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'BuildExportSourceClosureTask', createTask, buildInputs,
       <ResultDescriptor>[
     IMPORT_SOURCE_CLOSURE,
     EXPORT_SOURCE_CLOSURE,
     IS_CLIENT
   ]);
 
   BuildSourceClosuresTask(
       InternalAnalysisContext context, AnalysisTarget target)
       : super(context, target);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   void internalPerform() {
-    List<Source> importClosure = getRequiredInput(IMPORT_CLOSURE_INPUT);
-    List<Source> exportClosure = getRequiredInput(EXPORT_CLOSURE_INPUT);
+    List<Source> importClosure = getRequiredInput(IMPORT_INPUT);
+    List<Source> exportClosure = getRequiredInput(EXPORT_INPUT);
+    List<Source> importExportClosure = getRequiredInput(IMPORT_EXPORT_INPUT);
     Source htmlSource = context.sourceFactory.forUri(DartSdk.DART_HTML);
     //
     // Record outputs.
     //
     outputs[IMPORT_SOURCE_CLOSURE] = importClosure;
     outputs[EXPORT_SOURCE_CLOSURE] = exportClosure;
-    outputs[IS_CLIENT] = importClosure.contains(htmlSource);
+    outputs[IS_CLIENT] = importExportClosure.contains(htmlSource);
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the
    * given library [libSource].
    */
   static Map<String, TaskInput> buildInputs(Source libSource) {
     return <String, TaskInput>{
-      IMPORT_CLOSURE_INPUT: new _ImportSourceClosureTaskInput(libSource),
-      EXPORT_CLOSURE_INPUT: new _ExportSourceClosureTaskInput(libSource)
+      IMPORT_INPUT: new _ImportSourceClosureTaskInput(libSource),
+      EXPORT_INPUT: new _ExportSourceClosureTaskInput(libSource),
+      IMPORT_EXPORT_INPUT: new _ImportExportSourceClosureTaskInput(libSource)
     };
   }
 
   /**
    * Create a [BuildSourceClosuresTask] based on the given [target] in
    * the given [context].
    */
   static BuildSourceClosuresTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new BuildSourceClosuresTask(context, target);
@@ skipping 1016 matching lines @@
   _ExportSourceClosureTaskInput(this.target);
 
   @override
   TaskInputBuilder<List<Source>> createBuilder() =>
       new _SourceClosureTaskInputBuilder(target, _SourceClosureKind.EXPORT);
 }
 
 /**
  * The kind of the source closure to build.
  */
-enum _SourceClosureKind { IMPORT, EXPORT }
+enum _SourceClosureKind { IMPORT, EXPORT, IMPORT_EXPORT }
+
+/**
+ * A [TaskInput] whose value is a list of library sources imported or exported,
+ * directly or indirectly by the target [Source].
+ */
+class _ImportExportSourceClosureTaskInput implements TaskInput<List<Source>> {
+  final Source target;
+
+  _ImportExportSourceClosureTaskInput(this.target);
+
+  @override
+  TaskInputBuilder<List<Source>> createBuilder() =>
+      new _SourceClosureTaskInputBuilder(
+          target, _SourceClosureKind.IMPORT_EXPORT);
+}
 
 /**
  * A [TaskInput] whose value is a list of library sources imported directly
  * or indirectly by the target [Source].
  */
 class _ImportSourceClosureTaskInput implements TaskInput<List<Source>> {
   final Source target;
 
   _ImportSourceClosureTaskInput(this.target);
 
@@ skipping 15 matching lines @@
   _SourceClosureTaskInputBuilder(Source librarySource, this.kind) {
     _newSources.add(librarySource);
   }
 
   @override
   ResultDescriptor get currentResult => LIBRARY_ELEMENT2;
 
   @override
   void set currentValue(LibraryElement library) {
     if (_libraries.add(library)) {
-      if (kind == _SourceClosureKind.IMPORT) {
+      if (kind == _SourceClosureKind.IMPORT ||
+          kind == _SourceClosureKind.IMPORT_EXPORT) {
         for (ImportElement importElement in library.imports) {
           Source importedSource = importElement.importedLibrary.source;
           _newSources.add(importedSource);
         }
-      } else {
+      }
+      if (kind == _SourceClosureKind.EXPORT ||
+          kind == _SourceClosureKind.IMPORT_EXPORT) {
         for (ExportElement exportElement in library.exports) {
-          Source importedSource = exportElement.exportedLibrary.source;
-          _newSources.add(importedSource);
+          Source exportedSource = exportElement.exportedLibrary.source;
+          _newSources.add(exportedSource);
         }
       }
     }
   }
 
   @override
   List<Source> get inputValue {
     return _libraries.map((LibraryElement library) => library.source).toList();
   }
 
   @override
   bool moveNext() {
     if (_newSources.isEmpty) {
       return false;
     }
     currentTarget = _newSources.first;
     _newSources.remove(currentTarget);
     return true;
   }
 }