More strong mode fixes for analyzer

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 analyzer.test.src.task.dart_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 963 matching lines @@
     List<Source> sources = newSources(sourceMap);
     Source libSource = sources.first;
     computeResult(libSource, LIBRARY_ELEMENT1,
         matcher: isBuildLibraryElementTask);
     libraryUnit = context
         .getCacheEntry(new LibrarySpecificUnit(libSource, libSource))
         .getValue(RESOLVED_UNIT1);
     libraryUnitElement = libraryUnit.element;
     librarySource = libraryUnitElement.source;
     libraryElement = outputs[LIBRARY_ELEMENT1];
-    partUnits = task.inputs[BuildLibraryElementTask.PARTS_UNIT_INPUT];
+    partUnits = task.inputs[BuildLibraryElementTask.PARTS_UNIT_INPUT]
+        as List<CompilationUnit>;
   }
 }
 
 @reflectiveTest
 class BuildPublicNamespaceTaskTest extends _AbstractDartTaskTest {
   test_perform() {
     List<Source> sources = newSources({
       '/lib.dart': '''
 library lib;
 part 'part.dart';
@@ skipping 10 matching lines @@
         matcher: isBuildPublicNamespaceTask);
     // validate
     LibraryElement library = outputs[LIBRARY_ELEMENT3];
     Namespace namespace = library.publicNamespace;
     expect(namespace.definedNames.keys, unorderedEquals(['a', 'd']));
   }
 }
 
 @reflectiveTest
 class BuildSourceExportClosureTaskTest extends _AbstractDartTaskTest {
+  List<Source> getExportSourceClosure(Map<ResultDescriptor, dynamic> outputs) {
+    return outputs[EXPORT_SOURCE_CLOSURE] as List<Source>;
+  }
+
   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,
           matcher: isBuildSourceExportClosureTask);
-      List<Source> closure = outputs[EXPORT_SOURCE_CLOSURE];
+      List<Source> closure = getExportSourceClosure(outputs);
       expect(closure, unorderedEquals([sourceA, sourceB, sourceC]));
     }
     // c.dart
     {
       computeResult(sourceC, EXPORT_SOURCE_CLOSURE,
           matcher: isBuildSourceExportClosureTask);
-      List<Source> closure = outputs[EXPORT_SOURCE_CLOSURE];
+      List<Source> closure = getExportSourceClosure(outputs);
       expect(closure, unorderedEquals([sourceA, sourceB, sourceC]));
     }
     // d.dart
     {
       computeResult(sourceD, EXPORT_SOURCE_CLOSURE,
           matcher: isBuildSourceExportClosureTask);
-      List<Source> closure = outputs[EXPORT_SOURCE_CLOSURE];
+      List<Source> closure = getExportSourceClosure(outputs);
       expect(closure, unorderedEquals([sourceD]));
     }
   }
 }
 
 @reflectiveTest
 class BuildTypeProviderTaskTest extends _AbstractDartTaskTest {
   test_perform() {
     computeResult(AnalysisContextTarget.request, TYPE_PROVIDER,
         matcher: isBuildTypeProviderTask);
@@ skipping 437 matching lines @@
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, RESOLVED_UNIT5);
     CompilationUnit unit = outputs[RESOLVED_UNIT5];
     TopLevelVariableElement elementA = unit.element.topLevelVariables[0];
     TopLevelVariableElement elementB = unit.element.topLevelVariables[1];
 
     computeResult(elementA, INFERABLE_STATIC_VARIABLE_DEPENDENCIES,
         matcher: isComputeInferableStaticVariableDependenciesTask);
     expect(outputs, hasLength(1));
-    List<VariableElement> dependencies =
-        outputs[INFERABLE_STATIC_VARIABLE_DEPENDENCIES];
+    List<VariableElement> dependencies = outputs[
+        INFERABLE_STATIC_VARIABLE_DEPENDENCIES] as List<VariableElement>;
     expect(dependencies, unorderedEquals([elementB]));
   }
 }
 
 @reflectiveTest
 class ComputeLibraryCycleTaskTest extends _AbstractDartTaskTest {
+  List<LibraryElement> getLibraryCycle(Map<ResultDescriptor, dynamic> outputs) {
+    return outputs[LIBRARY_CYCLE] as List<LibraryElement>;
+  }
+
+  List<CompilationUnitElement> getLibraryCycleDependencies(
+      Map<ResultDescriptor, dynamic> outputs) {
+    return outputs[LIBRARY_CYCLE_DEPENDENCIES] as List<CompilationUnitElement>;
+  }
+
+  List<CompilationUnitElement> getLibraryCycleUnits(
+      Map<ResultDescriptor, dynamic> outputs) {
+    return outputs[LIBRARY_CYCLE_UNITS] as List<CompilationUnitElement>;
+  }
+
   @override
   void setUp() {
     super.setUp();
     enableStrongMode();
   }
 
   void test_library_cycle_incremental() {
     enableStrongMode();
     Source lib1Source = newSource(
         '/my_lib1.dart',
@@ skipping 99 matching lines @@
   void test_library_cycle_linear() {
     List<Source> sources = newSources({
       '/a.dart': '''
 ''',
       '/b.dart': '''
 import 'a.dart';
   '''
     });
     List<Map<ResultDescriptor, dynamic>> results =
         computeLibraryResultsMap(sources, LIBRARY_CYCLE);
-    List<LibraryElement> component0 = results[0][LIBRARY_CYCLE];
-    List<LibraryElement> component1 = results[1][LIBRARY_CYCLE];
+    List<LibraryElement> component0 = getLibraryCycle(results[0]);
+    List<LibraryElement> component1 = getLibraryCycle(results[1]);
     expect(component0, hasLength(1));
     expect(component1, hasLength(1));
 
-    List<CompilationUnitElement> units0 = results[0][LIBRARY_CYCLE_UNITS];
-    List<CompilationUnitElement> units1 = results[1][LIBRARY_CYCLE_UNITS];
+    List<CompilationUnitElement> units0 = getLibraryCycleUnits(results[0]);
+    List<CompilationUnitElement> units1 = getLibraryCycleUnits(results[1]);
     expect(units0, hasLength(1));
     expect(units1, hasLength(1));
 
-    List<CompilationUnitElement> dep0 = results[0][LIBRARY_CYCLE_DEPENDENCIES];
-    List<CompilationUnitElement> dep1 = results[1][LIBRARY_CYCLE_DEPENDENCIES];
+    List<CompilationUnitElement> dep0 = getLibraryCycleDependencies(results[0]);
+    List<CompilationUnitElement> dep1 = getLibraryCycleDependencies(results[1]);
     expect(dep0, hasLength(1)); // dart:core
     expect(dep1, hasLength(2)); // dart:core, a.dart
   }
 
   void test_library_cycle_loop() {
     List<Source> sources = newSources({
       '/a.dart': '''
   import 'c.dart';
 ''',
       '/b.dart': '''
   import 'a.dart';
   ''',
       '/c.dart': '''
   import 'b.dart';
   '''
     });
     List<Map<ResultDescriptor, dynamic>> results =
         computeLibraryResultsMap(sources, LIBRARY_CYCLE).toList();
-    List<LibraryElement> component0 = results[0][LIBRARY_CYCLE];
-    List<LibraryElement> component1 = results[1][LIBRARY_CYCLE];
-    List<LibraryElement> component2 = results[2][LIBRARY_CYCLE];
+    List<LibraryElement> component0 = getLibraryCycle(results[0]);
+    List<LibraryElement> component1 = getLibraryCycle(results[1]);
+    List<LibraryElement> component2 = getLibraryCycle(results[2]);
 
     expect(component0, hasLength(3));
     expect(component1, hasLength(3));
     expect(component2, hasLength(3));
 
-    List<CompilationUnitElement> units0 = results[0][LIBRARY_CYCLE_UNITS];
-    List<CompilationUnitElement> units1 = results[1][LIBRARY_CYCLE_UNITS];
-    List<CompilationUnitElement> units2 = results[2][LIBRARY_CYCLE_UNITS];
+    List<CompilationUnitElement> units0 = getLibraryCycleUnits(results[0]);
+    List<CompilationUnitElement> units1 = getLibraryCycleUnits(results[1]);
+    List<CompilationUnitElement> units2 = getLibraryCycleUnits(results[2]);
     expect(units0, hasLength(3));
     expect(units1, hasLength(3));
     expect(units2, hasLength(3));
 
-    List<CompilationUnitElement> dep0 = results[0][LIBRARY_CYCLE_DEPENDENCIES];
-    List<CompilationUnitElement> dep1 = results[1][LIBRARY_CYCLE_DEPENDENCIES];
-    List<CompilationUnitElement> dep2 = results[2][LIBRARY_CYCLE_DEPENDENCIES];
+    List<CompilationUnitElement> dep0 = getLibraryCycleDependencies(results[0]);
+    List<CompilationUnitElement> dep1 = getLibraryCycleDependencies(results[1]);
+    List<CompilationUnitElement> dep2 = getLibraryCycleDependencies(results[2]);
     expect(dep0, hasLength(1)); // dart:core
     expect(dep1, hasLength(1)); // dart:core
     expect(dep2, hasLength(1)); // dart:core
   }
 
   void test_library_cycle_override_inference_incremental() {
     enableStrongMode();
     Source lib1Source = newSource(
         '/my_lib1.dart',
         '''
@@ skipping 49 matching lines @@
   }
 
   void test_library_cycle_self_loop() {
     List<Source> sources = newSources({
       '/a.dart': '''
   import 'a.dart';
 '''
     });
     List<Map<ResultDescriptor, dynamic>> results =
         computeLibraryResultsMap(sources, LIBRARY_CYCLE).toList();
-    List<LibraryElement> component0 = results[0][LIBRARY_CYCLE];
+    List<LibraryElement> component0 = getLibraryCycle(results[0]);
     expect(component0, hasLength(1));
 
-    List<CompilationUnitElement> units0 = results[0][LIBRARY_CYCLE_UNITS];
+    List<CompilationUnitElement> units0 = getLibraryCycleUnits(results[0]);
     expect(units0, hasLength(1));
 
-    List<CompilationUnitElement> dep0 = results[0][LIBRARY_CYCLE_DEPENDENCIES];
+    List<CompilationUnitElement> dep0 = getLibraryCycleDependencies(results[0]);
     expect(dep0, hasLength(1)); // dart:core
   }
 
   void test_library_cycle_singleton() {
     Source source = newSource(
         '/test.dart',
         '''
 import 'dart:core';
 ''');
     computeResult(new LibrarySpecificUnit(source, source), LIBRARY_CYCLE);
-    List<LibraryElement> component = outputs[LIBRARY_CYCLE];
-    List<CompilationUnitElement> units = outputs[LIBRARY_CYCLE_UNITS];
-    List<CompilationUnitElement> deps = outputs[LIBRARY_CYCLE_DEPENDENCIES];
+    List<LibraryElement> component = getLibraryCycle(outputs);
+    List<CompilationUnitElement> units = getLibraryCycleUnits(outputs);
+    List<CompilationUnitElement> deps = getLibraryCycleDependencies(outputs);
     expect(component, hasLength(1));
     expect(units, hasLength(1));
     expect(deps, hasLength(1));
   }
 
   void test_library_cycle_tree() {
     List<Source> sources = newSources({
       '/a.dart': '''
 ''',
       '/b.dart': '''
   ''',
       '/c.dart': '''
   import 'a.dart';
   import 'b.dart';
   '''
     });
     List<Map<ResultDescriptor, dynamic>> results =
         computeLibraryResultsMap(sources, LIBRARY_CYCLE);
-    List<LibraryElement> component0 = results[0][LIBRARY_CYCLE];
-    List<LibraryElement> component1 = results[1][LIBRARY_CYCLE];
-    List<LibraryElement> component2 = results[2][LIBRARY_CYCLE];
+    List<LibraryElement> component0 = getLibraryCycle(results[0]);
+    List<LibraryElement> component1 = getLibraryCycle(results[1]);
+    List<LibraryElement> component2 = getLibraryCycle(results[2]);
     expect(component0, hasLength(1));
     expect(component1, hasLength(1));
     expect(component2, hasLength(1));
 
-    List<CompilationUnitElement> units0 = results[0][LIBRARY_CYCLE_UNITS];
-    List<CompilationUnitElement> units1 = results[1][LIBRARY_CYCLE_UNITS];
-    List<CompilationUnitElement> units2 = results[2][LIBRARY_CYCLE_UNITS];
+    List<CompilationUnitElement> units0 = getLibraryCycleUnits(results[0]);
+    List<CompilationUnitElement> units1 = getLibraryCycleUnits(results[1]);
+    List<CompilationUnitElement> units2 = getLibraryCycleUnits(results[2]);
     expect(units0, hasLength(1));
     expect(units1, hasLength(1));
     expect(units2, hasLength(1));
 
-    List<CompilationUnitElement> dep0 = results[0][LIBRARY_CYCLE_DEPENDENCIES];
-    List<CompilationUnitElement> dep1 = results[1][LIBRARY_CYCLE_DEPENDENCIES];
-    List<CompilationUnitElement> dep2 = results[2][LIBRARY_CYCLE_DEPENDENCIES];
+    List<CompilationUnitElement> dep0 = getLibraryCycleDependencies(results[0]);
+    List<CompilationUnitElement> dep1 = getLibraryCycleDependencies(results[1]);
+    List<CompilationUnitElement> dep2 = getLibraryCycleDependencies(results[2]);
     expect(dep0, hasLength(1)); // dart:core
     expect(dep1, hasLength(1)); // dart:core,
     expect(dep2, hasLength(3)); // dart:core, a.dart, b.dart
   }
 
   void test_library_double_loop() {
     List<Source> sources = newSources({
       '/a.dart': '''
   import 'b.dart';
 ''',
       '/b.dart': '''
   import 'a.dart';
   ''',
       '/c.dart': '''
   import 'd.dart' as foo;
   import 'a.dart' as bar;
   export 'b.dart';
   ''',
       '/d.dart': '''
   import 'c.dart' as foo;
   import 'b.dart' as bar;
   export 'a.dart';
   '''
     });
     List<Map<ResultDescriptor, dynamic>> results =
         computeLibraryResultsMap(sources, LIBRARY_CYCLE).toList();
-    List<LibraryElement> component0 = results[0][LIBRARY_CYCLE];
-    List<LibraryElement> component1 = results[1][LIBRARY_CYCLE];
-    List<LibraryElement> component2 = results[2][LIBRARY_CYCLE];
-    List<LibraryElement> component3 = results[3][LIBRARY_CYCLE];
+    List<LibraryElement> component0 = getLibraryCycle(results[0]);
+    List<LibraryElement> component1 = getLibraryCycle(results[1]);
+    List<LibraryElement> component2 = getLibraryCycle(results[2]);
+    List<LibraryElement> component3 = getLibraryCycle(results[3]);
 
     expect(component0, hasLength(2));
     expect(component1, hasLength(2));
     expect(component2, hasLength(2));
     expect(component3, hasLength(2));
 
-    List<CompilationUnitElement> units0 = results[0][LIBRARY_CYCLE_UNITS];
-    List<CompilationUnitElement> units1 = results[1][LIBRARY_CYCLE_UNITS];
-    List<CompilationUnitElement> units2 = results[2][LIBRARY_CYCLE_UNITS];
-    List<CompilationUnitElement> units3 = results[3][LIBRARY_CYCLE_UNITS];
+    List<CompilationUnitElement> units0 = getLibraryCycleUnits(results[0]);
+    List<CompilationUnitElement> units1 = getLibraryCycleUnits(results[1]);
+    List<CompilationUnitElement> units2 = getLibraryCycleUnits(results[2]);
+    List<CompilationUnitElement> units3 = getLibraryCycleUnits(results[3]);
     expect(units0, hasLength(2));
     expect(units1, hasLength(2));
     expect(units2, hasLength(2));
     expect(units3, hasLength(2));
 
-    List<CompilationUnitElement> dep0 = results[0][LIBRARY_CYCLE_DEPENDENCIES];
-    List<CompilationUnitElement> dep1 = results[1][LIBRARY_CYCLE_DEPENDENCIES];
-    List<CompilationUnitElement> dep2 = results[2][LIBRARY_CYCLE_DEPENDENCIES];
-    List<CompilationUnitElement> dep3 = results[3][LIBRARY_CYCLE_DEPENDENCIES];
+    List<CompilationUnitElement> dep0 = getLibraryCycleDependencies(results[0]);
+    List<CompilationUnitElement> dep1 = getLibraryCycleDependencies(results[1]);
+    List<CompilationUnitElement> dep2 = getLibraryCycleDependencies(results[2]);
+    List<CompilationUnitElement> dep3 = getLibraryCycleDependencies(results[3]);
     expect(dep0, hasLength(1)); // dart:core
     expect(dep1, hasLength(1)); // dart:core
     expect(dep2, hasLength(3)); // dart:core, a.dart, b.dart
     expect(dep3, hasLength(3)); // dart:core, a.dart, b.dart
   }
 
   void test_library_double_loop_parts() {
     List<Source> sources = newSources({
       '/a.dart': '''
   import 'b.dart';
@@ skipping 42 matching lines @@
     computeResult(
         new LibrarySpecificUnit(sources[5], sources[5]), LIBRARY_CYCLE);
     Map<ResultDescriptor, dynamic> results5 = outputs;
     computeResult(
         new LibrarySpecificUnit(sources[5], sources[6]), LIBRARY_CYCLE);
     Map<ResultDescriptor, dynamic> results6 = outputs;
     computeResult(
         new LibrarySpecificUnit(sources[5], sources[7]), LIBRARY_CYCLE);
     Map<ResultDescriptor, dynamic> results7 = outputs;
 
-    List<LibraryElement> component0 = results0[LIBRARY_CYCLE];
-    List<LibraryElement> component1 = results1[LIBRARY_CYCLE];
-    List<LibraryElement> component2 = results2[LIBRARY_CYCLE];
-    List<LibraryElement> component3 = results3[LIBRARY_CYCLE];
-    List<LibraryElement> component4 = results4[LIBRARY_CYCLE];
-    List<LibraryElement> component5 = results5[LIBRARY_CYCLE];
-    List<LibraryElement> component6 = results6[LIBRARY_CYCLE];
-    List<LibraryElement> component7 = results7[LIBRARY_CYCLE];
+    List<LibraryElement> component0 = getLibraryCycle(results0);
+    List<LibraryElement> component1 = getLibraryCycle(results1);
+    List<LibraryElement> component2 = getLibraryCycle(results2);
+    List<LibraryElement> component3 = getLibraryCycle(results3);
+    List<LibraryElement> component4 = getLibraryCycle(results4);
+    List<LibraryElement> component5 = getLibraryCycle(results5);
+    List<LibraryElement> component6 = getLibraryCycle(results6);
+    List<LibraryElement> component7 = getLibraryCycle(results7);
 
     expect(component0, hasLength(2));
     expect(component1, hasLength(2));
     expect(component2, hasLength(2));
     expect(component3, hasLength(2));
     expect(component4, hasLength(2));
     expect(component5, hasLength(2));
     expect(component6, hasLength(2));
     expect(component7, hasLength(2));
 
-    List<CompilationUnitElement> units0 = results0[LIBRARY_CYCLE_UNITS];
-    List<CompilationUnitElement> units1 = results1[LIBRARY_CYCLE_UNITS];
-    List<CompilationUnitElement> units2 = results2[LIBRARY_CYCLE_UNITS];
-    List<CompilationUnitElement> units3 = results3[LIBRARY_CYCLE_UNITS];
-    List<CompilationUnitElement> units4 = results4[LIBRARY_CYCLE_UNITS];
-    List<CompilationUnitElement> units5 = results5[LIBRARY_CYCLE_UNITS];
-    List<CompilationUnitElement> units6 = results6[LIBRARY_CYCLE_UNITS];
-    List<CompilationUnitElement> units7 = results7[LIBRARY_CYCLE_UNITS];
+    List<CompilationUnitElement> units0 = getLibraryCycleUnits(results0);
+    List<CompilationUnitElement> units1 = getLibraryCycleUnits(results1);
+    List<CompilationUnitElement> units2 = getLibraryCycleUnits(results2);
+    List<CompilationUnitElement> units3 = getLibraryCycleUnits(results3);
+    List<CompilationUnitElement> units4 = getLibraryCycleUnits(results4);
+    List<CompilationUnitElement> units5 = getLibraryCycleUnits(results5);
+    List<CompilationUnitElement> units6 = getLibraryCycleUnits(results6);
+    List<CompilationUnitElement> units7 = getLibraryCycleUnits(results7);
     expect(units0, hasLength(4));
     expect(units1, hasLength(4));
     expect(units2, hasLength(4));
     expect(units3, hasLength(4));
     expect(units4, hasLength(4));
     expect(units5, hasLength(4));
     expect(units6, hasLength(4));
     expect(units7, hasLength(4));
 
-    List<CompilationUnitElement> dep0 = results0[LIBRARY_CYCLE_DEPENDENCIES];
-    List<CompilationUnitElement> dep1 = results1[LIBRARY_CYCLE_DEPENDENCIES];
-    List<CompilationUnitElement> dep2 = results2[LIBRARY_CYCLE_DEPENDENCIES];
-    List<CompilationUnitElement> dep3 = results3[LIBRARY_CYCLE_DEPENDENCIES];
-    List<CompilationUnitElement> dep4 = results4[LIBRARY_CYCLE_DEPENDENCIES];
-    List<CompilationUnitElement> dep5 = results5[LIBRARY_CYCLE_DEPENDENCIES];
-    List<CompilationUnitElement> dep6 = results6[LIBRARY_CYCLE_DEPENDENCIES];
-    List<CompilationUnitElement> dep7 = results7[LIBRARY_CYCLE_DEPENDENCIES];
+    List<CompilationUnitElement> dep0 = getLibraryCycleDependencies(results0);
+    List<CompilationUnitElement> dep1 = getLibraryCycleDependencies(results1);
+    List<CompilationUnitElement> dep2 = getLibraryCycleDependencies(results2);
+    List<CompilationUnitElement> dep3 = getLibraryCycleDependencies(results3);
+    List<CompilationUnitElement> dep4 = getLibraryCycleDependencies(results4);
+    List<CompilationUnitElement> dep5 = getLibraryCycleDependencies(results5);
+    List<CompilationUnitElement> dep6 = getLibraryCycleDependencies(results6);
+    List<CompilationUnitElement> dep7 = getLibraryCycleDependencies(results7);
     expect(dep0, hasLength(1)); // dart:core
     expect(dep1, hasLength(1)); // dart:core
     expect(dep2, hasLength(1)); // dart:core
     expect(dep3, hasLength(1)); // dart:core
     expect(dep4, hasLength(5)); // dart:core, a.dart, aa.dart, ab.dart, b.dart
     expect(dep5, hasLength(5)); // dart:core, a.dart, aa.dart, ab.dart, b.dart
     expect(dep6, hasLength(5)); // dart:core, a.dart, aa.dart, ab.dart, b.dart
     expect(dep7, hasLength(5)); // dart:core, a.dart, aa.dart, ab.dart, b.dart
   }
 }
 
 @reflectiveTest
 class ComputePropagableVariableDependenciesTaskTest
     extends _AbstractDartTaskTest {
+  List<VariableElement> getPropagableVariableDependencies(
+      Map<ResultDescriptor, dynamic> outputs) {
+    return outputs[PROPAGABLE_VARIABLE_DEPENDENCIES] as List<VariableElement>;
+  }
+
   test_perform_instanceField() {
     AnalysisTarget source = newSource(
         '/test.dart',
         '''
 class A {
   final a = a1 + a2 + a3 + a4 + B.b1 + B.b2 + B.b3 + B.b4;
   static const a1 = 1;
   final a2 = 2;
   final a3;
   var   a4 = 4;
 }
 class B {
   static const b1 = 1;
   static final b2 = 2;
   static final b3;
   static var   b4 = 4;
 }
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, RESOLVED_UNIT5);
     CompilationUnit unit = outputs[RESOLVED_UNIT5];
     FieldElement elementA = AstFinder.getFieldInClassElement(unit, 'A', 'a');
     // compute
     computeResult(elementA, PROPAGABLE_VARIABLE_DEPENDENCIES,
         matcher: isComputePropagableVariableDependenciesTask);
     // verify
     expect(outputs, hasLength(1));
     List<VariableElement> dependencies =
-        outputs[PROPAGABLE_VARIABLE_DEPENDENCIES];
+        getPropagableVariableDependencies(outputs);
     expect(
         dependencies,
         unorderedEquals([
           AstFinder.getFieldInClassElement(unit, 'A', 'a1'),
           AstFinder.getFieldInClassElement(unit, 'A', 'a2'),
           AstFinder.getFieldInClassElement(unit, 'B', 'b1'),
           AstFinder.getFieldInClassElement(unit, 'B', 'b2')
         ]));
   }
 
@@ skipping 11 matching lines @@
     computeResult(target, RESOLVED_UNIT5);
     CompilationUnit unit = outputs[RESOLVED_UNIT5];
     TopLevelVariableElement elementA =
         AstFinder.getTopLevelVariableElement(unit, 'a');
     // compute
     computeResult(elementA, PROPAGABLE_VARIABLE_DEPENDENCIES,
         matcher: isComputePropagableVariableDependenciesTask);
     // verify
     expect(outputs, hasLength(1));
     List<VariableElement> dependencies =
-        outputs[PROPAGABLE_VARIABLE_DEPENDENCIES];
+        getPropagableVariableDependencies(outputs);
     expect(
         dependencies,
         unorderedEquals([
           AstFinder.getTopLevelVariableElement(unit, 'd1'),
           AstFinder.getTopLevelVariableElement(unit, 'd2')
         ]));
   }
 
   test_perform_topLevel_ignoreLocal() {
     AnalysisTarget source = newSource(
@@ skipping 10 matching lines @@
     computeResult(target, RESOLVED_UNIT5);
     CompilationUnit unit = outputs[RESOLVED_UNIT5];
     TopLevelVariableElement elementA =
         AstFinder.getTopLevelVariableElement(unit, 'a');
     // compute
     computeResult(elementA, PROPAGABLE_VARIABLE_DEPENDENCIES,
         matcher: isComputePropagableVariableDependenciesTask);
     // verify
     expect(outputs, hasLength(1));
     List<VariableElement> dependencies =
-        outputs[PROPAGABLE_VARIABLE_DEPENDENCIES];
+        getPropagableVariableDependencies(outputs);
     expect(dependencies,
         unorderedEquals([AstFinder.getTopLevelVariableElement(unit, 'd')]));
   }
 
   test_perform_topLevel_withoutSpaceAfterType() {
     AnalysisTarget source = newSource(
         '/test.dart',
         '''
 const List<int>a=[b, c];
 const b = 1;
 const c = 2;
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, RESOLVED_UNIT5);
     CompilationUnit unit = outputs[RESOLVED_UNIT5];
     TopLevelVariableElement elementA =
         AstFinder.getTopLevelVariableElement(unit, 'a');
     // compute
     computeResult(elementA, PROPAGABLE_VARIABLE_DEPENDENCIES,
         matcher: isComputePropagableVariableDependenciesTask);
     // verify
     expect(outputs, hasLength(1));
     List<VariableElement> dependencies =
-        outputs[PROPAGABLE_VARIABLE_DEPENDENCIES];
+        getPropagableVariableDependencies(outputs);
     expect(
         dependencies,
         unorderedEquals([
           AstFinder.getTopLevelVariableElement(unit, 'b'),
           AstFinder.getTopLevelVariableElement(unit, 'c')
         ]));
   }
 }
 
 @reflectiveTest
 class ContainingLibrariesTaskTest extends _AbstractDartTaskTest {
+  List<Source> getContainingLibraries(Map<ResultDescriptor, dynamic> outputs) {
+    return outputs[CONTAINING_LIBRARIES] as List<Source>;
+  }
+
   test_perform_definingCompilationUnit() {
     AnalysisTarget library = newSource('/test.dart', 'library test;');
     computeResult(library, INCLUDED_PARTS);
     computeResult(library, CONTAINING_LIBRARIES,
         matcher: isContainingLibrariesTask);
     expect(outputs, hasLength(1));
-    List<Source> containingLibraries = outputs[CONTAINING_LIBRARIES];
+    List<Source> containingLibraries = getContainingLibraries(outputs);
     expect(containingLibraries, unorderedEquals([library]));
   }
 
   test_perform_partInMultipleLibraries() {
     AnalysisTarget library1 =
         newSource('/lib1.dart', 'library test; part "part.dart";');
     AnalysisTarget library2 =
         newSource('/lib2.dart', 'library test; part "part.dart";');
     AnalysisTarget part = newSource('/part.dart', 'part of test;');
     computeResult(library1, INCLUDED_PARTS);
     computeResult(library2, INCLUDED_PARTS);
     computeResult(part, SOURCE_KIND);
     computeResult(part, CONTAINING_LIBRARIES,
         matcher: isContainingLibrariesTask);
     expect(outputs, hasLength(1));
-    List<Source> containingLibraries = outputs[CONTAINING_LIBRARIES];
+    List<Source> containingLibraries = getContainingLibraries(outputs);
     expect(containingLibraries, unorderedEquals([library1, library2]));
   }
 
   test_perform_partInSingleLibrary() {
     AnalysisTarget library =
         newSource('/lib.dart', 'library test; part "part.dart";');
     AnalysisTarget part = newSource('/part.dart', 'part of test;');
     computeResult(library, INCLUDED_PARTS);
     computeResult(part, SOURCE_KIND);
     computeResult(part, CONTAINING_LIBRARIES,
         matcher: isContainingLibrariesTask);
     expect(outputs, hasLength(1));
-    List<Source> containingLibraries = outputs[CONTAINING_LIBRARIES];
+    List<Source> containingLibraries = getContainingLibraries(outputs);
     expect(containingLibraries, unorderedEquals([library]));
   }
 }
 
 @reflectiveTest
 class DartErrorsTaskTest extends _AbstractDartTaskTest {
+  List<AnalysisError> getDartErrors(Map<ResultDescriptor, dynamic> outputs) {
+    return outputs[DART_ERRORS] as List<AnalysisError>;
+  }
+
   test_perform_definingCompilationUnit() {
     AnalysisTarget library =
         newSource('/test.dart', 'library test; import "dart:math";');
     computeResult(library, INCLUDED_PARTS);
     computeResult(library, DART_ERRORS, matcher: isDartErrorsTask);
     expect(outputs, hasLength(1));
-    List<AnalysisError> errors = outputs[DART_ERRORS];
+    List<AnalysisError> errors = getDartErrors(outputs);
     expect(errors, hasLength(1));
   }
 
   test_perform_partInSingleLibrary() {
     AnalysisTarget library = newSource(
         '/lib.dart', 'library test; import "dart:math"; part "part.dart";');
     AnalysisTarget part =
         newSource('/part.dart', 'part of test; class A extends A {}');
     computeResult(library, INCLUDED_PARTS);
     computeResult(library, DART_ERRORS);
     computeResult(part, DART_ERRORS, matcher: isDartErrorsTask);
     expect(outputs, hasLength(1));
-    List<AnalysisError> errors = outputs[DART_ERRORS];
+    List<AnalysisError> errors = getDartErrors(outputs);
     // This should contain only the errors in the part file, not the ones in the
     // library.
     expect(errors, hasLength(1));
   }
 }
 
 @reflectiveTest
 class EvaluateUnitConstantsTaskTest extends _AbstractDartTaskTest {
   test_created_resolved_unit() {
     Source source = newSource(
@@ skipping 943 matching lines @@
     bool ready = outputs[LIBRARY_ERRORS_READY];
     expect(ready, isTrue);
     expect(context.getErrors(library).errors, hasLength(1));
     expect(context.getErrors(part1).errors, hasLength(1));
     expect(context.getErrors(part2).errors, hasLength(1));
   }
 }
 
 @reflectiveTest
 class LibraryUnitErrorsTaskTest extends _AbstractDartTaskTest {
+  List<AnalysisError> getLibraryUnitErrors(
+      Map<ResultDescriptor, dynamic> outputs) {
+    return outputs[LIBRARY_UNIT_ERRORS] as List<AnalysisError>;
+  }
+
   test_perform_definingCompilationUnit() {
     AnalysisTarget library =
         newSource('/test.dart', 'library test; import "dart:math";');
     computeResult(
         new LibrarySpecificUnit(library, library), LIBRARY_UNIT_ERRORS,
         matcher: isLibraryUnitErrorsTask);
     expect(outputs, hasLength(1));
-    List<AnalysisError> errors = outputs[LIBRARY_UNIT_ERRORS];
+    List<AnalysisError> errors = getLibraryUnitErrors(outputs);
     expect(errors, hasLength(1));
   }
 
   test_perform_partInSingleLibrary() {
     AnalysisTarget library =
         newSource('/lib.dart', 'library test; part "part.dart";');
     AnalysisTarget part = newSource('/part.dart', 'part of test;');
     computeResult(new LibrarySpecificUnit(library, part), LIBRARY_UNIT_ERRORS,
         matcher: isLibraryUnitErrorsTask);
     expect(outputs, hasLength(1));
-    List<AnalysisError> errors = outputs[LIBRARY_UNIT_ERRORS];
+    List<AnalysisError> errors = getLibraryUnitErrors(outputs);
     expect(errors, hasLength(0));
   }
 }
 
 @reflectiveTest
 class ParseDartTaskTest extends _AbstractDartTaskTest {
   Source source;
 
   test_perform() {
     _performParseTask(r'''
@@ skipping 152 matching lines @@
 
   void _performParseTask(String content) {
     if (content == null) {
       source = resourceProvider.getFile('/test.dart').createSource();
     } else {
       source = newSource('/test.dart', content);
     }
     computeResult(source, PARSED_UNIT, matcher: isParseDartTask);
   }
 
-  static void _assertHasCore(List<Source> sources, int lenght) {
+  static void _assertHasCore(dynamic sourceList, int lenght) {
+    List<Source> sources = sourceList as List<Source>;
     expect(sources, hasLength(lenght));
     expect(sources, contains(predicate((Source s) {
       return s.fullName.endsWith('core.dart');
     })));
   }
 }
 
 @reflectiveTest
 class PartiallyResolveUnitReferencesTaskTest extends _AbstractDartTaskTest {
   test_perform_propagable() {
@@ skipping 13 matching lines @@
   const fi1 = 1;
   final fi2 = 2;
   var   fi3 = 3;
   final fi4;
 }
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, PROPAGABLE_VARIABLES_IN_UNIT,
         matcher: isPartiallyResolveUnitReferencesTask);
     // PROPAGABLE_VARIABLES_IN_UNIT
-    List<VariableElement> variables = outputs[PROPAGABLE_VARIABLES_IN_UNIT];
+    List<VariableElement> variables =
+        outputs[PROPAGABLE_VARIABLES_IN_UNIT] as List<VariableElement>;
     expect(variables.map((v) => v.displayName),
         unorderedEquals(['t1', 't2', 'fs1', 'fs2', 'fi1', 'fi2']));
   }
 
   test_perform_strong_importExport() {
     newSource(
         '/a.dart',
         '''
 library a;
 class A<T> {
@@ skipping 46 matching lines @@
   var g = 0;
 }
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, RESOLVED_UNIT5,
         matcher: isPartiallyResolveUnitReferencesTask);
     CompilationUnit unit = outputs[RESOLVED_UNIT5];
     // INFERABLE_STATIC_VARIABLES_IN_UNIT
     {
       List<VariableElement> variables =
-          outputs[INFERABLE_STATIC_VARIABLES_IN_UNIT];
+          outputs[INFERABLE_STATIC_VARIABLES_IN_UNIT] as List<VariableElement>;
       expect(variables, hasLength(4));
       expect(variables.map((v) => v.displayName),
           unorderedEquals(['a', 'b', 'd', 'f']));
     }
     // Test the state of the AST
     TopLevelVariableDeclaration a = unit.declarations[0];
     VariableDeclaration variableA = a.variables.variables[0];
     SimpleIdentifier initializer = variableA.initializer;
     expect(initializer.staticElement, isNotNull);
   }
@@ skipping 1659 matching lines @@
 
   void setUp() {
     super.setUp();
     emptySource = newSource('/test.dart');
   }
 
   /**
    * Fill [errorListener] with [result] errors in the current [task].
    */
   void _fillErrorListener(ResultDescriptor<List<AnalysisError>> result) {
-    List<AnalysisError> errors = task.outputs[result];
+    List<AnalysisError> errors = task.outputs[result] as List<AnalysisError>;
     expect(errors, isNotNull, reason: result.name);
     errorListener = new GatheringErrorListener();
     errorListener.addAll(errors);
   }
 }