More strong mode fixes for analyzer

pkg/analyzer/lib/src/task/dart_work_manager.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_work_manager;
 
 import 'dart:collection';
 
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/generated/engine.dart'
@@ skipping 12 matching lines @@
 import 'package:analyzer/task/dart.dart';
 import 'package:analyzer/task/model.dart';
 
 /**
  * The manager for Dart specific analysis.
  */
 class DartWorkManager implements WorkManager {
   /**
    * The list of errors that are reported for raw Dart [Source]s.
    */
-  static final List<ResultDescriptor> _SOURCE_ERRORS = <ResultDescriptor>[
+  static final List<ResultDescriptor<List<AnalysisError>>> _SOURCE_ERRORS =
+      <ResultDescriptor<List<AnalysisError>>>[
     BUILD_DIRECTIVES_ERRORS,
     BUILD_LIBRARY_ERRORS,
     PARSE_ERRORS,
     SCAN_ERRORS
   ];
 
   /**
    * The list of errors that are reported for raw Dart [LibrarySpecificUnit]s.
    */
-  static final List<ResultDescriptor> _UNIT_ERRORS = <ResultDescriptor>[
+  static final List<ResultDescriptor<List<AnalysisError>>> _UNIT_ERRORS =
+      <ResultDescriptor<List<AnalysisError>>>[
     HINTS,
     LINTS,
     LIBRARY_UNIT_ERRORS,
     RESOLVE_TYPE_NAMES_ERRORS,
     RESOLVE_UNIT_ERRORS,
     STRONG_MODE_ERRORS,
     VARIABLE_REFERENCE_ERRORS,
     VERIFY_ERRORS
   ];
 
@@ skipping 117 matching lines @@
   List<AnalysisError> getErrors(Source source) {
     if (!_isDartSource(source) && source is! DartScript) {
       return AnalysisError.NO_ERRORS;
     }
     // If analysis is finished, use all the errors.
     if (analysisCache.getState(source, DART_ERRORS) == CacheState.VALID) {
       return analysisCache.getValue(source, DART_ERRORS);
     }
     // If analysis is in progress, combine all known partial results.
     List<AnalysisError> errors = <AnalysisError>[];
-    for (ResultDescriptor descriptor in _SOURCE_ERRORS) {
+    for (ResultDescriptor<List<AnalysisError>> descriptor in _SOURCE_ERRORS) {
       errors.addAll(analysisCache.getValue(source, descriptor));
     }
     for (Source library in context.getLibrariesContaining(source)) {
       LibrarySpecificUnit unit = new LibrarySpecificUnit(library, source);
-      for (ResultDescriptor descriptor in _UNIT_ERRORS) {
+      for (ResultDescriptor<List<AnalysisError>> descriptor in _UNIT_ERRORS) {
         errors.addAll(analysisCache.getValue(unit, descriptor));
       }
     }
     return errors;
   }
 
   /**
    * Returns libraries containing the given [part].
    * Maybe empty, but not null.
    */
@@ skipping 100 matching lines @@
             if (needErrors) {
               librarySourceQueue.add(target);
             }
           }
         }
       }
     }
     // Update parts in libraries.
     if (isDartLibrarySource) {
       Source library = target;
-      List<Source> includedParts = outputs[INCLUDED_PARTS];
+      List<Source> includedParts = outputs[INCLUDED_PARTS] as List<Source>;
       if (includedParts != null) {
         libraryPartsMap[library] = includedParts;
         for (Source part in includedParts) {
           List<Source> libraries =
               partLibrariesMap.putIfAbsent(part, () => <Source>[]);
           if (!libraries.contains(library)) {
             libraries.add(library);
             _invalidateContainingLibraries(part);
           }
         }
@@ skipping 155 matching lines @@
     }
   }
 
   bool _shouldErrorsBeComputed(Source source) =>
       context.shouldErrorsBeAnalyzed(source);
 
   static bool _isDartSource(AnalysisTarget target) {
     return target is Source && AnalysisEngine.isDartFileName(target.fullName);
   }
 }