Split BuildSourceClosuresTask into two tasks; remove unnecessary computation.

pkg/analyzer/test/src/task/dart_test.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 test.src.task.dart_test;
 
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/element.dart';
@@ skipping 14 matching lines @@
 import '../../generated/test_support.dart';
 import '../../reflective_tests.dart';
 import '../context/abstract_context.dart';
 
 main() {
   groupSep = ' | ';
   runReflectiveTests(BuildClassConstructorsTaskTest);
   runReflectiveTests(BuildCompilationUnitElementTaskTest);
   runReflectiveTests(BuildDirectiveElementsTaskTest);
   runReflectiveTests(BuildEnumMemberElementsTaskTest);
-  runReflectiveTests(BuildSourceClosuresTaskTest);
+  runReflectiveTests(BuildSourceExportClosureTaskTest);
+  runReflectiveTests(BuildSourceImportExportClosureTaskTest);
   runReflectiveTests(BuildExportNamespaceTaskTest);
   runReflectiveTests(BuildLibraryConstructorsTaskTest);
   runReflectiveTests(BuildLibraryElementTaskTest);
   runReflectiveTests(BuildPublicNamespaceTaskTest);
   runReflectiveTests(BuildTypeProviderTaskTest);
   runReflectiveTests(ComputeConstantDependenciesTaskTest);
   runReflectiveTests(ComputeConstantValueTaskTest);
   runReflectiveTests(ContainingLibrariesTaskTest);
   runReflectiveTests(DartErrorsTaskTest);
   runReflectiveTests(EvaluateUnitConstantsTaskTest);
@@ skipping 1045 matching lines @@
     computeResult(sources.first, LIBRARY_ELEMENT3);
     expect(task, new isInstanceOf<BuildPublicNamespaceTask>());
     // validate
     LibraryElement library = outputs[LIBRARY_ELEMENT3];
     Namespace namespace = library.publicNamespace;
     expect(namespace.definedNames.keys, unorderedEquals(['a', 'd']));
   }
 }
 
 @reflectiveTest
