Adjusts dart2js backend to handle method type arguments.

pkg/compiler/lib/src/ssa/builder.dart

 // Copyright (c) 2012, 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.
 
 import 'dart:collection';
 
 import 'package:js_runtime/shared/embedded_names.dart';
 
 import '../closure.dart';
 import '../common.dart';
@@ skipping 2576 matching lines @@
             "${localsHandler.contextClass}.");
   }
 
   /// Build a [HTypeConversion] for convertion [original] to type [type].
   ///
   /// Invariant: [type] must be valid in the context.
   /// See [LocalsHandler.substInContext].
   HInstruction buildTypeConversion(
       HInstruction original, DartType type, int kind) {
     if (type == null) return original;
+    // TODO(eernst): The following statement was added for parsing and ignoring
+    // method type variables; must be generalized for full support of generic
+    // methods.
+    type = type.eraseMethodTypeVariableType;
     type = type.unaliased;
     assert(assertTypeInContext(type, original));
     if (type.isInterfaceType && !type.treatAsRaw) {
       TypeMask subtype = new TypeMask.subtype(type.element, compiler.world);
       HInstruction representations = buildTypeArgumentRepresentations(type);
       add(representations);
       return new HTypeConversion.withTypeRepresentation(
           type, kind, subtype, original, representations);
     } else if (type.isTypeVariable) {
       TypeMask subtype = original.instructionType;
@@ skipping 2158 matching lines @@
         // never built standalone, so in that case [target] is not
         // the [member] itself.
         (member.isField && member != target)) {
       // The type variable is stored in a parameter of the method.
       return localsHandler.readLocal(typeVariableLocal,
           sourceInformation: sourceInformation);
     } else if (member.isInstanceMember) {
       // The type variable is stored on the object.
       return readTypeVariable(member.enclosingClass, type.element,
           sourceInformation: sourceInformation);
+    } else if (type is MethodTypeVariableType) {

[Johnni Winther, 2016/05/17 10:27:05]

When is this used?

[eernst, 2016/05/17 14:48:54]

I believe that it is not used any more: with the new approach, every
`MethodTypeVariableType` has been replaced by a `DynamicType` when this point is
reached. Rerunning tests confirm that there are no known situations where it is
needed. Removed the whole `else if (..) {..}` such that the pre-previous-CL form
of `addTypeVariableReference` is restored.

+      // TODO(eernst): The enclosing `else if` was added to provide minimal
+      // support for generic methods: The method type arguments are always
+      // pretending to have the value `dynamic`. Revise for full support.
+      DynamicType type = const DynamicType();
+      JavaScriptBackend backend = compiler.backend;
+      ClassElement cls = backend.helpers.DynamicRuntimeType;
+      HInstruction instruction =
+          new HDynamicType(type, new TypeMask.exact(cls, compiler.world));
+      add(instruction);
+      return instruction;
     } else {
       reporter.internalError(
           type.element, 'Unexpected type variable in static context.');
       return null;
     }
   }
 
   HInstruction analyzeTypeArgument(DartType argument,
       {SourceInformation sourceInformation}) {
     assert(assertTypeInContext(argument));
@@ skipping 3821 matching lines @@
   const _LoopTypeVisitor();
   int visitNode(ast.Node node) => HLoopBlockInformation.NOT_A_LOOP;
   int visitWhile(ast.While node) => HLoopBlockInformation.WHILE_LOOP;
   int visitFor(ast.For node) => HLoopBlockInformation.FOR_LOOP;
   int visitDoWhile(ast.DoWhile node) => HLoopBlockInformation.DO_WHILE_LOOP;
   int visitAsyncForIn(ast.AsyncForIn node) => HLoopBlockInformation.FOR_IN_LOOP;
   int visitSyncForIn(ast.SyncForIn node) => HLoopBlockInformation.FOR_IN_LOOP;
   int visitSwitchStatement(ast.SwitchStatement node) =>
       HLoopBlockInformation.SWITCH_CONTINUE_LOOP;
 }