Reduce strong mode errors and warnings

pkg/front_end/lib/src/fasta/testing/kernel_chain.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.md file.
 
 // TODO(ahe): Copied from closure_conversion branch of kernel, remove this file
 // when closure_conversion is merged with master.
 
 library kernel.testing.kernel_chain;
 
 import 'dart:async' show
@@ skipping 170 matching lines @@
       target.performModularTransformations(program);
       target.performGlobalTransformations(program);
       return pass(program);
     } catch (e, s) {
       return crash(e, s);
     }
   }
 }
 
 
-class Print extends Step<Program, Program, dynamic> {
+class Print extends Step<Program, Program, TestContext> {
   const Print();
 
   String get name => "print";
 
   Future<Result<Program>> run(Program program, _) async {
     StringBuffer sb = new StringBuffer();
     for (Library library in program.libraries) {
       Printer printer = new Printer(sb);
       if (library.importUri.scheme != "dart" &&
           library.importUri.scheme != "package") {
         printer.writeLibraryFile(library);
       }
     }
     print("$sb");
     return pass(program);
   }
 }
 
-class Verify extends Step<Program, Program, dynamic> {
+class Verify extends Step<Program, Program, TestContext> {
   final bool fullCompile;
 
   const Verify(this.fullCompile);
 
   String get name => "verify";
 
   Future<Result<Program>> run(Program program, TestContext testContext) async {
     try {
       program.accept(new VerifyingVisitor()..isOutline = !fullCompile);
       return pass(program);
     } catch (e, s) {
       return new Result<Program>(
           null, testContext.expectationSet["VerificationError"], e, s);
     }
   }
 }
 
-class MatchExpectation extends Step<Program, Program, dynamic> {
+class MatchExpectation extends Step<Program, Program, TestContext> {
   final String suffix;
 
   // TODO(ahe): This is true by default which doesn't match well with the class
   // name.
   final bool updateExpectations;
 
   const MatchExpectation(this.suffix, {this.updateExpectations: true});
 
   String get name => "match expectations";
 
@@ skipping 28 matching lines @@
       });
       return pass(program);
     } else {
       return fail(program, """
 Please create file ${expectedFile.path} with this content:
 $buffer""");
     }
   }
 }
 
-class WriteDill extends Step<Program, Uri, dynamic> {
+class WriteDill extends Step<Program, Uri, TestContext> {
   const WriteDill();
 
   String get name => "write .dill";
 
   Future<Result<Uri>> run(Program program, _) async {
     Directory tmp = await Directory.systemTemp.createTemp();
     Uri uri = tmp.uri.resolve("generated.dill");
     File generated = new File.fromUri(uri);
     IOSink sink = generated.openWrite();
     try {
       new BinaryPrinter(sink).writeProgramFile(program);
     } catch (e, s) {
       return fail(uri, e, s);
     } finally {
       print("Wrote `${generated.path}`");
       await sink.close();
     }
     return pass(uri);
   }
 }
 
-class ReadDill extends Step<Uri, Uri, dynamic> {
+class ReadDill extends Step<Uri, Uri, TestContext> {
   const ReadDill();
 
   String get name => "read .dill";
 
   Future<Result<Uri>> run(Uri uri, _) async {
     try {
       loadProgramFromBinary(uri.toFilePath());
     } catch (e, s) {
       return fail(uri, e, s);
     }
     return pass(uri);
   }
 }
 
-class Copy extends Step<Program, Program, dynamic> {
+class Copy extends Step<Program, Program, TestContext> {
   const Copy();
 
   String get name => "copy program";
 
   Future<Result<Program>> run(Program program, _) async {
     BytesCollector sink = new BytesCollector();
     new BinaryPrinter(sink).writeProgramFile(program);
     Uint8List bytes = sink.collect();
     BinaryLoader loader = new BinaryLoader(new Repository());
     return pass(new BinaryBuilder(loader, bytes).readProgramFile());
@@ skipping 56 matching lines @@
 
 Future openWrite(Uri uri, f(IOSink sink)) async {
   IOSink sink = new File.fromUri(uri).openWrite();
   try {
     await f(sink);
   } finally {
     await sink.close();
   }
   print("Wrote $uri");
 }