[kernel] Support for top-level generic functions.

pkg/kernel/lib/transformations/closure/converter.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.closure.converter;
 
 import '../../ast.dart'
     show
         Arguments,
         Block,
@@ skipping 32 matching lines @@
         Statement,
         StaticInvocation,
         ThisExpression,
         Transformer,
         TreeNode,
         TypeParameter,
         TypeParameterType,
         VariableDeclaration,
         VariableGet,
         VariableSet,
+        VectorCreation,
         VectorType,
         transformList;
 
 import '../../frontend/accessors.dart' show VariableAccessor;
 
 import '../../clone.dart' show CloneVisitor;
 
 import '../../core_types.dart' show CoreTypes;
 
 import '../../type_algebra.dart' show substitute;
@@ skipping 375 matching lines @@
                 substitute(decl.type, closureTypeSubstitutionMap))
             .toList(),
         substitute(function.returnType, closureTypeSubstitutionMap),
         namedParameters: function.namedParameters
             .map((VariableDeclaration decl) => new NamedType(
                 decl.name, substitute(decl.type, closureTypeSubstitutionMap)))
             .toList(),
         typeParameters: closureTypeParams,
         requiredParameterCount: function.requiredParameterCount - 1);
 
+    // If we capture type parameters but not regular variables, we still need to
+    // make a context.
+    if (capturedTypeVariables[function] != null &&
+        accessContext is NullLiteral) {
+      accessContext = new VectorCreation(1);
+    }
+
     return new ClosureCreation(
         closedTopLevelFunction, accessContext, closureType, fnTypeArgs);
   }
 
   TreeNode visitProcedure(Procedure node) {
     assert(isEmptyContext);
 
     currentMember = node;
 
     FunctionNode function = node.function;
@@ skipping 275 matching lines @@
     return new FunctionNode(new ReturnStatement(invocation),
         typeParameters: typeParameters,
         positionalParameters: positionalParameters,
         namedParameters: namedParameters,
         requiredParameterCount: requiredParameterCount,
         returnType: substitute(function.returnType, cloner.typeSubstitution));
   }
 
   /// Creates copies of the type variables in [original] and returns a
   /// substitution that can be passed to [substitute] to substitute all uses of
-  /// [original] with their copies. Additionally returns a list of new type
-  /// parameters to prefix to the enclosing function's type parameters and the
-  /// arguments to be passed for those parameters.
+  /// [original] with their copies.
   ///
   Map<TypeParameter, DartType> copyTypeVariables(
       Iterable<TypeParameter> original) {
     if (original.isEmpty) return const <TypeParameter, DartType>{};
 
     Map<TypeParameter, DartType> substitution = <TypeParameter, DartType>{};
     for (TypeParameter t in original) {
       substitution[t] = new TypeParameterType(new TypeParameter(t.name));
     }
 
@@ skipping 27 matching lines @@
     copy.function.body.parent = copy.function;
     return copy;
   }
 
   void addGetterForwarder(Name name, Procedure getter) {
     assert(getter.isGetter);
     newClassMembers
         .add(copyWithBody(getter, forwardToThisProperty(getter))..name = name);
   }
 }