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 2569 matching lines @@
   bool assertTypeInContext(DartType type, [Spannable spannable]) {
     return invariant(spannable == null ? CURRENT_ELEMENT_SPANNABLE : spannable,
         () {
       ClassElement contextClass = Types.getClassContext(type);
       return contextClass == null || contextClass == localsHandler.contextClass;
     },
         message: "Type '$type' is not valid context of "
             "${localsHandler.contextClass}.");
   }
 
-  /// Build a [HTypeConversion] for convertion [original] to type [type].
+  /// Build a [HTypeConversion] for converting [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;
+    // GENERIC_METHODS: The following statement was added for parsing and
+    // ignoring method type variables; must be generalized for full support of
+    // generic methods.
+    type = type.dynamifyMethodTypeVariableType;
     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 1200 matching lines @@
           code, backend.readableArrayType, inputs,
           nativeBehavior: native.NativeBehavior.PURE_ALLOCATION);
       return representation;
     }
   }
 
   @override
   void visitAs(ast.Send node, ast.Node expression, DartType type, _) {
     HInstruction expressionInstruction = visitAndPop(expression);
     if (type.isMalformed) {
-      ErroneousElement element = type.element;
-      generateTypeError(node, element.message);
+      String message;
+      if (type is MalformedType) {
+        ErroneousElement element = type.element;
+        message = element.message;
+      } else {
+        assert(type is MethodTypeVariableType);
+        message = "Method type variables are not reified.";
+      }
+      generateTypeError(node, message);
     } else {
       HInstruction converted = buildTypeConversion(expressionInstruction,
           localsHandler.substInContext(type), HTypeConversion.CAST_TYPE_CHECK);
       if (converted != expressionInstruction) add(converted);
       stack.add(converted);
     }
   }
 
   @override
   void visitIs(ast.Send node, ast.Node expression, DartType type, _) {
     HInstruction expressionInstruction = visitAndPop(expression);
     push(buildIsNode(node, type, expressionInstruction));
   }
 
   @override
   void visitIsNot(ast.Send node, ast.Node expression, DartType type, _) {
     HInstruction expressionInstruction = visitAndPop(expression);
     HInstruction instruction = buildIsNode(node, type, expressionInstruction);
     add(instruction);
     push(new HNot(instruction, backend.boolType));
   }
 
   HInstruction buildIsNode(
       ast.Node node, DartType type, HInstruction expression) {
     type = localsHandler.substInContext(type).unaliased;
-    if (type.isFunctionType) {
+    if (type.isMalformed) {
+      String message;
+      if (type is MethodTypeVariableType) {
+        message = "Method type variables are not reified, "
+            "so they cannot be tested with an `is` expression.";
+      } else {
+        assert(type is MalformedType);
+        ErroneousElement element = type.element;
+        message = element.message;
+      }
+      generateTypeError(node, message);
+      HInstruction call = pop();
+      return new HIs.compound(type, expression, call, backend.boolType);
+    } else if (type.isFunctionType) {
       List arguments = [buildFunctionType(type), expression];
       pushInvokeDynamic(
           node,
           new Selector.call(new PrivateName('_isTest', helpers.jsHelperLibrary),
               CallStructure.ONE_ARG),
           null,
           arguments);
       return new HIs.compound(type, expression, pop(), backend.boolType);
     } else if (type.isTypeVariable) {
       HInstruction runtimeType = addTypeVariableReference(type);
@@ skipping 14 matching lines @@
           : graph.addConstantNull(compiler);
       List<HInstruction> inputs = <HInstruction>[
         expression,
         isFieldName,
         representations,
         asFieldName
       ];
       pushInvokeStatic(node, helper, inputs, typeMask: backend.boolType);
       HInstruction call = pop();
       return new HIs.compound(type, expression, call, backend.boolType);
-    } else if (type.isMalformed) {
-      ErroneousElement element = type.element;
-      generateTypeError(node, element.message);
-      HInstruction call = pop();
-      return new HIs.compound(type, expression, call, backend.boolType);
     } else {
       if (backend.hasDirectCheckFor(type)) {
         return new HIs.direct(type, expression, backend.boolType);
       }
       // The interceptor is not always needed.  It is removed by optimization
       // when the receiver type or tested type permit.
       return new HIs.raw(
           type, expression, invokeInterceptor(expression), backend.boolType);
     }
   }
@@ skipping 1445 matching lines @@
       // identifier that refers to the class/typedef) as a constant.
       stack.add(addConstant(node.selector));
     } else {
       stack.add(addConstant(node));
     }
   }
 
   /// Generate the literal for [typeVariable] in the current context.
   void generateTypeVariableLiteral(
       ast.Send node, TypeVariableType typeVariable) {
-    DartType type = localsHandler.substInContext(typeVariable);
-    HInstruction value = analyzeTypeArgument(type,
-        sourceInformation: sourceInformationBuilder.buildGet(node));
-    pushInvokeStatic(node, helpers.runtimeTypeToString, [value],
-        typeMask: backend.stringType);
-    pushInvokeStatic(node, helpers.createRuntimeType, [pop()]);
+    // GENERIC_METHODS: This provides thin support for method type variables
+    // by treating them as malformed when evaluated as a literal. For full
+    // support of generic methods this must be revised.
+    if (typeVariable is MethodTypeVariableType) {
+      generateTypeError(node, "Method type variables are not reified");
+    } else {
+      DartType type = localsHandler.substInContext(typeVariable);
+      HInstruction value = analyzeTypeArgument(type,
+          sourceInformation: sourceInformationBuilder.buildGet(node));
+      pushInvokeStatic(node, helpers.runtimeTypeToString, [value],
+          typeMask: backend.stringType);
+      pushInvokeStatic(node, helpers.createRuntimeType, [pop()]);
+    }
   }
 
   /// Generate a call to a type literal.
   void generateTypeLiteralCall(ast.Send node) {
     // This send is of the form 'e(...)', where e is resolved to a type
     // reference. We create a regular closure call on the result of the type
     // reference instead of creating a NoSuchMethodError to avoid pulling it
     // in if it is not used (e.g., in a try/catch).
     HInstruction target = pop();
     generateCallInvoke(node, target,
@@ skipping 3241 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;
 }