Fix all strong-mode errors and warnings.

lib/src/runner/configuration/load.dart

 // Copyright (c) 2016, 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:io';
 
 import 'package:boolean_selector/boolean_selector.dart';
 import 'package:glob/glob.dart';
 import 'package:path/path.dart' as p;
 import 'package:source_span/source_span.dart';
@@ skipping 272 matching lines @@
       _getValue(field, "boolean", (value) => value is bool);
 
   /// Asserts that [field] is a string and returns its value.
   String _getString(String field) =>
       _getValue(field, "string", (value) => value is String);
 
   /// Asserts that [field] is a list and runs [forElement] for each element it
   /// contains.
   ///
   /// Returns a list of values returned by [forElement].
-  List _getList(String field, forElement(YamlNode elementNode)) {
-    var node = _getNode(field, "list", (value) => value is List);
+  List/*<T>*/ _getList/*<T>*/(String field,
+      /*=T*/ forElement(YamlNode elementNode)) {
+    var node = _getNode(field, "list", (value) => value is List) as YamlList;
     if (node == null) return [];
     return node.nodes.map(forElement).toList();
   }
 
   /// Asserts that [field] is a map and runs [key] and [value] for each pair.
   ///
   /// Returns a map with the keys and values returned by [key] and [value]. Each
   /// of these defaults to asserting that the value is a string.
-  Map _getMap(String field, {key(YamlNode keyNode),
-      value(YamlNode valueNode)}) {
-    var node = _getNode(field, "map", (value) => value is Map);
+  Map/*<K, V>*/ _getMap/*<K, V>*/(String field, {/*=K*/ key(YamlNode keyNode),
+      /*=V*/ value(YamlNode valueNode)}) {
+    var node = _getNode(field, "map", (value) => value is Map) as YamlMap;
     if (node == null) return {};
 
     key ??= (keyNode) {
       _validate(keyNode, "$field keys must be strings.",
           (value) => value is String);
 
-      return keyNode.value;
+      return keyNode.value as dynamic/*=K*/;
     };
 
     value ??= (valueNode) {
       _validate(valueNode, "$field values must be strings.",
           (value) => value is String);
 
-      return valueNode.value;
+      return valueNode.value as dynamic/*=V*/;
     };
 
     return mapMap(node.nodes,
         key: (keyNode, _) => key(keyNode),
         value: (_, valueNode) => value(valueNode));
   }
 
   /// Verifies that [node]'s value is an optionally hyphenated Dart identifier,
   /// and returns it
   String _parseIdentifierLike(YamlNode node, String name) {
     _validate(node, "$name must be a string.", (value) => value is String);
     _validate(
         node,
         "$name must be an (optionally hyphenated) Dart identifier.",
         (value) => value.contains(anchoredHyphenatedIdentifier));
     return node.value;
   }
 
   /// Parses [node]'s value as a boolean selector.
   BooleanSelector _parseBooleanSelector(String name) =>
       _parseValue(name, (value) => new BooleanSelector.parse(value));
 
   /// Asserts that [node] is a string, passes its value to [parse], and returns
   /// the result.
   ///
   /// If [parse] throws a [FormatException], it's wrapped to include [node]'s
   /// span.
-  _parseNode(YamlNode node, String name, parse(String value)) {
+  /*=T*/ _parseNode/*<T>*/(YamlNode node, String name,
+      /*=T*/ parse(String value)) {
     _validate(node, "$name must be a string.", (value) => value is String);
 
     try {
       return parse(node.value);
     } on FormatException catch (error) {
       throw new SourceSpanFormatException(
           'Invalid $name: ${error.message}', node.span, _source);
     }
   }
 
   /// Asserts that [field] is a string, passes it to [parse], and returns the
   /// result.
   ///
   /// If [parse] throws a [FormatException], it's wrapped to include [field]'s
   /// span.
-  _parseValue(String field, parse(String value)) {
+  /*=T*/ _parseValue/*<T>*/(String field, /*=T*/ parse(String value)) {
     var node = _document.nodes[field];
     if (node == null) return null;
     return _parseNode(node, field, parse);
   }
 
   /// Parses a nested configuration document.
   ///
   /// [name] is the name of the field, which is used for error-handling.
   /// [runnerConfig] controls whether runner configuration is allowed in the
   /// nested configuration. It defaults to [_runnerConfig].
@@ skipping 18 matching lines @@
         _document.nodes.keys.firstWhere((key) => key.value == field).span,
         _source);
   }
 
   /// Throws a [SourceSpanFormatException] with [message] about [field].
   void _error(String message, String field) {
     throw new SourceSpanFormatException(
         message, _document.nodes[field].span, _source);
   }
 }