Support generic methods in kernel

pkg/compiler/lib/src/kernel/kernel.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.
 
 import 'dart:async';
 import 'dart:collection' show Queue;
 
 import 'package:kernel/ast.dart' as ir;
 import 'package:kernel/verifier.dart' show CheckParentPointers;
 
@@ skipping 284 matching lines @@
 
   ir.Supertype supertypeToIr(InterfaceType type) {
     ir.Class cls = classToIr(type.element);
     if (type.typeArguments.isEmpty) {
       return cls.asRawSupertype;
     } else {
       return new ir.Supertype(cls, typesToIr(type.typeArguments));
     }
   }
 
-  // TODO(ahe): Remove this method when dart2js support generic type arguments.
-  List<ir.TypeParameter> typeParametersNotImplemented() {
-    return const <ir.TypeParameter>[];
-  }
-
   ir.FunctionType functionTypeToIr(FunctionType type) {
-    List<ir.TypeParameter> typeParameters = typeParametersNotImplemented();
+    List<ir.TypeParameter> typeParameters = <ir.TypeParameter>[];
     int requiredParameterCount = type.parameterTypes.length;
     List<ir.DartType> positionalParameters =
         new List<ir.DartType>.from(typesToIr(type.parameterTypes))
           ..addAll(typesToIr(type.optionalParameterTypes));
     List<ir.NamedType> namedParameters = new List<ir.NamedType>.generate(
         type.namedParameters.length,
         (i) => new ir.NamedType(
             type.namedParameters[i], typeToIr(type.namedParameterTypes[i])));
     ir.DartType returnType = typeToIr(type.returnType);
 
@@ skipping 133 matching lines @@
           // TODO(ahe): Add setInitializers to [ir.Constructor].
           for (ir.Initializer initializer in irFunction.initializers) {
             initializer.parent = constructor;
           }
         } else {
           assert(irFunction.kind != null);
           procedure.function = irFunction.node;
           procedure.kind = irFunction.kind;
         }
         endFactoryScope(function);
+        irFunction.node.typeParameters
+            .addAll(typeVariablesToIr(function.typeVariables));
         member.transformerFlags = visitor.transformerFlags;
         assert(() {
           visitor.locals.forEach(checkMember);
           return true;
         });
       });
       addWork(function.declaration, () {
         for (MetadataAnnotation metadata in function.declaration.metadata) {
           member.addAnnotation(
               const ConstantVisitor().visit(metadata.constant, this));
@@ skipping 74 matching lines @@
     });
   }
 
   ir.TypeParameter typeVariableToIr(TypeVariableElement variable) {
     variable = variable.declaration;
     ir.TypeParameter parameter = factoryTypeParameters[variable];
     if (parameter != null) return parameter;
     return typeParameters.putIfAbsent(variable, () {
       ir.TypeParameter parameter = new ir.TypeParameter(variable.name, null);
       addWork(variable, () {
-        // TODO(ahe): This assignment will probably not be correct when dart2js
-        // supports generic methods.
-        ClassElement cls = variable.typeDeclaration;
-        cls.ensureResolved(compiler.resolution);
-        parameter.parent = classToIr(cls);
+        if (variable.typeDeclaration.isClass) {
+          ClassElement cls = variable.typeDeclaration;
+          cls.ensureResolved(compiler.resolution);
+          parameter.parent = classToIr(cls);
+        } else {
+          FunctionElement method = variable.typeDeclaration;
+          parameter.parent = functionToIr(method).function;
+        }
         parameter.bound = typeToIr(variable.bound);
       });
       return parameter;
     });
   }
 
   List<ir.TypeParameter> typeVariablesToIr(List<DartType> variables) {
     List<ir.TypeParameter> result =
         new List<ir.TypeParameter>(variables.length);
     for (int i = 0; i < variables.length; i++) {
@@ skipping 189 matching lines @@
 }
 
 class ConstructorTarget {
   final ConstructorElement element;
   final DartType type;
 
   ConstructorTarget(this.element, this.type);
 
   String toString() => "ConstructorTarget($element, $type)";
 }