Support checking of malbounded types.

sdk/lib/_internal/compiler/implementation/resolution/members.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.
 
 part of resolution;
 
 abstract class TreeElements {
   Element get currentElement;
   Setlet<Node> get superUses;
 
@@ skipping 1761 matching lines @@
         compiler.cancel("unexpected element kind ${element.kind}",
                         node: node);
       }
       // TODO(johnniwinther): We should not resolve type annotations after the
       // resolution queue has been closed. Currently the dart backend does so.
       // Remove the guarded when this is fixed.
       if (!compiler.enqueuer.resolution.queueIsClosed &&
           addTypeVariableBoundsCheck) {
         visitor.addDeferredAction(
             visitor.enclosingElement,
-            () => checkTypeVariableBounds(node, type));
+            () => checkTypeVariableBounds(visitor.mapping, node, type));
       }
     }
     visitor.useType(node, type);
     return type;
   }
 
   /// Checks the type arguments of [type] against the type variable bounds.
-  void checkTypeVariableBounds(TypeAnnotation node, GenericType type) {
-    TypeDeclarationElement element = type.element;
-    Link<DartType> typeArguments = type.typeArguments;
-    Link<DartType> typeVariables = element.typeVariables;
-    while (!typeVariables.isEmpty && !typeArguments.isEmpty) {
-      TypeVariableType typeVariable = typeVariables.head;
-      DartType bound = typeVariable.element.bound.subst(
-          type.typeArguments, element.typeVariables);
-      DartType typeArgument = typeArguments.head;
+  void checkTypeVariableBounds(TreeElements elements,
+                               TypeAnnotation node, GenericType type) {
+    void checkTypeVariableBound(_, DartType typeArgument,
+                                   TypeVariableType typeVariable,
+                                   DartType bound) {
+      compiler.backend.registerTypeVariableBoundCheck(elements);
       if (!compiler.types.isSubtype(typeArgument, bound)) {
         compiler.reportWarningCode(node,
             MessageKind.INVALID_TYPE_VARIABLE_BOUND,
             {'typeVariable': typeVariable,
              'bound': bound,
              'typeArgument': typeArgument,
-             'thisType': element.thisType});
+             'thisType': type.element.thisType});
       }
-      typeVariables = typeVariables.tail;
-      typeArguments = typeArguments.tail;
-    }
+    };
+
+    compiler.types.checkTypeVariableBounds(type, checkTypeVariableBound);
   }
 
   /**
    * Resolves the type arguments of [node] and adds these to [arguments].
    *
    * Returns [: true :] if the number of type arguments did not match the
    * number of type variables.
    */
   bool resolveTypeArguments(
       MappingVisitor visitor,
@@ skipping 2861 matching lines @@
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(Compiler compiler, Node node,
                       Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), compiler, node);
 }