Substitution handled for most Send nodes.

lib/compiler/implementation/resolver.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.
 
 interface TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
   Type getType(TypeAnnotation annotation);
 }
 
@@ skipping 1339 matching lines @@
     world.registerInstantiatedClass(cls);
     cls.forEachInstanceField(
         includeBackendMembers: false,
         includeSuperMembers: true,
         f: (ClassElement enclosingClass, Element member) {
           world.addToWorkList(member);
         });
     return null;
   }
 
-  TypeAnnotation getTypeAnnotationFromSend(Send send) {
-    if (send.selector.asTypeAnnotation() !== null) {
-      return send.selector;
-    } else if (send.selector.asSend() !== null) {
-      Send selector = send.selector;
-      if (selector.receiver.asTypeAnnotation() !== null) {
-        return selector.receiver;
-      }
-    } else {
-      compiler.internalError("malformed send in new expression");
-    }
-  }
-
   FunctionElement resolveConstructor(NewExpression node) {
     FunctionElement constructor =
         node.accept(new ConstructorResolver(compiler, this));
-    TypeAnnotation annotation = getTypeAnnotationFromSend(node.send);
+    TypeAnnotation annotation = node.getTypeAnnotation();
+    if (annotation == null) {
+      compiler.internalError("malformed send in new expression");
+    }
     Type type = resolveTypeRequired(annotation);
     if (constructor === null) {
       Element resolved = (type != null) ? type.element : null;
       if (resolved !== null && resolved.kind === ElementKind.TYPE_VARIABLE) {
         error(node, MessageKind.TYPE_VARIABLE_AS_CONSTRUCTOR);
         return null;
       } else {
         error(node.send, MessageKind.CANNOT_FIND_CONSTRUCTOR, [node.send]);
         return null;
       }
+    } else {
+      useType(annotation, type);
     }
     return constructor;
   }
 
   Type resolveTypeRequired(TypeAnnotation node) {
     bool old = typeRequired;
     typeRequired = true;
     Type result = resolveTypeAnnotation(node);
     typeRequired = old;
     return result;
@@ skipping 325 matching lines @@
     addDefaultConstructorIfNeeded(classElement);
     return classElement.computeType(compiler);
   }
 
   Type visitTypeAnnotation(TypeAnnotation node) {
     Type type = visit(node.typeName);
     if (type is! InterfaceType) {
       // TODO(johnniwinther): Handle function types.
       return type;
     }
+    int typeParameterCount = type.element.typeParameters.length;
     if (node.typeArguments === null) {
-      if (type.arguments.isEmpty()) {
+      if (type.typeArguments.isEmpty() || typeParameterCount == 0) {
         return type;
       }
       // Return the 'raw' version, for example List for List<E>.
       return new InterfaceType(type.element);
     }
+    int typeArgumentCount = node.typeArguments.length();
+    if (typeArgumentCount < typeParameterCount) {
+      error(node.typeArguments, MessageKind.MISSING_TYPE_ARGUMENT);
+    } else if (typeArgumentCount > typeParameterCount) {
+      error(node.typeArguments, MessageKind.ADDITIONAL_TYPE_ARGUMENT);
+    }
     var typeArguments = new LinkBuilder<Type>();
     var link = node.typeArguments.nodes;
     while (!link.isEmpty()) {
       typeArguments.addLast(visit(link.head));
       link = link.tail;
     }
     // TODO(johnniwinther): Check argument count and bounds.
     return new InterfaceType(type.element, typeArguments.toLink());
   }
 
@@ skipping 40 matching lines @@
     PrefixElement prefixElement = element;
     Identifier selector = node.selector.asIdentifier();
     var e = prefixElement.lookupLocalMember(selector.source);
     if (e === null || !e.impliesType()) {
       error(node.selector, MessageKind.CANNOT_RESOLVE_TYPE, [node.selector]);
       return null;
     }
     return e.computeType(compiler);
   }
 
