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

pkg/kernel/test/type_parser.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.
 // A very simple parser for a subset of DartTypes for use in testing type
 // algebra.
 library kernel.test.type_parser;
 
 import 'package:kernel/kernel.dart';
 import 'package:kernel/text/ast_to_text.dart';
 
@@ skipping 156 matching lines @@
         var returnType = parseType();
         popTypeParameters(typeParameters);
         return new FunctionType(parameters, returnType,
             typeParameters: typeParameters, namedParameters: namedParameters);
 
       default:
         return fail('Unexpected token: $tokenText');
     }
   }
 
-  void parseParameterList(
-      List<DartType> positional, List<NamedType> named) {
+  void parseParameterList(List<DartType> positional, List<NamedType> named) {
     int token = scanToken();
     assert(token == Token.LeftParen);
     token = peekToken();
     while (token != Token.RightParen) {
       var type = parseType(); // Could be a named parameter name.
       token = scanToken();
       if (token == Token.Colon) {
         String name = convertTypeToParameterName(type);
         named.add(new NamedType(name, parseType()));
         token = scanToken();
@@ skipping 19 matching lines @@
 
   List<DartType> parseTypeList(int open, int close) {
     int token = scanToken();
     assert(token == open);
     List<DartType> types = <DartType>[];
     token = peekToken();
     while (token != close) {
       types.add(parseType());
       token = scanToken();
       if (token != Token.Comma && token != close) {
-        return fail('Unterminated list');
+        throw fail('Unterminated list');
       }
     }
     return types;
   }
 
   List<DartType> parseOptionalList(int open, int close) {
     if (peekToken() != open) return null;
     return parseTypeList(open, close);
   }
 
   List<DartType> parseOptionalTypeArgumentList() {
     return parseOptionalList(Token.LeftAngle, Token.RightAngle);
   }
 
   void popTypeParameters(List<TypeParameter> typeParameters) {
     typeParameters.forEach(localTypeParameters.remove);
   }
 
   List<TypeParameter> parseAndPushTypeParameterList() {
     int token = scanToken();
     assert(token == Token.LeftAngle);
     List<TypeParameter> typeParameters = <TypeParameter>[];
     token = peekToken();
     while (token != Token.RightAngle) {
       typeParameters.add(parseAndPushTypeParameter());
       token = scanToken();
       if (token != Token.Comma && token != Token.RightAngle) {
-        return fail('Unterminated type parameter list');
+        throw fail('Unterminated type parameter list');
       }
     }
     return typeParameters;
   }
 
   TypeParameter parseAndPushTypeParameter() {
     var nameTok = scanToken();
     if (nameTok != Token.Name) return fail('Expected a name');
     var typeParameter = new TypeParameter(tokenText);
     if (localTypeParameters.containsKey(typeParameter.name)) {
@@ skipping 11 matching lines @@
   }
 
   dynamic fail(String message) {
     throw '$message at index $index';
   }
 }
 
 class LazyTypeEnvironment {
   final Map<String, Class> classes = <String, Class>{};
   final Map<String, TypeParameter> typeParameters = <String, TypeParameter>{};
-  final Library dummyLibrary = new Library(new Uri(path: 'dummy.dart'),
-    name: 'lib');
+  final Library dummyLibrary =
+      new Library(new Uri(path: 'dummy.dart'), name: 'lib');
 
   TreeNode lookup(String name) {
     return name.length == 1
         ? typeParameters.putIfAbsent(name, () => new TypeParameter(name))
         : classes.putIfAbsent(name, () => makeClass(name));
   }
 
   Class makeClass(String name) {
     var class_ = new Class(name: name);
     dummyLibrary.addClass(class_);
@@ skipping 25 matching lines @@
 void main(List<String> args) {
   if (args.length != 1) {
     print('Usage: type_parser TYPE');
   }
   var environment = new LazyTypeEnvironment();
   var type = parseDartType(args[0], environment.lookup);
   var buffer = new StringBuffer();
   new Printer(buffer).writeType(type);
   print(buffer);
 }