Unify ClassElement and TypedefElement.

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 715 matching lines @@
       } else {
         return null;
       }
     } else {
       return scope.lookup(typeName.source);
     }
   }
 
   // TODO(johnniwinther): Change  [onFailure] and [whenResolved] to use boolean
   // flags instead of closures.
+  // TODO(johnniwinther): Should never return [null] but instead an erroneous
+  // type.
   Type resolveTypeAnnotation(TypeAnnotation node,
                              [Scope inScope, ClassElement inClass,
                               onFailure(Node, MessageKind, [List arguments]),
                               whenResolved(Node, Type)]) {
     if (onFailure === null) {
       onFailure = (n, k, [arguments]) {};
     }
     if (whenResolved === null) {
       whenResolved = (n, t) {};
     }
@@ skipping 15 matching lines @@
       onFailure(node, MessageKind.CANNOT_RESOLVE_TYPE, [node.typeName]);
     } else if (!element.impliesType()) {
       onFailure(node, MessageKind.NOT_A_TYPE, [node.typeName]);
     } else {
       if (element === compiler.types.voidType.element ||
           element === compiler.types.dynamicType.element) {
         type = element.computeType(compiler);
       } else if (element.isClass()) {
         ClassElement cls = element;
         if (!cls.isResolved) compiler.resolveClass(cls);
-        LinkBuilder<Type> arguments = new LinkBuilder<Type>();
-        if (node.typeArguments !== null) {
-          int index = 0;
-          for (Link<Node> typeArguments = node.typeArguments.nodes;
-               !typeArguments.isEmpty();
-               typeArguments = typeArguments.tail) {
-            if (++index > cls.typeParameters.length) {
-              onFailure(typeArguments.head,
-                        MessageKind.ADDITIONAL_TYPE_ARGUMENT);
-            }
-            Type argType = resolveTypeAnnotationInContext(scope,
-                                                          typeArguments.head,
-                                                          onFailure,
-                                                          whenResolved);
-            arguments.addLast(argType);
-          }
-          if (index < cls.typeParameters.length) {
-            onFailure(node.typeArguments, MessageKind.MISSING_TYPE_ARGUMENT);
-          }
-        }
-        if (cls.typeParameters.length == 0) {
-          // Return the canonical type if it has no type parameters.
+        Link<Type> arguments =
+            resolveTypeArguments(node, cls.typeVariables, scope,
+                                 onFailure, whenResolved);
+        if (cls.typeVariables.isEmpty() && arguments.isEmpty()) {
+          // Use the canonical type if it has no type parameters.
           type = cls.computeType(compiler);
         } else {
-          type = new InterfaceType(cls, arguments.toLink());
+          type = new InterfaceType(cls, arguments);
         }
       } else if (element.isTypedef()) {
         type = element.computeType(compiler);
       } else if (element.isTypeVariable()) {
         type = element.computeType(compiler);
       } else {
         compiler.cancel("unexpected element kind ${element.kind}",
                         node: node);
       }
     }
     whenResolved(node, type);
     return type;
   }
+
+  Link<Type> resolveTypeArguments(TypeAnnotation node,
+                                  Link<Type> typeVariables,
+                                  Scope scope, onFailure, whenResolved) {
+    if (node.typeArguments == null) {
+      return const EmptyLink<Type>();
+    }
+    var arguments = new LinkBuilder<Type>();
+    for (Link<Node> typeArguments = node.typeArguments.nodes;
+         !typeArguments.isEmpty();
+         typeArguments = typeArguments.tail) {
+      if (typeVariables.isEmpty()) {
+        onFailure(typeArguments.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT);
+      }
+      Type argType = resolveTypeAnnotationInContext(scope,
+                                                    typeArguments.head,
+                                                    onFailure,
+                                                    whenResolved);
+      arguments.addLast(argType);
+      if (!typeVariables.isEmpty()) {
+        typeVariables = typeVariables.tail;
+      }
+    }
+    if (!typeVariables.isEmpty()) {
+      onFailure(node.typeArguments, MessageKind.MISSING_TYPE_ARGUMENT);
+    }
+    return arguments.toLink();
+  }
 }
 
 class ResolverVisitor extends CommonResolverVisitor<Element> {
   final TreeElementMapping mapping;
   final Element enclosingElement;
   final TypeResolver typeResolver;
   bool inInstanceContext;
   Scope scope;
   ClassElement currentClass;
   bool typeRequired = false;
@@ skipping 818 matching lines @@
     }
     visitIn(node.formals, blockScope);
     visitIn(node.block, blockScope);
   }
 
   visitTypedef(Typedef node) {
     unimplemented(node, 'typedef');
   }
 }
 
