Make pub strong-mode clean.

lib/src/barback/load_all_transformers.dart

 // Copyright (c) 2013, 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 'dart:async';
 
 import 'package:barback/barback.dart';
 
 import '../log.dart' as log;
 import '../package_graph.dart';
@@ skipping 14 matching lines @@
 /// automatically be added to the end of the root package's cascade.
 ///
 /// If [entrypoints] is passed, only transformers necessary to run those
 /// entrypoints will be loaded.
 Future loadAllTransformers(AssetEnvironment environment,
     BarbackServer transformerServer, {Iterable<AssetId> entrypoints}) async {
   var dependencyComputer = new DependencyComputer(environment.graph);
 
   // If we only need to load transformers for a specific set of entrypoints,
   // remove any other transformers from [transformersNeededByTransformers].
-  var necessaryTransformers;
+  Set<TransformerId> necessaryTransformers;
   if (entrypoints != null) {
     if (entrypoints.isEmpty) return;
 
     necessaryTransformers = unionAll(entrypoints.map(
         dependencyComputer.transformersNeededByLibrary));
 
     if (necessaryTransformers.isEmpty) {
       log.fine("No transformers are needed for ${toSentence(entrypoints)}.");
       return;
     }
@@ skipping 73 matching lines @@
 /// Given [transformerDependencies], a directed acyclic graph, returns a list of
 /// "stages" (sets of transformers).
 ///
 /// Each stage must be fully loaded and passed to barback before the next stage
 /// can be safely loaded. However, transformers within a stage can be safely
 /// loaded in parallel.
 List<Set<TransformerId>> _stageTransformers(
     Map<TransformerId, Set<TransformerId>> transformerDependencies) {
   // A map from transformer ids to the indices of the stages that those
   // transformer ids should end up in. Populated by [stageNumberFor].
-  var stageNumbers = {};
-  var stages = [];
+  var stageNumbers = <TransformerId, int>{};
+  var stages = <Set<TransformerId>>[];
 
-  stageNumberFor(id) {
+  stageNumberFor(TransformerId id) {
     // Built-in transformers don't have to be loaded in stages, since they're
     // run from pub's source. Return -1 so that the "next stage" is 0.
     if (id.isBuiltInTransformer) return -1;
 
     if (stageNumbers.containsKey(id)) return stageNumbers[id];
     var dependencies = transformerDependencies[id];
     stageNumbers[id] = dependencies.isEmpty ?
         0 : maxAll(dependencies.map(stageNumberFor)) + 1;
     return stageNumbers[id];
   }
 
   for (var id in transformerDependencies.keys) {
     var stageNumber = stageNumberFor(id);
     if (stages.length <= stageNumber) stages.length = stageNumber + 1;
     if (stages[stageNumber] == null) stages[stageNumber] = new Set();
     stages[stageNumber].add(id);
   }
 
   return stages;
 }
 
 /// Returns a map from transformer ids to all packages in [graph] that use each
 /// transformer.
 Map<TransformerId, Set<String>> _packagesThatUseTransformers(
     PackageGraph graph) {
-  var results = {};
+  var results = <TransformerId, Set<String>>{};
   for (var package in graph.packages.values) {
     for (var phase in package.pubspec.transformers) {
       for (var config in phase) {
         results.putIfAbsent(config.id, () => new Set()).add(package.name);
       }
     }
   }
   return results;
 }