-  Link<Type> getOrCalculateAllSupertypes(ClassElement cls,
-                                         [Set<ClassElement> seen]) {
-    Link<Type> allSupertypes = cls.allSupertypes;
+  Link<InterfaceType> getOrCalculateAllSupertypes(ClassElement cls,
+                                                  [Set<ClassElement> seen]) {
+    Link<InterfaceType> allSupertypes = cls.allSupertypes;
     if (allSupertypes !== null) return allSupertypes;
     if (seen === null) {
       seen = new Set<ClassElement>();
     }
     if (seen.contains(cls)) {
       error(cls.parseNode(compiler),
             MessageKind.CYCLIC_CLASS_HIERARCHY,
             [cls.name]);
-      cls.allSupertypes = const EmptyLink<Type>();
+      cls.allSupertypes = const EmptyLink<InterfaceType>();
     } else {
       cls.ensureResolved(compiler);
       calculateAllSupertypes(cls, seen);
     }
     return cls.allSupertypes;
   }
 
   void calculateAllSupertypes(ClassElement cls, Set<ClassElement> seen) {
     // TODO(karlklose): check if type arguments match, if a classelement occurs
     //                  more than once in the supertypes.
     if (cls.allSupertypes !== null) return;
     final InterfaceType supertype = cls.supertype;
     if (seen.contains(cls)) {
       error(cls.parseNode(compiler),
             MessageKind.CYCLIC_CLASS_HIERARCHY,
             [cls.name]);
-      cls.allSupertypes = const EmptyLink<Type>();
+      cls.allSupertypes = const EmptyLink<InterfaceType>();
     } else if (supertype != null) {
       seen.add(cls);
       ClassElement supertypeElement = supertype.element;
-      Link<Type> superSupertypes =
+      Link<InterfaceType> superSupertypes =
           getOrCalculateAllSupertypes(supertypeElement, seen);
-      var superTypesBuilder = new LinkBuilder<Type>();
+      var superTypesBuilder = new LinkBuilder<InterfaceType>();
       superTypesBuilder.addLast(supertype);
 
       // Substitute type variables in supertypes.
-      var superTypeParameters = <Type>[];
-      var typeVariableElements = supertypeElement.typeParameters.getValues();
-      for (TypeVariableElement typeVariableElement in typeVariableElements) {
-        superTypeParameters.add(typeVariableElement.type);
-      }
       for (Type superSupertype in superSupertypes) {
-        superTypesBuilder.addLast(superSupertype.subst(
-            supertype.arguments, superTypeParameters));
+        superTypesBuilder.addLast(superSupertype.subst(compiler,
+            supertype.typeArguments, supertypeElement.typeParameters));
       }
 
-      Link<Type> supertypes = superTypesBuilder.toLink();
-      for (Link<Type> interfaces = cls.interfaces;
+      Link<InterfaceType> supertypes = superTypesBuilder.toLink();
+      for (Link<InterfaceType> interfaces = cls.interfaces;
            !interfaces.isEmpty();
            interfaces = interfaces.tail) {
         Element element = interfaces.head.element;
-        Link<Type> interfaceSupertypes =
+        Link<InterfaceType> interfaceSupertypes =
             getOrCalculateAllSupertypes(element, seen);
         supertypes = supertypes.reversePrependAll(interfaceSupertypes);
         supertypes = supertypes.prepend(interfaces.head);
       }
       seen.remove(cls);
       cls.allSupertypes = supertypes;
     } else {
-      cls.allSupertypes = const EmptyLink<Type>();
+      cls.allSupertypes = const EmptyLink<InterfaceType>();
     }
   }
 
   /**
    * Add a synthetic nullary constructor if there are no other
    * constructors.
    */
   void addDefaultConstructorIfNeeded(ClassElement element) {
     if (element.constructors.length != 0) return;
     SynthesizedConstructorElement constructor =
@@ skipping 372 matching lines @@
 
   TopScope(LibraryElement library) : super(null, library);
   Element lookup(SourceString name) {
     return library.find(name);
   }
 
   Element add(Element newElement) {
     throw "Cannot add an element in the top scope";
   }
 }