Fix all strong-mode warnings.

test/utils.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.
 
 library barback.test.utils;
 
 import 'dart:async';
 import 'dart:convert' show Encoding;
 
 import 'package:barback/barback.dart';
@@ skipping 96 matching lines @@
   // There should be one successful build after adding all the transformers but
   // before adding any sources.
   if (!transformers.isEmpty) buildShouldSucceed();
 }
 
 /// Updates [assets] in the current [PackageProvider].
 ///
 /// Each item in the list may either be an [AssetId] or a string that can be
 /// parsed as one.
 void updateSources(Iterable assets) {
-  assets = _parseAssets(assets);
-  schedule(() => _barback.updateSources(assets),
-      "updating ${assets.join(', ')}");
+  var parsed = _parseAssets(assets);
+  schedule(() => _barback.updateSources(parsed),
+      "updating ${parsed.join(', ')}");
 }
 
 /// Updates [assets] in the current [PackageProvider].
 ///
 /// Each item in the list may either be an [AssetId] or a string that can be
 /// parsed as one. Unlike [updateSources], this is not automatically scheduled
 /// and will be run synchronously when called.
 void updateSourcesSync(Iterable assets) =>
     _barback.updateSources(_parseAssets(assets));
 
 /// Removes [assets] from the current [PackageProvider].
 ///
 /// Each item in the list may either be an [AssetId] or a string that can be
 /// parsed as one.
 void removeSources(Iterable assets) {
-  assets = _parseAssets(assets);
-  schedule(() => _barback.removeSources(assets),
-      "removing ${assets.join(', ')}");
+  var parsed = _parseAssets(assets);
+  schedule(() => _barback.removeSources(parsed),
+      "removing ${parsed.join(', ')}");
 }
 
 /// Removes [assets] from the current [PackageProvider].
 ///
 /// Each item in the list may either be an [AssetId] or a string that can be
 /// parsed as one. Unlike [removeSources], this is not automatically scheduled
 /// and will be run synchronously when called.
 void removeSourcesSync(Iterable assets) =>
     _barback.removeSources(_parseAssets(assets));
 
 /// Sets the transformers for [package] to [transformers].
 void updateTransformers(String package, Iterable<Iterable> transformers) {
   schedule(() => _barback.updateTransformers(package, transformers),
       "updating transformers for $package");
 }
 
 /// Parse a list of strings or [AssetId]s into a list of [AssetId]s.
 List<AssetId> _parseAssets(Iterable assets) {
   return assets.map((asset) {
     if (asset is String) return new AssetId.parse(asset);
-    return asset;
+    return asset as AssetId;
   }).toList();
 }
 
 /// Schedules a change to the contents of an asset identified by [name] to
 /// [contents].
 ///
 /// Does not update it in the graph.
 void modifyAsset(String name, String contents) {
   schedule(() {
     _provider._modifyAsset(name, contents);
@@ skipping 34 matching lines @@
 void buildShouldNotBeDone() {
   _futureShouldNotCompleteUntil(
       _barback.results.elementAt(_nextBuildResult),
       schedule(() => pumpEventQueue(), "build should not terminate"),
       "build");
 }
 
 /// Expects that the next [BuildResult] is a build success.
 void buildShouldSucceed() {
   expect(_getNextBuildResult("build should succeed").then((result) {
-    result.errors.forEach(currentSchedule.signalError);
+    for (var error in result.errors) {
+      currentSchedule.signalError(error);
+    }
     expect(result.succeeded, isTrue);
   }), completes);
 }
 
 /// Expects that the next [BuildResult] emitted is a failure.
 ///
 /// [matchers] is a list of matchers to match against the errors that caused the
 /// build to fail. Every matcher is expected to match an error, but the order of
 /// matchers is unimportant.
 void buildShouldFail(List matchers) {
@@ skipping 287 matching lines @@
   }
 
   MockProvider(assets, {Iterable<String> staticPackages,
           Iterable<String> additionalPackages})
       : staticPackages = staticPackages == null ? new Set() :
             staticPackages.toSet(),
         _assets = _normalizeAssets(assets, additionalPackages);
 
   static Map<String, AssetSet> _normalizeAssets(assets,
       Iterable<String> additionalPackages) {
-    var assetList;
+    Iterable<Asset> assetList;
     if (assets is Map) {
       assetList = assets.keys.map((asset) {
         var id = new AssetId.parse(asset);
         return new _MockAsset(id, assets[asset]);
       });
     } else if (assets is Iterable) {
       assetList = assets.map((asset) {
         var id = new AssetId.parse(asset);
         var contents = pathos.basenameWithoutExtension(id.path);
         return new _MockAsset(id, contents);
       });
     }
 
-    var assetMap = mapMapValues(groupBy(assetList, (asset) => asset.id.package),
-        (package, assets) => new AssetSet.from(assets));
+    var assetMap = mapMapValues/*<String, List<Asset>, AssetSet>*/(

[Bob Nystrom, 2016/05/13 21:07:50]

Does the inference not cover this case? If not, it might be worth filing a bug
to see if it can be improved.

[nweiz, 2016/05/17 17:27:46]

Looks like it's working now!

+        groupBy(assetList, (asset) => asset.id.package),
+        (_, assets) => new AssetSet.from(assets));
 
     // Make sure that packages that have transformers but no assets are
     // considered by MockProvider to exist.
     if (additionalPackages != null) {
       for (var package in additionalPackages) {
         assetMap.putIfAbsent(package, () => new AssetSet());
       }
     }
 
     // If there are no assets or transformers, add a dummy package. This better
     // simulates the real world, where there'll always be at least the
     // entrypoint package.
     return assetMap.isEmpty ? {"app": new AssetSet()} : assetMap;
   }
 
   void _modifyAsset(String name, String contents) {
     var id = new AssetId.parse(name);
     _errors.remove(id);
     _syncErrors.remove(id);
     (_assets[id.package][id] as _MockAsset).contents = contents;
   }
 
   void _setAssetError(String name, bool async) {
     (async ? _errors : _syncErrors).add(new AssetId.parse(name));
   }
 
   Stream<AssetId> getAllAssetIds(String package) =>
       new Stream.fromIterable(_assets[package].map((asset) => asset.id));
 
-  Future<Asset> getAsset(AssetId id) {
+  Future<Asset> getAsset(AssetId id) async {
     // Eagerly load the asset so we can test an asset's value changing between
     // when a load starts and when it finishes.
     var assets = _assets[id.package];
     var asset;
     if (assets != null) asset = assets[id];
 
     if (_syncErrors.contains(id)) throw new MockLoadException(id);
     var hasError = _errors.contains(id);
 
-    var future;
-    if (_pauseCompleter != null) {
-      future = _pauseCompleter.future;
-    } else {
-      future = new Future.value();
-    }
+    if (_pauseCompleter != null) await _pauseCompleter.future;
 
-    return future.then((_) {
-      if (hasError) throw new MockLoadException(id);
-      if (asset == null) throw new AssetNotFoundException(id);
-      return asset;
-    });
+    if (hasError) throw new MockLoadException(id);
+    if (asset == null) throw new AssetNotFoundException(id);
+    return asset;
   }
 }
 
 /// Error thrown for assets with [setAssetError] set.
 class MockLoadException implements Exception {
   final AssetId id;
 
   MockLoadException(this.id);
 
   String toString() => "Error loading $id.";
 }
 
 /// An implementation of [Asset] that never hits the file system.
 class _MockAsset implements Asset {
   final AssetId id;
   String contents;
 
   _MockAsset(this.id, this.contents);
 
   Future<String> readAsString({Encoding encoding}) =>
       new Future.value(contents);
 
   Stream<List<int>> read() => throw new UnimplementedError();
 
   String toString() => "MockAsset $id $contents";
 }