-class ClassResolverVisitor extends CommonResolverVisitor<Type> {
-  Scope scope;
-  ClassElement classElement;
+class ClassResolverVisitor extends TypeDefinitionVisitor {
+  ClassElement get element() => super.element;
 
-  ClassResolverVisitor(Compiler compiler,
-                       ClassElement classElement)
-      : this.classElement = classElement,
-        scope = classElement.buildEnclosingScope(),
-        super(compiler);
+  ClassResolverVisitor(Compiler compiler, ClassElement classElement)
+    : super(compiler, classElement);
 
   Type visitClassNode(ClassNode node) {
-    compiler.ensure(classElement !== null);
-    compiler.ensure(!classElement.isResolved);
-    final 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;
-      scope = new TypeDeclarationScope(scope, 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);
-        }
-      }
-    }
+    compiler.ensure(element !== null);
+    compiler.ensure(!element.isResolved);
+
+    InterfaceType type = element.computeType(compiler);
+    scope = new TypeDeclarationScope(scope, element);
+    // TODO(ahe): It is not safe to call resolveTypeVariableBounds yet.
+    // As a side-effect, this may get us back here trying to
+    // resolve this class again.
+    resolveTypeVariableBounds(node.typeParameters);
+
     // Find super type.
     Type supertype = visit(node.superclass);
     if (supertype !== null && supertype.element.isExtendable()) {
-      classElement.supertype = supertype;
+      element.supertype = supertype;
       if (isBlackListed(supertype)) {
         error(node.superclass, MessageKind.CANNOT_EXTEND, [supertype]);
       }
     } else if (supertype !== null) {
       error(node.superclass, MessageKind.TYPE_NAME_EXPECTED);
     }
     final objectElement = compiler.objectClass;
-    if (classElement !== objectElement && classElement.supertype === null) {
+    if (element !== objectElement && element.supertype === null) {
       if (objectElement === null) {
         compiler.internalError("Internal error: cannot resolve Object",
                                node: node);
       } else if (!objectElement.isResolved) {
         compiler.resolver.toResolve.add(objectElement);
       }
-      classElement.supertype = new InterfaceType(objectElement);
+      // TODO(ahe): This should be objectElement.computeType(...).
+      element.supertype = new InterfaceType(objectElement);
     }
     if (node.defaultClause !== null) {
-      classElement.defaultClass = visit(node.defaultClause);
+      element.defaultClass = visit(node.defaultClause);
     }
     for (Link<Node> link = node.interfaces.nodes;
          !link.isEmpty();
          link = link.tail) {
       Type interfaceType = visit(link.head);
       if (interfaceType !== null && interfaceType.element.isExtendable()) {
-        classElement.interfaces =
-            classElement.interfaces.prepend(interfaceType);
+        element.interfaces =
+            element.interfaces.prepend(interfaceType);
         if (isBlackListed(interfaceType)) {
           error(link.head, MessageKind.CANNOT_IMPLEMENT, [interfaceType]);
         }
       } else {
         error(link.head, MessageKind.TYPE_NAME_EXPECTED);
       }
     }
-    calculateAllSupertypes(classElement, new Set<ClassElement>());
-    addDefaultConstructorIfNeeded(classElement);
-    return classElement.computeType(compiler);
+    calculateAllSupertypes(element, new Set<ClassElement>());
+    addDefaultConstructorIfNeeded(element);
+    return element.computeType(compiler);
   }
 
   Type visitTypeAnnotation(TypeAnnotation node) {
     return visit(node.typeName);
   }
 
   Type visitIdentifier(Identifier node) {
     Element element = scope.lookup(node.source);
     if (element === null) {
       error(node, MessageKind.CANNOT_RESOLVE_TYPE, [node]);
@@ skipping 103 matching lines @@
     constructor.type = new FunctionType(returnType, const EmptyLink<Type>(),
                                         constructor);
     constructor.cachedNode =
       new FunctionExpression(new Identifier(element.position()),
                              new NodeList.empty(),
                              new Block(new NodeList.empty()),
                              null, null, null, null);
   }
 
   isBlackListed(Type type) {
-    LibraryElement lib = classElement.getLibrary();
+    LibraryElement lib = element.getLibrary();
     return
       lib !== compiler.coreLibrary &&
       lib !== compiler.coreImplLibrary &&
       lib !== compiler.jsHelperLibrary &&
       (type.element === compiler.dynamicClass ||
        type.element === compiler.boolClass ||
        type.element === compiler.numClass ||
        type.element === compiler.intClass ||
        type.element === compiler.doubleClass ||
        type.element === compiler.stringClass ||
        type.element === compiler.nullClass ||
        type.element === compiler.functionClass);
   }
 }
 