-class BuildSourceClosuresTaskTest extends _AbstractDartTaskTest {
+class BuildSourceExportClosureTaskTest extends _AbstractDartTaskTest {
   test_perform_exportClosure() {
     Source sourceA = newSource('/a.dart', '''
 library lib_a;
 export 'b.dart';
 ''');
     Source sourceB = newSource('/b.dart', '''
 library lib_b;
 export 'c.dart';
 ''');
     Source sourceC = newSource('/c.dart', '''
 library lib_c;
 export 'a.dart';
 ''');
     Source sourceD = newSource('/d.dart', '''
 library lib_d;
 ''');
     // a.dart
     {
       computeResult(sourceA, EXPORT_SOURCE_CLOSURE);
-      expect(task, new isInstanceOf<BuildSourceClosuresTask>());
+      expect(task, new isInstanceOf<BuildSourceExportClosureTask>());
       List<Source> closure = outputs[EXPORT_SOURCE_CLOSURE];
       expect(closure, unorderedEquals([sourceA, sourceB, sourceC]));
     }
     // c.dart
     {
       computeResult(sourceC, EXPORT_SOURCE_CLOSURE);
-      expect(task, new isInstanceOf<BuildSourceClosuresTask>());
+      expect(task, new isInstanceOf<BuildSourceExportClosureTask>());
       List<Source> closure = outputs[EXPORT_SOURCE_CLOSURE];
       expect(closure, unorderedEquals([sourceA, sourceB, sourceC]));
     }
     // d.dart
     {
       computeResult(sourceD, EXPORT_SOURCE_CLOSURE);
-      expect(task, new isInstanceOf<BuildSourceClosuresTask>());
+      expect(task, new isInstanceOf<BuildSourceExportClosureTask>());
       List<Source> closure = outputs[EXPORT_SOURCE_CLOSURE];
       expect(closure, unorderedEquals([sourceD]));
     }
   }
+}
 
-  test_perform_importClosure() {
-    Source sourceA = newSource('/a.dart', '''
-library lib_a;
-import 'b.dart';
-''');
-    Source sourceB = newSource('/b.dart', '''
-library lib_b;
-import 'c.dart';
-''');
-    Source sourceC = newSource('/c.dart', '''
-library lib_c;
-import 'a.dart';
-''');
-    Source sourceD = newSource('/d.dart', '''
-library lib_d;
-''');
-    Source coreSource = context.sourceFactory.resolveUri(null, 'dart:core');
-    // a.dart
-    {
-      computeResult(sourceA, IMPORT_SOURCE_CLOSURE);
-      expect(task, new isInstanceOf<BuildSourceClosuresTask>());
-      List<Source> closure = outputs[IMPORT_SOURCE_CLOSURE];
-      expect(closure, contains(sourceA));
-      expect(closure, contains(sourceB));
-      expect(closure, contains(sourceC));
-      expect(closure, contains(coreSource));
-    }
-    // c.dart
-    {
-      computeResult(sourceC, IMPORT_SOURCE_CLOSURE);
-      expect(task, new isInstanceOf<BuildSourceClosuresTask>());
-      List<Source> closure = outputs[IMPORT_SOURCE_CLOSURE];
-      expect(closure, contains(sourceA));
-      expect(closure, contains(sourceB));
-      expect(closure, contains(sourceC));
-      expect(closure, contains(coreSource));
-    }
-    // d.dart
-    {
-      computeResult(sourceD, IMPORT_SOURCE_CLOSURE);
-      expect(task, new isInstanceOf<BuildSourceClosuresTask>());
-      List<Source> closure = outputs[IMPORT_SOURCE_CLOSURE];
-      expect(closure, contains(sourceD));
-      expect(closure, contains(coreSource));
-    }
-  }
-
+@reflectiveTest
+class BuildSourceImportExportClosureTaskTest extends _AbstractDartTaskTest {
   test_perform_importExportClosure() {
     Source sourceA = newSource('/a.dart', '''
 library lib_a;
 ''');
     Source sourceB = newSource('/b.dart', '''
 library lib_b;
 export 'a.dart';
 ''');
     Source sourceC = newSource('/c.dart', '''
 library lib_c;
 import 'b.dart';
 ''');
     Source coreSource = context.sourceFactory.resolveUri(null, 'dart:core');
     // c.dart
     {
       computeResult(sourceC, IMPORT_EXPORT_SOURCE_CLOSURE);
-      expect(task, new isInstanceOf<BuildSourceClosuresTask>());
+      expect(task, new isInstanceOf<BuildSourceImportExportClosureTask>());
       List<Source> closure = outputs[IMPORT_EXPORT_SOURCE_CLOSURE];
       expect(closure, contains(sourceA));
       expect(closure, contains(sourceB));
       expect(closure, contains(sourceC));
       expect(closure, contains(coreSource));
     }
     // b.dart
     {
       computeResult(sourceB, IMPORT_EXPORT_SOURCE_CLOSURE);
-      expect(task, new isInstanceOf<BuildSourceClosuresTask>());
+      expect(task, new isInstanceOf<BuildSourceImportExportClosureTask>());
       List<Source> closure = outputs[IMPORT_EXPORT_SOURCE_CLOSURE];
       expect(closure, contains(sourceA));
       expect(closure, contains(sourceB));
       expect(closure, contains(coreSource));
     }
   }
 
   test_perform_isClient_false() {
     Source sourceA = newSource('/a.dart', '''
 library lib_a;
 import 'b.dart';
 ''');
     newSource('/b.dart', '''
 library lib_b;
 ''');
     computeResult(sourceA, IS_CLIENT);
-    expect(task, new isInstanceOf<BuildSourceClosuresTask>());
+    expect(task, new isInstanceOf<BuildSourceImportExportClosureTask>());
     expect(outputs[IS_CLIENT], isFalse);
   }
 
   test_perform_isClient_true_export_indirect() {
     newSource('/exports_html.dart', '''
 library lib_exports_html;
 export 'dart:html';
 ''');
     Source source = newSource('/test.dart', '''
 import 'exports_html.dart';
 ''');
     computeResult(source, IS_CLIENT);
-    expect(task, new isInstanceOf<BuildSourceClosuresTask>());
+    expect(task, new isInstanceOf<BuildSourceImportExportClosureTask>());
     expect(outputs[IS_CLIENT], isTrue);
   }
 
   test_perform_isClient_true_import_direct() {
     Source sourceA = newSource('/a.dart', '''
 library lib_a;
 import 'dart:html';
 ''');
     computeResult(sourceA, IS_CLIENT);
-    expect(task, new isInstanceOf<BuildSourceClosuresTask>());
+    expect(task, new isInstanceOf<BuildSourceImportExportClosureTask>());
     expect(outputs[IS_CLIENT], isTrue);
   }
 
   test_perform_isClient_true_import_indirect() {
     Source sourceA = newSource('/a.dart', '''
 library lib_a;
 import 'b.dart';
 ''');
     newSource('/b.dart', '''
 library lib_b;
 import 'dart:html';
 ''');
     computeResult(sourceA, IS_CLIENT);
-    expect(task, new isInstanceOf<BuildSourceClosuresTask>());
+    expect(task, new isInstanceOf<BuildSourceImportExportClosureTask>());
     expect(outputs[IS_CLIENT], isTrue);
   }
 }
 
 @reflectiveTest
 class BuildTypeProviderTaskTest extends _AbstractDartTaskTest {
   test_perform() {
     computeResult(AnalysisContextTarget.request, TYPE_PROVIDER);
     expect(task, new isInstanceOf<BuildTypeProviderTask>());
     // validate
@@ skipping 1502 matching lines @@
   /**
    * Fill [errorListener] with [result] errors in the current [task].
    */
   void _fillErrorListener(ResultDescriptor<List<AnalysisError>> result) {
     List<AnalysisError> errors = task.outputs[result];
     expect(errors, isNotNull, reason: result.name);
     errorListener = new GatheringErrorListener();
     errorListener.addAll(errors);
   }
 }