Add type arguments to constants.

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;
   Set<Node> get superUses;
 
@@ skipping 2601 matching lines @@
     if (!callSelector.applies(constructor, compiler)) {
       warnArgumentMismatch(node.send, constructor);
       compiler.backend.registerThrowNoSuchMethod(mapping);
     }
 
     // [constructor] might be the implementation element
     // and only declaration elements may be registered.
     world.registerStaticUse(constructor.declaration);
     ClassElement cls = constructor.getEnclosingClass();
     InterfaceType type = mapping.getType(node);
+    if (node.isConst() && type.containsTypeVariables) {
+      compiler.reportErrorCode(node.send.selector,
+                               MessageKind.TYPE_VARIABLE_IN_CONSTANT);
+    }
     world.registerInstantiatedType(type, mapping);
     if (constructor.isFactoryConstructor() && !type.typeArguments.isEmpty) {
       world.registerFactoryWithTypeArguments(mapping);
     }
     if (cls.isAbstract(compiler)) {
       compiler.backend.registerAbstractClassInstantiation(mapping);
     }
 
     if (isSymbolConstructor) {
       if (node.isConst()) {
@@ skipping 88 matching lines @@
       } else {
         typeArgument = resolveTypeRequired(nodes.head);
         for (nodes = nodes.tail; !nodes.isEmpty; nodes = nodes.tail) {
           error(nodes.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT);
           resolveTypeRequired(nodes.head);
         }
       }
     }
     DartType listType;
     if (typeArgument != null) {
+      if (node.isConst() && typeArgument.containsTypeVariables) {
+        compiler.reportErrorCode(arguments.nodes.head,
+            MessageKind.TYPE_VARIABLE_IN_CONSTANT);
+      }
       listType = new InterfaceType(compiler.listClass,
                                    new Link<DartType>.fromList([typeArgument]));
     } else {
       compiler.listClass.computeType(compiler);
       listType = compiler.listClass.rawType;
     }
     mapping.setType(node, listType);
     world.registerInstantiatedType(listType, mapping);
     visit(node.elements);
   }
@@ skipping 195 matching lines @@
       }
     }
     DartType mapType;
     if (valueTypeArgument != null) {
       mapType = new InterfaceType(compiler.mapClass,
           new Link<DartType>.fromList([keyTypeArgument, valueTypeArgument]));
     } else {
       compiler.mapClass.computeType(compiler);
       mapType = compiler.mapClass.rawType;
     }
+    if (node.isConst() && mapType.containsTypeVariables) {
+      compiler.reportErrorCode(arguments,
+          MessageKind.TYPE_VARIABLE_IN_CONSTANT);
+    }
     mapping.setType(node, mapType);
     world.registerInstantiatedClass(compiler.mapClass, mapping);
     if (node.isConst()) {
       compiler.backend.registerConstantMap(mapping);
     }
     node.visitChildren(this);
   }
 
   visitLiteralMapEntry(LiteralMapEntry node) {
     node.visitChildren(this);
@@ skipping 1079 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }