Adjusts dart2js backend to handle method type arguments.

pkg/compiler/lib/src/dart_backend/backend_ast_to_frontend_ast.dart

 // Copyright (c) 2014, 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 dart_tree_printer;
 
 import '../common.dart';
 import '../constants/values.dart' as values;
 import '../dart_types.dart' as types;
 import '../elements/elements.dart' as elements;
@@ skipping 477 matching lines @@
       tree.NodeList parameters = makeParameters(exp.parameters);
       tree.NodeList initializers =
           exp.initializers == null || exp.initializers.isEmpty
               ? null
               : makeList(",", exp.initializers.map(makeExpression).toList());
       tree.Node body = exp.isConst || exp.body == null
           ? new tree.EmptyStatement(semicolon)
           : makeFunctionBody(exp.body);
       result = new tree.FunctionExpression(
           constructorName(exp),
-          // TODO(eernst): retrieve and pass the actual type variables.
+          // GENERIC_METHODS: In order to support generic methods fully,

[karlklose, 2016/05/18 06:40:59]

Or consider filing a bug and change this to TODO(<issue number>). That way you
have already a tracking bug and it is easy to find the places that you already
know need to be changed.

[eernst, 2016/05/23 14:30:23]

(This topic was discussed and finalized outside this comment thread).

+          // we must retrieve and pass the actual type variables here.
           null, // typeVariables
           parameters,
           body,
           null, // return type
           makeFunctionModifiers(exp),
           initializers,
           null, // get/set
           null); // async modifier
       setElement(result, exp.element, exp);
     } else if (exp is FunctionExpression) {
       precedence = PRIMARY;
       if (beginStmt && exp.name != null) {
         needParen = true; // Do not mistake for function declaration.
       }
       Token getOrSet = exp.isGetter ? getToken : exp.isSetter ? setToken : null;
       tree.NodeList parameters =
           exp.isGetter ? makeList("", []) : makeParameters(exp.parameters);
       tree.Node body = makeFunctionBody(exp.body);
       result = new tree.FunctionExpression(
           functionName(exp),
-          // TODO(eernst): retrieve and pass the actual type variables.
+          // GENERIC_METHODS: In order to support generic methods fully,
+          // we must retrieve and pass the actual type variables here.
           null, // typeVariables
           parameters,
           body,
           exp.returnType == null || exp.element.isConstructor
               ? null
               : makeType(exp.returnType),
           makeFunctionModifiers(exp),
           null, // initializers
           getOrSet, // get/set
           null); // async modifier
@@ skipping 265 matching lines @@
       if (stmt.leftHandValue is Identifier) {
         left = makeExpression(stmt.leftHandValue);
       } else {
         left = makeVariableDeclarations(stmt.leftHandValue);
       }
       return new tree.SyncForIn(left, makeExpression(stmt.expression),
           makeStatement(stmt.body, shortIf: shortIf), forToken, inToken);
     } else if (stmt is FunctionDeclaration) {
       tree.FunctionExpression function = new tree.FunctionExpression(
           stmt.name != null ? makeIdentifier(stmt.name) : null,
-          // TODO(eernst): retrieve and pass the actual type variables.
+          // GENERIC_METHODS: In order to support generic methods fully,
+          // we must retrieve and pass the actual type variables here.
           null, // typeVariables
           makeParameters(stmt.parameters),
           makeFunctionBody(stmt.body),
           stmt.returnType != null ? makeType(stmt.returnType) : null,
           makeEmptyModifiers(),
           null, // initializers
           null, // get/set
           null); // async modifier
       setElement(function, stmt.function.element, stmt);
       return new tree.FunctionDeclaration(function);
@@ skipping 148 matching lines @@
       nodes.add(new tree.NodeList(open, makeLink(opt), close, ','));
     }
     return argList(nodes);
   }
 
   /// [assignOperator] is used for writing the default value.
   tree.Node makeParameter(Parameter param, [Token assignOperator]) {
     if (param.isFunction) {
       tree.Node definition = new tree.FunctionExpression(
           makeIdentifier(param.name),
-          // TODO(eernst): retrieve and pass the actual type variables.
+          // GENERIC_METHODS: In order to support generic methods fully,
+          // we must retrieve and pass the actual type variables here.
           null, // typeVariables
           makeParameters(param.parameters),
           null, // body
               param.type == null ? null : makeType(param.type),
           makeEmptyModifiers(), // TODO: Function parameter modifiers?
           null, // initializers
           null, // get/set
           null); // async modifier
       if (param.element != null) {
         setElement(definition, param.element, param);
@@ skipping 355 matching lines @@
       if (chunk.previous != null) {
         return new tree.StringJuxtaposition(
             printStringChunk(chunk.previous), node);
       } else {
         return node;
       }
     }
     return printStringChunk(output.chunk);
   }
 }