Substitution implemented for the class hierarchy.

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 551 matching lines @@
     return null;  // If there was no redirection always return null.
   }
 }
 
 class CommonResolverVisitor<R> extends AbstractVisitor<R> {
   final Compiler compiler;
 
   CommonResolverVisitor(Compiler this.compiler);
 
   R visitNode(Node node) {
-    cancel(node, 'internal error');
+    cancel(node,
+           'internal error: Unhandled node: ${node.getObjectDescription()}');
   }
 
   R visitEmptyStatement(Node node) => null;
 
   /** Convenience method for visiting nodes that may be null. */
   R visit(Node node) => (node == null) ? null : node.accept(this);
 
   void error(Node node, MessageKind kind, [arguments = const []]) {
     ResolutionError message  = new ResolutionError(kind, arguments);
     compiler.reportError(node, message);
@@ skipping 1064 matching lines @@
   ClassElement classElement;
 
   ClassResolverVisitor(Compiler compiler, LibraryElement library,
                        ClassElement this.classElement)
     : context = new TopScope(library),
       super(compiler);
 
   Type visitClassNode(ClassNode node) {
     compiler.ensure(classElement !== null);
     compiler.ensure(!classElement.isResolved);
-    final Link<Node> parameters =
+
+    classElement.ensureParametersAndType(compiler);
+    context = new TypeVariablesScope(context, classElement);
+
+    // Resolve the bounds of type variables.
+    Link<Node> parameters =
         node.typeParameters !== null ? node.typeParameters.nodes
                                      : const EmptyLink<TypeVariable>();
-    // Create types and elements for type variable.
     for (Link<Node> link = parameters; !link.isEmpty(); link = link.tail) {
       TypeVariable typeNode = link.head;
       SourceString variableName = typeNode.name.source;
-      TypeVariableType variableType = new TypeVariableType(variableName);
-      TypeVariableElement variableElement =
-          new TypeVariableElement(variableName, classElement, node,
-                                  variableType);
-      variableType.element = variableElement;
-      classElement.typeParameters[variableName] = variableElement;
-      context = new TypeVariablesScope(context, classElement);
-    }
-    // Resolve the bounds of type variables.
-    for (Link<Node> link = parameters; !link.isEmpty(); link = link.tail) {
-      TypeVariable typeNode = link.head;
-      SourceString variableName = typeNode.name.source;
       TypeVariableElement variableElement =
           classElement.typeParameters[variableName];
       if (typeNode.bound !== null) {
         Type boundType = visit(typeNode.bound);
         if (boundType !== null && boundType.element == variableElement) {
           warning(node, MessageKind.CYCLIC_TYPE_VARIABLE,
                   [variableElement.name]);
         } else if (boundType !== null) {
           variableElement.bound = boundType;
         } else {
           variableElement.bound = compiler.objectClass.computeType(compiler);
         }
       }
     }
+
     // Find super type.
     Type supertype = visit(node.superclass);
     if (supertype !== null && supertype.element.isExtendable()) {
       classElement.supertype = supertype;
       if (isBlackListed(supertype)) {
         error(node.superclass, MessageKind.CANNOT_EXTEND, [supertype]);
       }
     } else if (supertype !== null) {
       error(node.superclass, MessageKind.TYPE_NAME_EXPECTED);
     }
@@ skipping 23 matching lines @@
       } else {
         error(link.head, MessageKind.TYPE_NAME_EXPECTED);
       }
     }
     calculateAllSupertypes(classElement, new Set<ClassElement>());
     addDefaultConstructorIfNeeded(classElement);
     return classElement.computeType(compiler);
   }
 
   Type visitTypeAnnotation(TypeAnnotation node) {
-    return visit(node.typeName);
+    Type type = visit(node.typeName);
+    if (type is! InterfaceType) {
+      // TODO(johnniwinther): Handle function types.
+      return type;
+    }
+    if (node.typeArguments === null) {
+      if (type.arguments.isEmpty()) {
+        return type;
+      }
+      // Return the 'raw' version, for example List for List<E>.
+      return new InterfaceType(type.element);
+    }
+    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());
+  }
+
+  Type visitTypeVariable(TypeVariable node) {
+    return visit(node.name);
   }
 
   Type visitIdentifier(Identifier node) {
     Element element = context.lookup(node.source);
     if (element === null) {
       error(node, MessageKind.CANNOT_RESOLVE_TYPE, [node]);
       return null;
     } else if (!element.impliesType() && !element.isTypeVariable()) {
       error(node, MessageKind.NOT_A_TYPE, [node]);
       return null;
     } else {
       if (element.isClass()) {
         compiler.resolver.toResolve.add(element);
       }
       if (element.isTypeVariable()) {
         TypeVariableElement variableElement = element;
         return variableElement.type;
       } else if (element.isTypedef()) {
         compiler.unimplemented('visitIdentifier for typedefs', node: node);
       } else {
-        // TODO(ngeoffray): Use type variables.
+        // Type variables are handled in [visitTypeAnnotation].
         return element.computeType(compiler);
       }
     }
     return null;
   }
 
   Type visitSend(Send node) {
     Identifier prefix = node.receiver.asIdentifier();
     if (prefix === null) {
       error(node.receiver, MessageKind.NOT_A_PREFIX, [node.receiver]);
@@ skipping 27 matching lines @@
             [cls.name]);
       cls.allSupertypes = const EmptyLink<Type>();
     } else {
       cls.ensureResolved(compiler);
       calculateAllSupertypes(cls, seen);
     }
     return cls.allSupertypes;
   }
 
   void calculateAllSupertypes(ClassElement cls, Set<ClassElement> seen) {
-    // TODO(karlklose): substitute type variables.
     // TODO(karlklose): check if type arguments match, if a classelement occurs
     //                  more than once in the supertypes.
     if (cls.allSupertypes !== null) return;
-    final Type supertype = cls.supertype;
+    final InterfaceType supertype = cls.supertype;
     if (seen.contains(cls)) {
       error(cls.parseNode(compiler),
             MessageKind.CYCLIC_CLASS_HIERARCHY,
             [cls.name]);
       cls.allSupertypes = const EmptyLink<Type>();
     } else if (supertype != null) {
       seen.add(cls);
+      ClassElement supertypeElement = supertype.element;
       Link<Type> superSupertypes =
-          getOrCalculateAllSupertypes(supertype.element, seen);
-      Link<Type> supertypes = new Link<Type>(supertype, superSupertypes);
+          getOrCalculateAllSupertypes(supertypeElement, seen);
+      var superTypesBuilder = new LinkBuilder<Type>();
+      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));
+      }
+
+      Link<Type> supertypes = superTypesBuilder.toLink();
       for (Link<Type> interfaces = cls.interfaces;
            !interfaces.isEmpty();
            interfaces = interfaces.tail) {
         Element element = interfaces.head.element;
         Link<Type> interfaceSupertypes =
             getOrCalculateAllSupertypes(element, seen);
         supertypes = supertypes.reversePrependAll(interfaceSupertypes);
         supertypes = supertypes.prepend(interfaces.head);
       }
       seen.remove(cls);
@@ skipping 385 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";
   }
 }