Implement erasure of local function declarations.

pkg/kernel/lib/transformations/erasure.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.erasure;
 
 import '../ast.dart';
 import '../type_algebra.dart';
 import '../core_types.dart';
 
 Program transformProgram(CoreTypes coreTypes, Program program) {
@@ skipping 33 matching lines @@
   }
 
   void popConstantContext() {
     --constantContexts;
   }
 
   bool get isInConstantContext => constantContexts > 0;
 
   @override
   visitDartType(DartType type) {
+    if (type is FunctionType && type.typeParameters.isNotEmpty) {
+      FunctionType function = type;
+      for (var parameter in function.typeParameters) {
+        // Note, normally, we would have to remove these substitutions again to
+        // avoid memory leaks. Unfortunately, that that's not compatible with
+        // how function types share their TypeParameter object with a
+        // FunctionNode.
+        substitution[parameter] = const DynamicType();
+      }
+      for (var parameter in function.typeParameters) {
+        if (!isObject(parameter.bound)) {
+          substitution[parameter] = substitute(parameter.bound, substitution);
+        }
+      }
+      // We need to delete the type parameters of the function type before
+      // calling [substitute], otherwise it creates a new environment with
+      // fresh type variables that shadow the ones we want to remove.  Since a
+      // FunctionType is often assumed to be immutable, we return a copy.
+      type = new FunctionType(
+          function.positionalParameters, function.returnType,
+          namedParameters: function.namedParameters,
+          requiredParameterCount: function.requiredParameterCount,
+          positionalParameterNames: function.positionalParameterNames,
+          typedefReference: function.typedefReference);
+    }
     type = substitute(type, substitution);
     if (isInConstantContext) {
       type = substitute(type, constantSubstitution);
     }
     return type;
   }
 
   @override
   visitClass(Class node) {
     for (var parameter in node.typeParameters) {
@@ skipping 87 matching lines @@
   }
 
   @override
   visitMapLiteral(MapLiteral node) {
     if (node.isConst) pushConstantContext();
     node.transformChildren(this);
     if (node.isConst) popConstantContext();
     return node;
   }
 }