Make pub strong-mode clean.

lib/src/package_graph.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 'package:collection/collection.dart';
+
 import 'barback/transformer_cache.dart';
 import 'entrypoint.dart';
 import 'lock_file.dart';
 import 'package.dart';
 import 'solver/version_solver.dart';
 import 'source/cached.dart';
-import 'utils.dart';
 
 /// A holistic view of the entire transitive dependency graph for an entrypoint.
 class PackageGraph {
   /// The entrypoint.
   final Entrypoint entrypoint;
 
   /// The entrypoint's lockfile.
   ///
   /// This describes the sources and resolved descriptions of everything in
   /// [packages].
@@ skipping 13 matching lines @@
   TransformerCache _transformerCache;
 
   PackageGraph(this.entrypoint, this.lockFile, this.packages);
 
   /// Creates a package graph using the data from [result].
   ///
   /// This is generally faster than loading a package graph from scratch, since
   /// the packages' pubspecs are already fully-parsed.
   factory PackageGraph.fromSolveResult(Entrypoint entrypoint,
       SolveResult result) {
-    var packages = new Map.fromIterable(result.packages,
+    var packages = new Map<String, Package>.fromIterable(result.packages,
         key: (id) => id.name,
         value: (id) {
       if (id.name == entrypoint.root.name) return entrypoint.root;
 
       return new Package(result.pubspecs[id.name],
           entrypoint.cache.source(id.source).getDirectory(id));
     });
 
     return new PackageGraph(entrypoint, result.lockFile, packages);
   }
@@ skipping 15 matching lines @@
 
   /// Returns all transitive dependencies of [package].
   ///
   /// For the entrypoint this returns all packages in [packages], which includes
   /// dev and override. For any other package, it ignores dev and override
   /// dependencies.
   Set<Package> transitiveDependencies(String package) {
     if (package == entrypoint.root.name) return packages.values.toSet();
 
     if (_transitiveDependencies == null) {
-      var closure = transitiveClosure(mapMap(packages,
-          value: (_, package) => package.dependencies.map((dep) => dep.name)));
-      _transitiveDependencies = mapMap(closure,
-          value: (_, names) => names.map((name) => packages[name]).toSet());
+      var closure = transitiveClosure(
+          mapMap/*<String, Package, String, Iterable<String>>*/(
+              packages,
+              value: (_, package) =>
+                  package.dependencies.map((dep) => dep.name)));
+      _transitiveDependencies =
+          mapMap/*<String, Set<String>, String, Set<Package>>*/(
+              closure,
+              value: (depender, names) {
+                var set = names.map((name) => packages[name]).toSet();
+                set.add(packages[depender]);
+                return set;
+              });
     }
 
     return _transitiveDependencies[package];
   }
 
   /// Returns whether [package], or any of its transitive dependencies, have
   /// transformers that run on any of their public assets.
   ///
   /// This is pessimistic; if any package can't be determined to be transformed,
   /// this returns `true`.
@@ skipping 51 matching lines @@
   ///
   /// Note that a static package isn't the same as an immutable package (see
   /// [isPackageMutable]).
   bool isPackageStatic(String package) {
     var id = lockFile.packages[package];
     if (id == null) return false;
     if (entrypoint.cache.source(id.source) is! CachedSource) return false;
     return packages[package].pubspec.transformers.isEmpty;
   }
 }