Enable strong-mode for pkg/kernel and fix some strong-mode warnings.

pkg/kernel/lib/transformations/continuation.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.
 
 library kernel.transformations.continuation;
 
 import 'dart:math' as math;
 
 import '../ast.dart';
 import '../visitor.dart';
@@ skipping 135 matching lines @@
     // The body will insert calls to
     //    :iterator.current_=
     //    :iterator.isYieldEach=
     // and return `true` as long as it did something and `false` when it's done.
     return enclosingFunction.body.accept(this);
   }
 
   visitYieldStatement(YieldStatement node) {
     var transformedExpression = node.expression.accept(this);
 
-    var statements = [];
+    var statements = <Statement>[];
     if (node.isYieldStar) {
       var markYieldEach = new ExpressionStatement(new PropertySet(
           new VariableGet(iteratorVariable),
           new Name("isYieldEach", helper.coreLibrary),
           new BoolLiteral(true)));
       statements.add(markYieldEach);
     }
 
     var setCurrentIteratorValue = new ExpressionStatement(new PropertySet(
         new VariableGet(iteratorVariable),
@@ skipping 324 matching lines @@
         new Block(initializers), new Block(updates)));
 
     LabeledStatement labeled = new LabeledStatement(null);
     if (cond != null) {
       loopBody.addAll(condEffects);
     } else {
       cond = new BoolLiteral(true);
     }
     loopBody.add(
         new IfStatement(cond, new Block(newBody), new BreakStatement(labeled)));
-    labeled.body =
-        new WhileStatement(new BoolLiteral(true), new Block(loopBody))
-        ..parent = labeled;
+    labeled.body = new WhileStatement(
+        new BoolLiteral(true), new Block(loopBody))..parent = labeled;
     statements.add(new Block(<Statement>[]
       ..addAll(temps)
       ..add(labeled)));
     return null;
   }
 
   TreeNode visitForInStatement(ForInStatement stmt) {
     if (stmt.isAsync) {
       // Transform
       //
@@ skipping 310 matching lines @@
       this.awaitHelper);
 
   factory HelperNodes.fromProgram(Program program) {
     Library findLibrary(String name) {
       Uri uri = Uri.parse(name);
       for (var library in program.libraries) {
         if (library.importUri == uri) return library;
       }
       throw 'Library "$name" not found';
     }
+
     Class findClass(Library library, String name) {
       for (var klass in library.classes) {
         if (klass.name == name) return klass;
       }
       throw 'Class "$name" not found';
     }
+
     Procedure findFactoryConstructor(Class klass, String name) {
       for (var procedure in klass.procedures) {
         if (procedure.isStatic && procedure.name.name == name) return procedure;
       }
       throw 'Factory constructor "$klass.$name" not found';
     }
+
     Constructor findConstructor(Class klass, String name) {
       for (var constructor in klass.constructors) {
         if (constructor.name.name == name) return constructor;
       }
       throw 'Constructor "$klass.$name" not found';
     }
+
     Procedure findProcedure(Library library, String name) {
       for (var procedure in library.procedures) {
         if (procedure.name.name == name ||
             procedure.name.name == '${library.name}::${name}') {
           return procedure;
         }
       }
       throw 'Procedure "$name" not found';
     }
 
@@ skipping 28 matching lines @@
         findFactoryConstructor(completerClass, 'sync'),
         findConstructor(syncIterableClass, ''),
         findConstructor(streamIteratorClass, ''),
         findFactoryConstructor(futureClass, 'microtask'),
         findConstructor(streamControllerClass, ''),
         findProcedure(asyncLibrary, '_asyncThenWrapperHelper'),
         findProcedure(asyncLibrary, '_asyncErrorWrapperHelper'),
         findProcedure(asyncLibrary, '_awaitHelper'));
   }
 }