+class TypeDefinitionVisitor extends CommonResolverVisitor<Type> {
+  Scope scope;
+  TypeDeclarationElement element;
+  TypeResolver typeResolver;
+
+  TypeDefinitionVisitor(Compiler compiler, TypeDeclarationElement element)
+      : this.element = element,
+        scope = element.enclosingElement.buildScope(),
+        typeResolver = new TypeResolver(compiler),
+        super(compiler);
+
+  void resolveTypeVariableBounds(NodeList node) {
+    if (node === null) return;
+
+    var nameSet = new Set<SourceString>();
+    // Resolve the bounds of type variables.
+    Link<Type> typeLink = element.typeVariables;
+    Link<Node> nodeLink = node.nodes;
+    while (!nodeLink.isEmpty()) {
+      TypeVariableType typeVariable = typeLink.head;
+      SourceString typeName = typeVariable.name;
+      TypeVariable typeNode = nodeLink.head;
+      if (nameSet.contains(typeName)) {
+        error(typeNode, MessageKind.DUPLICATE_TYPE_VARIABLE_NAME, [typeName]);
+      }
+      nameSet.add(typeName);
+
+      TypeVariableElement variableElement = typeVariable.element;
+      if (typeNode.bound !== null) {
+        Type boundType = typeResolver.resolveTypeAnnotation(
+            typeNode.bound, inScope: scope, onFailure: warning);
+        if (boundType !== null && boundType.element == variableElement) {
+          // TODO(johnniwinther): Check for more general cycles, like
+          // [: <A extends B, B extends C, C extends B> :].
+          warning(node, MessageKind.CYCLIC_TYPE_VARIABLE,
+                  [variableElement.name]);
+        } else if (boundType !== null) {
+          variableElement.bound = boundType;
+        } else {
+          // TODO(johnniwinther): Should be an erroneous type.
+          variableElement.bound = compiler.objectClass.computeType(compiler);
+        }
+      } else {
+        variableElement.bound = compiler.objectClass.computeType(compiler);
+      }
+      nodeLink = nodeLink.tail;
+      typeLink = typeLink.tail;
+    }
+    assert(typeLink.isEmpty());
+  }
+}
+
 class VariableDefinitionsVisitor extends CommonResolverVisitor<SourceString> {
   VariableDefinitions definitions;
   ResolverVisitor resolver;
   ElementKind kind;
   VariableListElement variables;
 
   VariableDefinitionsVisitor(Compiler compiler,
                              this.definitions, this.resolver, this.kind)
     : super(compiler)
   {
@@ skipping 277 matching lines @@
 }
 
 /**
  * [TypeDeclarationScope] defines the outer scope of a type declaration in
  * which the declared type variables and the entities in the enclosing scope are
  * available but where declared and inherited members are not available. This
  * scope is only used for class/interface declarations during resolution of the
  * class hierarchy. In all other cases [ClassScope] is used.
  */
 class TypeDeclarationScope extends Scope {
-  ClassElement get element() => super.element;
+  TypeDeclarationElement get element() => super.element;
 
-  TypeDeclarationScope(Scope parent, ClassElement element)
-      : super(parent, element);
+  TypeDeclarationScope(parent, TypeDeclarationElement element)
+      : super(parent, element) {
+    assert(parent !== null);
+  }
 
   Element add(Element newElement) {
     throw "Cannot add element to TypeDeclarationScope";
   }
 
+  /**
+   * Looks up [name] within the type variables declared in [element].
+   */
+  Element lookupTypeVariable(SourceString name) {
+    return null;
+  }
+
   Element lookup(SourceString name) {
-    Element result = element.lookupTypeParameter(name);
-    if (result !== null) return result;
-    if (parent !== null) return parent.lookup(name);
+    Link<Type> typeVariableLink = element.typeVariables;
+    while (!typeVariableLink.isEmpty()) {
+      TypeVariableType typeVariable = typeVariableLink.head;
+      if (typeVariable.name == name) {
+        return typeVariable.element;
+      }
+      typeVariableLink = typeVariableLink.tail;
+    }
+
+    return parent.lookup(name);
   }
 
   String toString() =>
-      '$element${element.typeParameters.getKeys()} > $parent';
+      '$element${element.typeVariables} > $parent';
 }
 
 class MethodScope extends Scope {
   final Map<SourceString, Element> elements;
 
   MethodScope(Scope parent, Element element)
-    : super(parent, element), this.elements = new Map<SourceString, Element>();
+      : super(parent, element),
+        this.elements = new Map<SourceString, Element>() {
+    assert(parent !== null);
+  }
 
   Element lookup(SourceString name) {
     Element found = elements[name];
     if (found !== null) return found;
     return parent.lookup(name);
   }
 
   Element add(Element newElement) {
     if (elements.containsKey(newElement.name)) {
       return elements[newElement.name];
@@ skipping 42 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";
   }
   String toString() => '$element';
 }