Make pub strong-mode clean.

lib/src/barback/dependency_computer.dart

 // Copyright (c) 2014, 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 'package:barback/barback.dart';
 import 'package:path/path.dart' as p;
 
 import '../dart.dart';
 import '../io.dart';
 import '../package.dart';
@@ skipping 51 matching lines @@
   /// This graph is represented by a map whose keys are the vertices and whose
   /// values are sets representing edges from the given vertex. Each vertex is a
   /// [TransformerId]. If there's an edge from `T1` to `T2`, then `T2` must be
   /// loaded before `T1` can be loaded.
   ///
   /// The returned graph is transitively closed. That is, if there's an edge
   /// from `T1` to `T2` and an edge from `T2` to `T3`, there's also an edge from
   /// `T1` to `T2`.
   Map<TransformerId, Set<TransformerId>> transformersNeededByTransformers(
       [Iterable<TransformerId> transformers]) {
-    var result = {};
+    var result = <TransformerId, Set<TransformerId>>{};
 
     if (transformers == null) {
       transformers = ordered(_graph.packages.keys).expand((packageName) {
         var package = _graph.packages[packageName];
         return package.pubspec.transformers.expand((phase) {
           return phase.expand((config) {
             var id = config.id;
             if (id.isBuiltInTransformer) return [];
             if (package.name != _graph.entrypoint.root.name &&
                 !config.canTransformPublicFiles) {
@@ skipping 72 matching lines @@
   /// (transitively) imports a transformed library. The result of the
   /// transformation may import any dependency or hit any transformer, so we
   /// have to assume that it will.
   Set<TransformerId> _transformersNeededByPackage(String rootPackage) {
     if (_untransformedPackages.contains(rootPackage)) return new Set();
 
     if (_transformersNeededByPackages.containsKey(rootPackage)) {
       return _transformersNeededByPackages[rootPackage];
     }
 
-    var results = new Set();
-    var seen = new Set();
+    var results = new Set<TransformerId>();
+    var seen = new Set<String>();
 
     traversePackage(packageName) {
       if (seen.contains(packageName)) return;
       seen.add(packageName);
 
       var package = _graph.packages[packageName];
       for (var phase in package.pubspec.transformers) {
         for (var config in phase) {
           var id = config.id;
           if (id.isBuiltInTransformer) continue;
@@ skipping 205 matching lines @@
   /// will be URIs for this package.
   ///
   /// If [rootLibrary] transitively imports or exports a library that's modified
   /// by a transformer, this will return `null`.
   Set<Uri> _getTransitiveExternalDirectives(String rootLibrary) {
     rootLibrary = p.normalize(rootLibrary);
     if (_transitiveExternalDirectives.containsKey(rootLibrary)) {
       return _transitiveExternalDirectives[rootLibrary];
     }
 
-    var results = new Set();
-    var seen = new Set();
+    var results = new Set<Uri>();
+    var seen = new Set<String>();
 
-    traverseLibrary(library) {
+    traverseLibrary(String library) {
       library = p.normalize(library);
       if (seen.contains(library)) return true;
       seen.add(library);
 
       var directives = _getDirectives(library);
       if (directives == null) return false;
 
       for (var uri in directives) {
         var path;
         if (uri.scheme == 'package') {
@@ skipping 46 matching lines @@
       return null;
     }
 
     _directives[libraryUri] =
         parseImportsAndExports(readTextFile(library), name: library)
         .map((directive) => Uri.parse(directive.uri.stringValue))
         .toSet();
     return _directives[libraryUri];
   }
 }